diff --git a/.changeset/status-pages.md b/.changeset/status-pages.md
new file mode 100644
index 00000000..c2e43d5e
--- /dev/null
+++ b/.changeset/status-pages.md
@@ -0,0 +1,6 @@
+---
+"@cloudhal/astro-renderer": patch
+"@cloudhal/cli": patch
+---
+
+Status pages (RFC-0043 §1, #117). A site that cannot show its pages answers with one small, translated, self-contained page instead of plain text: `not-published` (503, `Retry-After: 3600`, `noindex`) before the first publish, `preview-expired` (410) for a preview link that does not verify, `unavailable` (503) for a Worker that serves no site, and `error` (500, with the `cf-ray` as a reference) when a render fails. The Site Worker answers them before Astro runs, every one `no-store` with its own CSP; `GET /__cloudhal/health` answers `{ "ok": true, "state": "published" | "not-published" }` in the admin's `/api/health` shape. The page is in the request's locale (host or path prefix, then the site default, then English) for every language Studio speaks, right to left where needed, through the same `pnpm i18n:export/import` flow as Studio's catalogs. A theme may restyle it with an optional `statusPage` export in `src/theme.ts` (`@cloudhal/astro-renderer/status-page`), which falls back to the built-in page on a throw, a slow answer or an oversized document and never runs for `error`; `cloudhal dev` draws each state at `/__cloudhal/status/<state>`. The blog starter's routes use `statusPage`/`statusPlain` as their own fallback. **Behaviour change:** an invalid or expired preview link now answers 410 instead of silently showing the published page.
diff --git a/AGENTS.md b/AGENTS.md
index 9b797768..04ec7fc0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -30,7 +30,7 @@ pnpm i18n:export / pnpm i18n:import [--locale xx]  # translations as nested ICU
 - `packages/storage` — `SqlDriver`/`BlobStore` + adapters (`sqlite`, `d1`, `do-sqlite`, `fs`, `r2`; `SqlBlobStore`, `LayeredBlobStore`, `FetcherBlobStore` at the root) + migrations (`migrations/*.ts`, plain SQL). Conformance suites in `src/testing.ts`.
 - `packages/core-ts` — `SiteGraphStore` (CAS on `rev`, snapshots, diff, publish, rollback). Behavioural suite in `src/testing.ts` runs on sqlite and Miniflare D1. `./local` opens the offline store; `seedStarterSite` seeds a demo. `./surfaces` is RFC-0020's generative UI: the catalog (primitives + block types), eval-free surface checks, bindings, repairs, JSON Patch (`patchPage`), `catalogPrompt`; `./interop` converts A2UI v0.9 and json-render to and from surfaces; `./design` is RFC-0021's DESIGN.md lint and guidance. `./fields` is RFC-0041's typed custom fields (definition and value checks, `resolveFields`, `formatFieldValue`, the agents' JSON Schema, the conversion table); `src/fields-operations/` runs rename/retype/localize/remove. `search.ts` is RFC-0019's FTS5 site search (index written with the publish batch; articles, pages, terms and authors, RFC-0029); `search-provider.ts` is RFC-0029's `SearchProvider` (`fts5`, `memory`, `withFallback`), set with `SiteGraphStoreOptions.search`; `search-ai.ts` is the experimental Cloudflare AI Search provider (`hybridProvider`, `searchProviderFromEnv`, `cloudhal.json` `search`, docs/guides/search.md).
 - `packages/schedules` — RFC-0008: time model (only `temporal-polyfill/implementation`, `now` injected, never `Temporal.Now`), RRULE subset, release model (`rl1:`), automation/run state, taint and budgets, `runDue`; `./sql` is `SqlScheduleStore`, `./engine` the Temporal-free part core-ts and the site Worker use. Worker-safe; conformance suites in `src/testing.ts` on sqlite and Miniflare D1.
-- `packages/astro-renderer` — `GraphSource` (live/snapshot), `cloudhal()` integration (virtual config + dev route-cache watcher), `.astro` section components (`Surface.astro` for RFC-0020 surfaces; `./surfaces` renders them, `./kit` has the table of contents and reading time; `./fields` and `EntryFields.astro` render typed field values, RFC-0041). Routes live in starters, not here.
+- `packages/astro-renderer` — `GraphSource` (live/snapshot), `cloudhal()` integration (virtual config + dev route-cache watcher), `.astro` section components (`Surface.astro` for RFC-0020 surfaces; `./surfaces` renders them, `./kit` has the table of contents and reading time; `./fields` and `EntryFields.astro` render typed field values, RFC-0041). `./status-page` is RFC-0043's status pages (`statusPage(state, input) → Response`, served by the Site Worker entry before Astro and by `cloudhal dev` at `/__cloudhal/status/<state>`; the optional `statusPage` theme hook; the catalog in `src/status-strings/` where only `en.ts` is hand-edited and the other languages come from `pnpm i18n:import`). Routes live in starters, not here.
 - `packages/cli` — the `cloudhal` CLI (`init`, `dev`, `studio`, `mcp`, `deploy`, `push`, `pull`, `export`, `import`, …; every command is in `src/cli/help.ts`, which `cloudhal --help` prints and the docs site's CLI reference is generated from); TS bin run by Node 24 type stripping. `src/cli.ts` parses flags and dispatches through `COMMANDS`, built from `src/cli/commands-{local,remote,content,ops,site}.ts` (a new command is one handler plus one line in `src/cli/help.ts`). `src/archive/` is RFC-0039's `.cloudhal` container (tar, gzip, manifest, limits), read and written by `src/commands/export.ts` and `import*.ts` (`archive-bundle.ts`, `archive-reassemble.ts`); the starter demo archive `test/fixtures/site-archives/starter-blog.cloudhal` is written by `pnpm demo:archive`, and `pnpm check` fails when it is stale. E2E test spawns the bin (Astro disables dev middleware under `VITEST`). Cloudflare tests run both Workers on workerd via wrangler's `createTestHarness`; test files run serially (shared starter caches).
 - `packages/cloudflare` — the admin Worker (`createAdminWorker`); `./playground` is RFC-0036's playground Worker (`createPlaygroundWorker`, the `PlaygroundSite` Durable Object, signed session cookies). Generated entries must import `@cloudhal/cloudflare/workerd-prelude` first (ADR-0012).
 - `packages/agent-runtime` / `packages/mcp-server` — policy, skills, audit; MCP tools and transports (ADR-0011). `@cloudhal/mcp-server/render` is RFC-0021's `render_page` core: a small DevTools client, the in-page checks and limits; the CLI drives local Chrome with it (`render-chrome.ts`), the admin Worker Browser Rendering (`browser-render.ts`).
diff --git a/packages/astro-renderer/package.json b/packages/astro-renderer/package.json
index d06d3bfb..e45a3129 100644
--- a/packages/astro-renderer/package.json
+++ b/packages/astro-renderer/package.json
@@ -62,7 +62,11 @@
     "./locales": "./src/locales.ts",
     "./locale-middleware": "./src/locale-middleware.ts",
     "./locale-feeds": "./src/locale-feeds.ts",
-    "./not-found": "./src/not-found.ts"
+    "./not-found": "./src/not-found.ts",
+    "./status-page": "./src/status-page.ts",
+    "./status-hook": "./src/status-hook.ts",
+    "./status-serve": "./src/status-serve.ts",
+    "./status-middleware": "./src/status-middleware.ts"
   },
   "files": [
     "dist",
@@ -296,6 +300,22 @@
       "./not-found": {
         "types": "./dist/src/not-found.d.ts",
         "default": "./dist/src/not-found.js"
+      },
+      "./status-page": {
+        "types": "./dist/src/status-page.d.ts",
+        "default": "./dist/src/status-page.js"
+      },
+      "./status-hook": {
+        "types": "./dist/src/status-hook.d.ts",
+        "default": "./dist/src/status-hook.js"
+      },
+      "./status-serve": {
+        "types": "./dist/src/status-serve.d.ts",
+        "default": "./dist/src/status-serve.js"
+      },
+      "./status-middleware": {
+        "types": "./dist/src/status-middleware.d.ts",
+        "default": "./dist/src/status-middleware.js"
       }
     }
   }
diff --git a/packages/astro-renderer/src/astro-env.d.ts b/packages/astro-renderer/src/astro-env.d.ts
index e19348cc..6be51bd9 100644
--- a/packages/astro-renderer/src/astro-env.d.ts
+++ b/packages/astro-renderer/src/astro-env.d.ts
@@ -19,3 +19,12 @@ declare module "virtual:cloudhal/comments-client" {
   const client: import("./comments-client.ts").CommentsClient | null;
   export default client;
 }
+
+declare module "virtual:cloudhal/theme-hooks" {
+  /**
+   * RFC-0043 §1.7: loads the project's `src/theme.ts` lazily (an empty module when the project
+   * has none), so a status page can ask for the theme's `statusPage` hook without evaluating
+   * the theme on the normal path.
+   */
+  export const loadTheme: () => Promise<Record<string, unknown>>;
+}
diff --git a/packages/astro-renderer/src/cloudflare-entry.ts b/packages/astro-renderer/src/cloudflare-entry.ts
index 5af6d96e..ef42ec32 100644
--- a/packages/astro-renderer/src/cloudflare-entry.ts
+++ b/packages/astro-renderer/src/cloudflare-entry.ts
@@ -32,17 +32,26 @@
  *   render the section themselves (`loadComments`, `<Comments />`) and set their own CSP when an
  *   open form uses Turnstile; `withSecurityHeaders` keeps it. All of it is off without a usable
  *   `CLOUDHAL_COMMENTS_KEY` (or when the build has no comments module).
+ * - Status pages (RFC-0043 §1): before Astro, the entry decides the site's state — `not-published`
+ *   before the first publish, `preview-expired` for a preview token that does not verify,
+ *   `unavailable` for a Worker that serves no site — and answers page paths with the renderer's
+ *   own page (`status-page.ts`: 503/410, `Retry-After`, `no-store`, its own CSP), restyled by the
+ *   theme's optional `statusPage` hook. A failure anywhere becomes the `error` page (500) with the
+ *   `cf-ray` as its reference. `GET /__cloudhal/health` answers `{ ok, state }` for monitors.
  */
 
 import { cache } from "cloudflare:workers";
 import config from "virtual:cloudhal/config";
+import { loadTheme } from "virtual:cloudhal/theme-hooks";
 import { handle } from "@astrojs/cloudflare/handler";
 import { type WaeDataset, WaeWriter } from "@cloudhal/analytics/wae";
 import {
   analyticsBackend,
   CACHE_TAG_PREFIX,
   resetSource,
+  type SiteStateResult,
   serveMedia,
+  siteState,
   withRequestSite,
 } from "@cloudhal/astro-renderer/runtime";
 import { SqlCommentStore } from "@cloudhal/comments/sql";
@@ -63,6 +72,9 @@ import { hostRedirect, type RedirectEnv } from "./host-redirect.ts";
 import { PREVIEW_PARAM } from "./resolver.ts";
 import { SearchLimiter, searchCost } from "./search-limit.ts";
 import { SiteDispatch, unknownHost, withNoindex } from "./site-dispatch.ts";
+import { renderStatus, themeStatusHook } from "./status-hook.ts";
+import { type SiteState, statusPage } from "./status-page.ts";
+import { isStatusPagePath, statusInput } from "./status-serve.ts";
 
 interface Env extends RedirectEnv {
   CLOUDHAL_SITE_ID?: string;
@@ -142,6 +154,67 @@ const pendingWrites = new PendingWrites();
 const analyticsBySite = new Map<string, SiteAnalytics>();
 const commentsBySite = new Map<string, SiteComments>();
 let dispatch: SiteDispatch | undefined;
+/** RFC-0043 §1.7: the theme's `statusPage` hook, loaded the first time a status page is drawn. */
+const statusHook = themeStatusHook(loadTheme, (m, e) => console.error(m, e));
+
+/** RFC-0043 §1.3: the `error` page's reference — Cloudflare's ray id, else a random one. */
+function referenceId(request: Request): string {
+  return (
+    request.headers.get("cf-ray") ??
+    Array.from(crypto.getRandomValues(new Uint8Array(8)), (b) =>
+      b.toString(16).padStart(2, "0"),
+    ).join("")
+  );
+}
+
+/** The `error` page (RFC-0043 §1.2): never the theme's hook, nothing read from the store. */
+function errorPage(request: Request, error: unknown): Response {
+  const rayId = referenceId(request);
+  console.error(`cloudhal: request failed (reference ${rayId})`, error);
+  return statusPage("error", { locale: "en", now: Date.now(), rayId }, { method: request.method });
+}
+
+/**
+ * A 5xx HTML answer from Astro becomes the `error` page unless the theme marked it as its own
+ * (`x-cloudhal-error-page: theme`, a theme's `500.astro`).
+ */
+function withErrorPage(response: Response, request: Request): Response {
+  if (
+    response.status < 500 ||
+    !(response.headers.get("content-type") ?? "").includes("text/html") ||
+    response.headers.get("x-cloudhal-error-page") === "theme"
+  )
+    return response;
+  return errorPage(request, new Error(`Astro answered ${response.status}`));
+}
+
+/**
+ * RFC-0043 §1.9: `{ ok, state }`, the admin's `/api/health` shape plus the site's state, so one
+ * monitor rule reads both. Public, never cached, never indexed; reads only the memoised pointer.
+ */
+async function health(request: Request): Promise<Response> {
+  const headers = {
+    "cache-control": "no-store",
+    "cloudflare-cdn-cache-control": "no-store",
+    "x-robots-tag": "noindex",
+  };
+  if (request.method !== "GET" && request.method !== "HEAD")
+    return Response.json(
+      { error: "method_not_allowed" },
+      { status: 405, headers: { ...headers, allow: "GET" } },
+    );
+  try {
+    const state = await siteState(request);
+    if (state.kind === "unavailable") return Response.json({ ok: false }, { status: 503, headers });
+    return Response.json(
+      { ok: true, state: state.kind === "not-published" ? "not-published" : "published" },
+      { headers },
+    );
+  } catch (error) {
+    console.error("cloudhal: health check could not read the store", error);
+    return Response.json({ ok: false }, { status: 503, headers });
+  }
+}
 
 /** One per isolate: which site a request is for (RFC-0034 §4). */
 function siteDispatch(env: Env, siteIdFromBuild: string | undefined): SiteDispatch {
@@ -504,8 +577,11 @@ async function serveSite(
   const media = siteId ? await serveMedia(request, { siteId }) : undefined;
   const rendered =
     media ??
-    withSecurityHeaders(
-      cacheOnlySuccess((await handle(request, env as never, ctx)) as unknown as Response),
+    withErrorPage(
+      withSecurityHeaders(
+        cacheOnlySuccess((await handle(request, env as never, ctx)) as unknown as Response),
+      ),
+      request,
     );
   // Server-side render events (§5.4), off the response path: published HTML 200s (cache
   // misses), redirects, 404, 410, 451 and 5xx; never previews or HEAD.
@@ -529,6 +605,44 @@ async function serveSite(
     : stripped;
 }
 
+/**
+ * RFC-0043 §2.5: the status page for a request the site cannot serve, drawn with the site data
+ * the state allows (§1.6) and the theme's hook; counted as a render event like any 5xx (§1.8).
+ */
+async function statusResponse(
+  call: { request: Request; env: Env; ctx: ExecutionContext },
+  state: Exclude<SiteStateResult, { kind: "serve" }>,
+  siteId: string,
+): Promise<Response> {
+  const { request, env, ctx } = call;
+  const url = new URL(request.url);
+  const kind: SiteState = state.kind;
+  const sites =
+    state.kind === "unavailable"
+      ? {}
+      : {
+          live: state.site,
+          published: state.kind === "preview-expired" ? state.published : undefined,
+        };
+  const started = Date.now();
+  const response = await renderStatus(
+    kind,
+    statusInput(kind, sites, { host: url.host, pathname: url.pathname }, started),
+    {
+      hook: await statusHook(),
+      method: request.method,
+      csp: SITE_CSP,
+      onFailure: (m, e) => console.error(m, e),
+    },
+  );
+  const a = state.kind !== "unavailable" ? await siteAnalytics(env, siteId) : undefined;
+  if (a?.available)
+    ctx.waitUntil(
+      a.render(request, response, Date.now() - started).then(() => pendingWrites.settled()),
+    );
+  return response;
+}
+
 export function createSiteWorker(options: { siteId?: string } = {}) {
   const searchLimiter = new SearchLimiter();
   async function route(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
@@ -541,15 +655,30 @@ export function createSiteWorker(options: { siteId?: string } = {}) {
     // runs (Astro's render included) then sees that site.
     const choice = await siteDispatch(env, options.siteId).choose(request);
     if (choice.kind === "unknown") return unknownHost();
-    const siteId = choice.siteId;
-    const run = () => serveSite({ request, env, ctx }, siteId, searchLimiter);
-    const response = siteId ? await withRequestSite(siteId, run) : await run();
+    // Without `CLOUDHAL_SITE_ID` a single-site Worker serves the site it was built for, as
+    // Astro's `getSource` always did; `unavailable` is for a site row that is gone (§2.5).
+    const siteId = choice.siteId ?? config.siteId;
+    const call = { request, env, ctx };
+    const run = async () => {
+      if (url.pathname === "/__cloudhal/health") return health(request);
+      const page =
+        (request.method === "GET" || request.method === "HEAD") && isStatusPagePath(url.pathname);
+      const state = page ? await siteState(request) : undefined;
+      if (state && state.kind !== "serve") return statusResponse(call, state, siteId);
+      return serveSite(call, siteId, searchLimiter);
+    };
+    const response = await withRequestSite(siteId, run);
     return choice.noindex ? withNoindex(response) : response;
   }
   return {
     async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
       // #62: the edge cache is shared by every host this Worker answers on, unless told to vary.
-      return varyByHost(await route(request, env, ctx));
+      try {
+        return varyByHost(await route(request, env, ctx));
+      } catch (error) {
+        // RFC-0043 §1.8: whatever failed, the visitor gets a page and a reference to quote.
+        return varyByHost(errorPage(request, error));
+      }
     },
   };
 }
diff --git a/packages/astro-renderer/src/integration.ts b/packages/astro-renderer/src/integration.ts
index 91aed255..67f60267 100644
--- a/packages/astro-renderer/src/integration.ts
+++ b/packages/astro-renderer/src/integration.ts
@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
 import type { AstroIntegration } from "astro";
 import type { AnalyticsClient } from "./analytics-client.ts";
 import type { CommentsClient } from "./comments-client.ts";
@@ -61,6 +63,14 @@ const RESOLVED_CLIENT_ID = `\0${CLIENT_ID}`;
 /** Dev only: the built comments module and worker, served from memory by the comments middleware. */
 const COMMENTS_CLIENT_ID = "virtual:cloudhal/comments-client";
 const RESOLVED_COMMENTS_CLIENT_ID = `\0${COMMENTS_CLIENT_ID}`;
+/**
+ * RFC-0043 §1.7: a lazy loader of the project's `src/theme.ts` for the status pages' theme hook
+ * (root-relative, so Vite resolves it in dev and in the Site Worker build), or of an empty module
+ * when the project has no theme module. Evaluated only when a status page is drawn.
+ */
+const THEME_HOOKS_ID = "virtual:cloudhal/theme-hooks";
+const RESOLVED_THEME_HOOKS_ID = `\0${THEME_HOOKS_ID}`;
+const THEME_MODULE = "src/theme.ts";
 
 /** The virtual modules: the project config, and in dev the built analytics and comments clients. */
 function configPlugin(modules: { config: unknown; client: unknown; comments: unknown }) {
@@ -68,27 +78,46 @@ function configPlugin(modules: { config: unknown; client: unknown; comments: unk
     [VIRTUAL_ID]: RESOLVED_ID,
     [CLIENT_ID]: RESOLVED_CLIENT_ID,
     [COMMENTS_CLIENT_ID]: RESOLVED_COMMENTS_CLIENT_ID,
+    [THEME_HOOKS_ID]: RESOLVED_THEME_HOOKS_ID,
   };
   const bodies: Record<string, unknown> = {
     [RESOLVED_ID]: modules.config,
     [RESOLVED_CLIENT_ID]: modules.client,
     [RESOLVED_COMMENTS_CLIENT_ID]: modules.comments,
   };
+  let root = process.cwd();
   return {
     name: "cloudhal-config",
+    configResolved: (config: { root: string }) => {
+      root = config.root;
+    },
     resolveId: (id: string) => (Object.hasOwn(ids, id) ? ids[id] : undefined),
-    load: (id: string) =>
-      Object.hasOwn(bodies, id) ? `export default ${JSON.stringify(bodies[id])};` : undefined,
+    load: (id: string) => {
+      if (id === RESOLVED_THEME_HOOKS_ID)
+        return existsSync(path.join(root, THEME_MODULE))
+          ? `export const loadTheme = () => import("/${THEME_MODULE}");`
+          : "export const loadTheme = () => Promise.resolve({});";
+      return Object.hasOwn(bodies, id)
+        ? `export default ${JSON.stringify(bodies[id])};`
+        : undefined;
+    },
   };
 }
 
 /**
  * What only `cloudhal dev` runs as middleware (the Site Worker's entry and builds do these jobs):
  * the analytics beacon (RFC-0006 §5.1); the click-to-load video player (RFC-0015 §4) and the
- * interaction runtime (RFC-0020 §4), which builds write as files; and the Site Worker's CSP sent
- * report-only, so the console shows what a deploy would block.
+ * interaction runtime (RFC-0020 §4), which builds write as files; the Site Worker's CSP sent
+ * report-only, so the console shows what a deploy would block; and the status pages' preview
+ * route (RFC-0043 §1.8).
  */
-const DEV_MIDDLEWARE = ["analytics-middleware", "embed-middleware", "csp-middleware"].map((m) => ({
+const DEV_MIDDLEWARE = [
+  "analytics-middleware",
+  "embed-middleware",
+  "csp-middleware",
+  // RFC-0043 §1.8: the status pages drawn on demand at `/__cloudhal/status/<state>`.
+  "status-middleware",
+].map((m) => ({
   entrypoint: `@cloudhal/astro-renderer/${m}`,
   order: "pre" as const,
 }));
diff --git a/packages/astro-renderer/src/runtime-workerd.ts b/packages/astro-renderer/src/runtime-workerd.ts
index 3aabb5e3..7d9608a1 100644
--- a/packages/astro-renderer/src/runtime-workerd.ts
+++ b/packages/astro-renderer/src/runtime-workerd.ts
@@ -23,7 +23,7 @@ import { usableCommentsKey } from "./comments.ts";
 import type { CloudhalRendererConfig } from "./integration.ts";
 import type { PeerEdition } from "./locales.ts";
 import { matchMediaRoute, serveMediaRequest } from "./media-route.ts";
-import { PREVIEW_PARAM, SiteResolver } from "./resolver.ts";
+import { PREVIEW_PARAM, type Resolution, SiteResolver } from "./resolver.ts";
 import type { GraphSource } from "./source.ts";
 
 /** RFC-0029 §3: `AI_SEARCH`, `SEARCH_BUCKET` and `CLOUDHAL_SEARCH_*` turn on semantic search. */
@@ -143,6 +143,66 @@ export function resetSource(siteId?: string): void {
   for (const [id, r] of resolvers) if (!siteId || id === siteId) r.invalidate();
 }
 
+/**
+ * RFC-0043 §1.8: one resolution per request. The entry decides the site's state before Astro
+ * runs and Astro's `getSource` resolves the same request, so the verdict (pointer read, preview
+ * token) is memoised on the request object; a request Astro re-created simply resolves again.
+ */
+const resolutions = new WeakMap<Request, Promise<Resolution>>();
+
+function resolveRequest(r: SiteResolver, request: Request): Promise<Resolution> {
+  let pending = resolutions.get(request);
+  if (!pending) {
+    pending = r.resolve(request);
+    resolutions.set(request, pending);
+  }
+  return pending;
+}
+
+/** RFC-0043 §2.5: what the entry answers for this request, decided before Astro runs. */
+export type SiteStateResult =
+  | { readonly kind: "serve" }
+  /** The site row is missing (deleted, RFC-0034). */
+  | { readonly kind: "unavailable" }
+  /** No published snapshot and no valid preview: `site` is the live node (its name, locales). */
+  | { readonly kind: "not-published"; readonly site: Site }
+  /** A preview token in the URL that does not verify; `published` is the published snapshot's site node, if any. */
+  | {
+      readonly kind: "preview-expired";
+      readonly site: Site;
+      readonly published?: Site | undefined;
+    };
+
+/**
+ * The state of the request's site (RFC-0043 §2.5): `serve` for a published site or a valid
+ * preview, `not-published` before the first publish, `preview-expired` for a token in the URL
+ * that does not verify (§1.2: it no longer falls back to the published page). Shares the
+ * request's resolution with `getSource`.
+ */
+export async function siteState(request: Request, siteId?: string): Promise<SiteStateResult> {
+  const id = siteOf(siteId);
+  if (!id) return { kind: "unavailable" };
+  const r = getResolver(id);
+  let resolution: Resolution;
+  try {
+    resolution = await resolveRequest(r, request);
+  } catch (error) {
+    if (error instanceof Error && /^site .* not found$/.test(error.message))
+      return { kind: "unavailable" };
+    throw error;
+  }
+  if (resolution.kind === "preview") return { kind: "serve" };
+  const fromUrl = new URL(request.url).searchParams.get(PREVIEW_PARAM);
+  if (resolution.previewError && fromUrl && fromUrl !== "exit")
+    return {
+      kind: "preview-expired",
+      site: await r.site(),
+      published: resolution.kind === "published" ? await resolution.source.site() : undefined,
+    };
+  if (resolution.kind === "unpublished") return { kind: "not-published", site: await r.site() };
+  return { kind: "serve" };
+}
+
 /**
  * What site analytics read on the Site Worker (`SiteAnalytics`, RFC-0006 §5.2): D1 for settings and
  * the daily salt, the site row (published pointer, domains) and the isolate's snapshot cache.
@@ -237,7 +297,7 @@ export async function getSource(
   if (!astro) throw new Error("on Cloudflare, pass the Astro global: getSource(config, Astro)");
   const siteId = siteOf(config.siteId) as string;
   const r = getResolver(siteId);
-  const resolution = await r.resolve(astro.request);
+  const resolution = await resolveRequest(r, astro.request);
   const h = astro.response.headers;
   if (resolution.kind === "preview") {
     h.set("cache-control", "private, no-store");
@@ -296,7 +356,7 @@ export async function serveMedia(
   const siteId = siteOf(options.siteId);
   if (!siteId) return undefined;
   const r = getResolver(siteId);
-  const resolution = await r.resolve(request);
+  const resolution = await resolveRequest(r, request);
   if (resolution.kind === "unpublished")
     return new Response("not found", {
       status: 404,
diff --git a/packages/astro-renderer/src/runtime.ts b/packages/astro-renderer/src/runtime.ts
index 24b22e18..ae913ac4 100644
--- a/packages/astro-renderer/src/runtime.ts
+++ b/packages/astro-renderer/src/runtime.ts
@@ -158,5 +158,24 @@ export async function commentsBackend(
   return { store: new SqlCommentStore((await localStore(config.dataDir)).sql) };
 }
 
+/** RFC-0043 §2.5: the `workerd` build's verdict shape, for code importing either build. */
+export type SiteStateResult =
+  | { readonly kind: "serve" }
+  | { readonly kind: "unavailable" }
+  | { readonly kind: "not-published"; readonly site: Site }
+  | {
+      readonly kind: "preview-expired";
+      readonly site: Site;
+      readonly published?: Site | undefined;
+    };
+
+/**
+ * RFC-0043 §1.8: `cloudhal dev` renders the working copy, drafts included, so a request on Node
+ * is always served; the status pages are drawn on demand at `/__cloudhal/status/<state>`.
+ */
+export async function siteState(_request: Request, _siteId?: string): Promise<SiteStateResult> {
+  return { kind: "serve" };
+}
+
 /** Shared with the `workerd` runtime so code importing either build sees the same names. */
 export { CACHE_TAG_PREFIX } from "./cache-tags.ts";
diff --git a/packages/astro-renderer/src/status-hook.ts b/packages/astro-renderer/src/status-hook.ts
new file mode 100644
index 00000000..892a3349
--- /dev/null
+++ b/packages/astro-renderer/src/status-hook.ts
@@ -0,0 +1,141 @@
+/**
+ * The theme hook for status pages (RFC-0043 §1.7): a theme may export `statusPage(state, ctx)`
+ * from `src/theme.ts` and return its own document. The renderer keeps the status code, the
+ * headers and the CSP (invariant 9); the built-in page is used when the hook returns
+ * `undefined`, throws, answers with something other than a string, exceeds 64 KB, or takes more
+ * than 50 ms — logged once per state and isolate — and always for `error`, which must not depend
+ * on code that may be the cause. Worker-safe.
+ */
+import { SITE_CSP } from "./csp.ts";
+import { messageHtml, type StatusDir } from "./status-html.ts";
+import {
+  HOOK_HTML_LIMIT,
+  type SiteState,
+  type StatusPageInput,
+  type StatusStrings,
+  statusCode,
+  statusPage,
+  statusPageHtml,
+  statusStrings,
+} from "./status-page.ts";
+
+/** The states a theme may draw. */
+export type HookState = Exclude<SiteState, "error">;
+
+export interface StatusContext extends StatusPageInput {
+  readonly status: 503 | 410;
+  readonly dir: StatusDir;
+  /** The built-in words, already in the page's locale. */
+  readonly strings: StatusStrings;
+  /** The owner's message, escaped, line breaks as `<br>` (never use `message.text` raw). */
+  readonly messageHtml?: string | undefined;
+  /** "Back by …", formatted. */
+  readonly untilText?: string | undefined;
+  /** The built-in document, with extra CSS appended. */
+  defaultHtml(options?: { css?: string | undefined }): string;
+}
+
+export type StatusPageHook = (
+  state: HookState,
+  ctx: StatusContext,
+) => string | undefined | Promise<string | undefined>;
+
+/** How long a hook may take before the built-in page answers instead. */
+export const HOOK_TIMEOUT_MS = 50;
+
+const failed = new Set<string>();
+
+/** Loads `src/theme.ts` lazily (the integration's `virtual:cloudhal/theme-hooks`) and memoises the hook. */
+export function themeStatusHook(
+  loadTheme: () => Promise<unknown>,
+  onError: (message: string, error: unknown) => void = () => {},
+): () => Promise<StatusPageHook | undefined> {
+  let pending: Promise<StatusPageHook | undefined> | undefined;
+  return () => {
+    pending ??= loadTheme().then(
+      (mod) => {
+        const hook = (mod as { statusPage?: unknown } | null)?.statusPage;
+        return typeof hook === "function" ? (hook as StatusPageHook) : undefined;
+      },
+      (error: unknown) => {
+        onError("cloudhal: the theme module could not be loaded for the status page", error);
+        return undefined;
+      },
+    );
+    return pending;
+  };
+}
+
+export interface RenderStatusOptions {
+  readonly hook?: StatusPageHook | undefined;
+  readonly method?: string | undefined;
+  readonly onFailure?: ((message: string, error?: unknown) => void) | undefined;
+  /** The site's policy for a theme's document (default `SITE_CSP`). */
+  readonly csp?: string | undefined;
+  /** Test hook: the hook's time budget. */
+  readonly timeoutMs?: number | undefined;
+}
+
+/** Runs the hook within its budget; `undefined` means the built-in page. */
+async function hookHtml(
+  state: HookState,
+  input: StatusPageInput,
+  hook: StatusPageHook,
+  options: RenderStatusOptions,
+): Promise<string | undefined> {
+  const strings = statusStrings(state, input);
+  const ctx: StatusContext = {
+    ...input,
+    status: statusCode(state) as 503 | 410,
+    dir: strings.dir,
+    strings,
+    ...(input.message && state === "maintenance"
+      ? { messageHtml: messageHtml(input.message.text) }
+      : {}),
+    untilText: strings.untilText,
+    defaultHtml: (o = {}) => statusPageHtml(state, input, o),
+  };
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`took more than ${options.timeoutMs ?? HOOK_TIMEOUT_MS} ms`)),
+      options.timeoutMs ?? HOOK_TIMEOUT_MS,
+    );
+  });
+  try {
+    const result = await Promise.race([Promise.resolve().then(() => hook(state, ctx)), timeout]);
+    if (result === undefined) return undefined;
+    if (typeof result !== "string") throw new Error("returned something other than a string");
+    if (result.length > HOOK_HTML_LIMIT)
+      throw new Error(`returned more than ${HOOK_HTML_LIMIT} bytes`);
+    return result;
+  } catch (error) {
+    if (!failed.has(state)) {
+      failed.add(state);
+      options.onFailure?.(`cloudhal: the theme's statusPage hook failed for ${state}`, error);
+    }
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Test hook: forget which states' hook failures were logged. */
+export function resetHookFailures(): void {
+  failed.clear();
+}
+
+/** The status response for `state`: the theme's document when the hook gives one, else the built-in page. */
+export async function renderStatus(
+  state: SiteState,
+  input: StatusPageInput,
+  options: RenderStatusOptions = {},
+): Promise<Response> {
+  if (state === "error" || !options.hook)
+    return statusPage(state, input, { method: options.method });
+  const html = await hookHtml(state, input, options.hook, options);
+  return statusPage(state, input, {
+    method: options.method,
+    ...(html !== undefined ? { html, csp: options.csp ?? SITE_CSP } : {}),
+  });
+}
diff --git a/packages/astro-renderer/src/status-html.ts b/packages/astro-renderer/src/status-html.ts
new file mode 100644
index 00000000..fc4a9479
--- /dev/null
+++ b/packages/astro-renderer/src/status-html.ts
@@ -0,0 +1,157 @@
+/**
+ * The built-in status document (RFC-0043 §1.3): one self-contained HTML page under 8 KB with
+ * inline CSS, the system font stack, no scripts and no requests except the site's own logo.
+ * Light and dark through `prefers-color-scheme`, logical properties only (ADR-0033), and the
+ * published site's tokens (§1.3) as four custom properties when the state allows them.
+ */
+import type { StatusMessages } from "./status-strings/en.ts";
+
+export type StatusDir = "ltr" | "rtl";
+
+/** The published site's look, read from `Site.theme.config` (§1.3); every field optional. */
+export interface StatusTheme {
+  /** `#rrggbb`: a decorative accent (never text), so it needs no contrast check. */
+  readonly brand?: string | undefined;
+  /** `#rrggbb`: the page background; used only together with `text` and when they contrast. */
+  readonly surface?: string | undefined;
+  /** `#rrggbb`: the text color; used only together with `surface` and when they contrast. */
+  readonly text?: string | undefined;
+  readonly font?: "sans" | "serif" | "mono" | undefined;
+}
+
+/** What the template draws; every piece already chosen and, where it is text, still unescaped. */
+export interface StatusDocument {
+  readonly state: string;
+  readonly locale: string;
+  readonly dir: StatusDir;
+  readonly noindex: boolean;
+  readonly words: Pick<StatusMessages, "builtWith"> & { title: string; body: string };
+  readonly siteName?: string | undefined;
+  /** A same-origin `/media/…` URL only (the page's CSP allows `img-src 'self'`). */
+  readonly logo?: string | undefined;
+  readonly message?: { readonly text: string; readonly locale: string; readonly dir: StatusDir };
+  /** "Back by …", already formatted. */
+  readonly until?: string | undefined;
+  /** "Reference: …", already formatted. */
+  readonly reference?: string | undefined;
+  readonly theme?: StatusTheme | undefined;
+  /** Extra CSS from a theme hook's `defaultHtml({ css })`, appended after the built-in rules. */
+  readonly css?: string | undefined;
+}
+
+export function escapeHtml(s: string): string {
+  return s.replace(
+    /[&<>"']/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] as string,
+  );
+}
+
+/** The owner's message: escaped, line breaks as `<br>`; never markup or links (§2.10). */
+export function messageHtml(text: string): string {
+  return escapeHtml(text.replace(/\r\n?/g, "\n"))
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join("<br>");
+}
+
+const HEX = /^#[0-9a-f]{6}$/i;
+
+function luminance(hex: string): number {
+  const channel = (i: number) => {
+    const c = Number.parseInt(hex.slice(i, i + 2), 16) / 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * channel(1) + 0.7152 * channel(3) + 0.0722 * channel(5);
+}
+
+/** WCAG 2.x contrast ratio of two `#rrggbb` colors. */
+export function contrastRatio(a: string, b: string): number {
+  const [l1, l2] = [luminance(a), luminance(b)].sort((x, y) => y - x) as [number, number];
+  return (l1 + 0.05) / (l2 + 0.05);
+}
+
+/** Only typed values reach the stylesheet: hex colors (a readable pair) and a font keyword. */
+function themeCss(theme: StatusTheme | undefined): string {
+  if (!theme) return "";
+  const decl: string[] = [];
+  if (theme.brand && HEX.test(theme.brand)) decl.push(`--ch-status-brand:${theme.brand}`);
+  if (
+    theme.surface &&
+    theme.text &&
+    HEX.test(theme.surface) &&
+    HEX.test(theme.text) &&
+    contrastRatio(theme.surface, theme.text) >= 4.5
+  )
+    decl.push(`--ch-status-surface:${theme.surface}`, `--ch-status-text:${theme.text}`);
+  const stacks = {
+    sans: "system-ui, sans-serif",
+    serif: "ui-serif, Georgia, serif",
+    mono: "ui-monospace, Menlo, monospace",
+  };
+  if (theme.font && theme.font in stacks) decl.push(`--ch-status-font:${stacks[theme.font]}`);
+  return decl.length ? `:root{${decl.join(";")}}` : "";
+}
+
+/** The built-in rules: about 1.2 KB, logical properties only. */
+const CSS = [
+  ":root{--ch-status-brand:#2563eb;--ch-status-surface:#f6f7f9;--ch-status-text:#1a1d21;",
+  "--ch-status-muted:#5b6470;--ch-status-card:#ffffff;--ch-status-font:system-ui,sans-serif;",
+  "color-scheme:light dark}",
+  "@media(prefers-color-scheme:dark){:root{--ch-status-surface:#111418;--ch-status-text:#e8eaed;",
+  "--ch-status-muted:#a3abb5;--ch-status-card:#1b1f25}}",
+  "*{box-sizing:border-box}",
+  "html{background:var(--ch-status-surface);color:var(--ch-status-text);",
+  "font:16px/1.5 var(--ch-status-font)}",
+  "body{margin:0;min-height:100vh;display:grid;grid-template-rows:1fr auto;",
+  "padding-block:1rem;padding-inline:1rem}",
+  ".ch-status{align-self:center;justify-self:center;inline-size:100%;max-inline-size:32rem;",
+  "background:var(--ch-status-card);border-block-start:4px solid var(--ch-status-brand);",
+  "border-radius:.75rem;padding-block:2rem;padding-inline:1.75rem;",
+  "box-shadow:0 1px 2px rgba(0,0,0,.06),0 8px 24px rgba(0,0,0,.08)}",
+  ".ch-status__logo{max-block-size:3rem;max-inline-size:12rem;margin-block-end:1rem}",
+  ".ch-status__site{margin:0 0 .5rem;font-size:.875rem;letter-spacing:.04em;",
+  "text-transform:uppercase;color:var(--ch-status-muted)}",
+  "h1{margin:0 0 .75rem;font-size:1.625rem;line-height:1.25}",
+  "p{margin:0 0 .75rem}",
+  ".ch-status__message{padding-block:.75rem;padding-inline:1rem;",
+  "border-inline-start:3px solid var(--ch-status-brand);",
+  "background:color-mix(in srgb,var(--ch-status-brand) 8%,transparent);border-radius:.25rem}",
+  ".ch-status__until,.ch-status__ref{color:var(--ch-status-muted);font-size:.9375rem}",
+  "code{font-family:ui-monospace,Menlo,monospace;font-size:.9em}",
+  "footer{justify-self:center;margin-block-start:1.5rem;font-size:.8125rem;",
+  "color:var(--ch-status-muted)}",
+].join("");
+
+/** The document for `doc`, as a string. */
+export function statusDocument(doc: StatusDocument): string {
+  const e = escapeHtml;
+  const title = doc.siteName ? `${doc.words.title} · ${doc.siteName}` : doc.words.title;
+  const parts = [
+    "<!doctype html>",
+    `<html lang="${e(doc.locale)}" dir="${doc.dir}">`,
+    "<head>",
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    doc.noindex ? '<meta name="robots" content="noindex">' : "",
+    `<title>${e(title)}</title>`,
+    `<style>${CSS}${themeCss(doc.theme)}${doc.css ?? ""}</style>`,
+    "</head>",
+    "<body>",
+    `<main class="ch-status" data-state="${e(doc.state)}">`,
+    doc.logo ? `<img class="ch-status__logo" src="${e(doc.logo)}" alt="">` : "",
+    doc.siteName ? `<p class="ch-status__site">${e(doc.siteName)}</p>` : "",
+    `<h1>${e(doc.words.title)}</h1>`,
+    `<p>${e(doc.words.body)}</p>`,
+    doc.message
+      ? `<p class="ch-status__message" lang="${e(doc.message.locale)}" dir="${doc.message.dir}">${messageHtml(doc.message.text)}</p>`
+      : "",
+    doc.until ? `<p class="ch-status__until">${e(doc.until)}</p>` : "",
+    doc.reference ? `<p class="ch-status__ref"><code>${e(doc.reference)}</code></p>` : "",
+    "</main>",
+    `<footer>${e(doc.words.builtWith)}</footer>`,
+    "</body>",
+    "</html>",
+  ];
+  return `${parts.filter(Boolean).join("\n")}\n`;
+}
diff --git a/packages/astro-renderer/src/status-middleware.ts b/packages/astro-renderer/src/status-middleware.ts
new file mode 100644
index 00000000..8ff10b4f
--- /dev/null
+++ b/packages/astro-renderer/src/status-middleware.ts
@@ -0,0 +1,61 @@
+/**
+ * Dev middleware (added by the `cloudhal()` integration for Node targets, RFC-0043 §1.8):
+ * `cloudhal dev` renders the working copy, drafts included, so it never answers a real page with
+ * a status page. For parity it draws each page on demand, through the same module and the
+ * project's theme hook, at `/__cloudhal/status/<state>` (`?locale=tr`, `?page=coming-soon`,
+ * `?message=…`, `?until=<RFC 3339>`), so a theme author can see and screenshot their override.
+ */
+import config from "virtual:cloudhal/config";
+import { loadTheme } from "virtual:cloudhal/theme-hooks";
+import { getSource } from "@cloudhal/astro-renderer/runtime";
+import { renderStatus, themeStatusHook } from "./status-hook.ts";
+import { isSiteState, type StatusPageInput } from "./status-page.ts";
+import { statusInput } from "./status-serve.ts";
+
+interface MiddlewareContext {
+  request: Request;
+}
+
+export const STATUS_PREVIEW_PATH = /^\/__cloudhal\/status\/([a-z-]+)\/?$/;
+
+const hook = themeStatusHook(loadTheme, (m, e) => console.error(m, e));
+
+export async function onRequest(
+  context: MiddlewareContext,
+  next: () => Promise<Response>,
+): Promise<Response> {
+  const url = new URL(context.request.url);
+  const m = STATUS_PREVIEW_PATH.exec(url.pathname);
+  if (!m) return next();
+  const state = m[1] as string;
+  if (!isSiteState(state))
+    return new Response(`unknown state "${state}"`, {
+      status: 404,
+      headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" },
+    });
+  const site = await (await getSource(config)).site();
+  const now = Date.now();
+  // Dev shows the working copy: the live node stands in for the published one here.
+  const base = statusInput(
+    state,
+    { live: site, published: site },
+    { host: url.host, pathname: "/" },
+    now,
+  );
+  const locale = url.searchParams.get("locale");
+  const message = url.searchParams.get("message");
+  const until = url.searchParams.get("until");
+  const input: StatusPageInput = {
+    ...base,
+    ...(locale ? { locale } : {}),
+    page: url.searchParams.get("page") === "coming-soon" ? "coming-soon" : "maintenance",
+    ...(message ? { message: { text: message, locale: locale ?? site.defaultLocale } } : {}),
+    ...(until ? { until: { at: until, timeZone: site.timeZone } } : {}),
+    ...(state === "error" ? { rayId: "dev-preview" } : {}),
+  };
+  return renderStatus(state, input, {
+    hook: await hook(),
+    method: context.request.method,
+    onFailure: (msg, e) => console.error(msg, e),
+  });
+}
diff --git a/packages/astro-renderer/src/status-page.ts b/packages/astro-renderer/src/status-page.ts
new file mode 100644
index 00000000..81a3c241
--- /dev/null
+++ b/packages/astro-renderer/src/status-page.ts
@@ -0,0 +1,323 @@
+/**
+ * Status pages (RFC-0043 §1): the one page a site answers with when it cannot show its pages —
+ * not published yet, in maintenance, unavailable, failed, or behind an expired preview link —
+ * with the right status code, `Retry-After`, `no-store` and its own CSP. Pure and Worker-safe:
+ * it imports only the catalog and the template, takes an injected clock, and never throws (a
+ * broken input degrades to the English page). Where it is served: `cloudflare-entry.ts` before
+ * Astro, `status-middleware.ts` in `cloudhal dev`, and the starter's routes as their fallback.
+ */
+import {
+  messageHtml,
+  type StatusDir,
+  type StatusDocument,
+  type StatusTheme,
+  statusDocument,
+} from "./status-html.ts";
+import { STATUS_CATALOG } from "./status-strings/catalog.ts";
+import type { StatusMessages } from "./status-strings/en.ts";
+
+// The hook's types, so a theme imports everything from one subpath (§1.7).
+export type { HookState, StatusContext, StatusPageHook } from "./status-hook.ts";
+export type { StatusTheme } from "./status-html.ts";
+
+export type SiteState =
+  | "not-published"
+  | "maintenance"
+  | "unavailable"
+  | "error"
+  | "preview-expired";
+
+export const SITE_STATES: readonly SiteState[] = [
+  "not-published",
+  "maintenance",
+  "unavailable",
+  "error",
+  "preview-expired",
+];
+
+export const isSiteState = (value: string): value is SiteState =>
+  (SITE_STATES as readonly string[]).includes(value);
+
+export interface StatusPageInput {
+  /** §1.6 decides what is passed per state; `logo` is a same-origin `/media/…` URL. */
+  readonly site?: { readonly name: string; readonly logo?: string | undefined } | undefined;
+  /** Already chosen (§1.4: host or path prefix, the site default, then English). */
+  readonly locale: string;
+  /** Maintenance wording (§2.1 `page`); `maintenance` when absent. */
+  readonly page?: "maintenance" | "coming-soon" | undefined;
+  /** Maintenance only: the owner's plain-text message and its language. */
+  readonly message?: { readonly text: string; readonly locale: string } | undefined;
+  /** Maintenance only: when it ends, for "Back by …" and `Retry-After`. */
+  readonly until?: { readonly at: string; readonly timeZone?: string | undefined } | undefined;
+  /** The published site's tokens (§1.3); the caller passes them only where the state allows. */
+  readonly theme?: StatusTheme | undefined;
+  /** `error` only: the request id a visitor can quote (`cf-ray`). */
+  readonly rayId?: string | undefined;
+  /** Injected clock (RFC-0008 §9.4). */
+  readonly now: number;
+}
+
+/** The built-in page's own policy (§1.3): inline style, same-origin images, nothing else. */
+export const STATUS_CSP =
+  "default-src 'none'; style-src 'unsafe-inline'; img-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+
+/** The built-in document never exceeds this (§1.3); a test draws every state in every language. */
+export const STATUS_PAGE_LIMIT = 8192;
+
+/** A theme hook's document may be this large before the built-in page is used instead (§1.7). */
+export const HOOK_HTML_LIMIT = 65536;
+
+const STATUS: Record<SiteState, 503 | 500 | 410> = {
+  "not-published": 503,
+  maintenance: 503,
+  unavailable: 503,
+  error: 500,
+  "preview-expired": 410,
+};
+
+const NOINDEX: ReadonlySet<SiteState> = new Set(["not-published", "preview-expired"]);
+
+/** RTL scripts by primary language subtag (CLDR), for locales the catalog does not list. */
+const RTL = new Set(["ar", "fa", "he", "ur", "ps", "ckb", "dv", "yi", "ug", "sd", "ks", "ku"]);
+
+export function statusCode(state: SiteState): 503 | 500 | 410 {
+  return STATUS[state];
+}
+
+/** Delay-seconds (§1.2), or nothing for `error` and `preview-expired`. */
+export function retryAfter(
+  state: SiteState,
+  input: Pick<StatusPageInput, "until" | "now">,
+): string | undefined {
+  if (state === "not-published") return "3600";
+  if (state === "unavailable") return "300";
+  if (state !== "maintenance") return undefined;
+  const end = input.until ? Date.parse(input.until.at) : Number.NaN;
+  if (!Number.isFinite(end)) return "3600";
+  return String(Math.max(60, Math.ceil((end - input.now) / 1000)));
+}
+
+/**
+ * The catalog locale for a site locale (§1.4): exact, then the primary language subtag
+ * (`pt-PT` → `pt-BR`, `zh-HK` → `zh-Hans`), then English.
+ */
+export function catalogLocale(locale: string): string {
+  if (Object.hasOwn(STATUS_CATALOG, locale)) return locale;
+  const language = locale.toLowerCase().split("-")[0] ?? "";
+  if (Object.hasOwn(STATUS_CATALOG, language)) return language;
+  const same = Object.keys(STATUS_CATALOG).find((l) => l.split("-")[0]?.toLowerCase() === language);
+  return same ?? "en";
+}
+
+/** `<html dir>` for a locale: the catalog's entry, else by script. */
+export function statusDirection(locale: string): StatusDir {
+  const entry = STATUS_CATALOG[catalogLocale(locale)];
+  if (entry && catalogLocale(locale) !== "en") return entry.dir;
+  if (locale === "en") return "ltr";
+  const [language = "", script] = locale.toLowerCase().split("-");
+  if (script === "latn" || script === "cyrl") return "ltr";
+  return RTL.has(language) ? "rtl" : "ltr";
+}
+
+/** ICU simple arguments only (§1.5): `{name}` is replaced, anything else is left as it is. */
+export function fillMessage(message: string, params: Readonly<Record<string, string>>): string {
+  return message.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (all, name: string) =>
+    Object.hasOwn(params, name) ? (params[name] as string) : all,
+  );
+}
+
+function wordsOf(state: SiteState, page: StatusPageInput["page"], m: StatusMessages) {
+  switch (state) {
+    case "not-published":
+      return m.notPublished;
+    case "maintenance":
+      return page === "coming-soon" ? m.comingSoon : m.maintenance;
+    case "unavailable":
+      return m.unavailable;
+    case "error":
+      return m.error;
+    case "preview-expired":
+      return m.previewExpired;
+  }
+}
+
+/** "2 November, 11:00 GMT+3" in the page's locale and the site's zone (Western digits as Studio). */
+function formatUntil(at: string, timeZone: string | undefined, intl: string): string | undefined {
+  const t = Date.parse(at);
+  if (!Number.isFinite(t)) return undefined;
+  const options: Intl.DateTimeFormatOptions = {
+    day: "numeric",
+    month: "long",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short",
+  };
+  for (const zone of [timeZone, "UTC"]) {
+    try {
+      return new Intl.DateTimeFormat(intl, { ...options, timeZone: zone ?? "UTC" }).format(t);
+    } catch {
+      // an unknown zone: UTC next
+    }
+  }
+  return undefined;
+}
+
+/** The words of a page in its language: what the theme hook gets as `strings` (§1.7). */
+export interface StatusStrings {
+  readonly locale: string;
+  readonly dir: StatusDir;
+  readonly title: string;
+  readonly body: string;
+  readonly builtWith: string;
+  readonly untilText?: string | undefined;
+  readonly referenceText?: string | undefined;
+}
+
+export function statusStrings(state: SiteState, input: StatusPageInput): StatusStrings {
+  const locale = catalogLocale(input.locale);
+  const entry = STATUS_CATALOG[locale] ?? (STATUS_CATALOG.en as (typeof STATUS_CATALOG)["en"]);
+  const m = entry.messages;
+  const words = wordsOf(state, input.page, m);
+  const until =
+    state === "maintenance" && input.until
+      ? formatUntil(input.until.at, input.until.timeZone, entry.intl ?? locale)
+      : undefined;
+  return {
+    locale,
+    dir: entry.dir,
+    title: words.title,
+    body: words.body,
+    builtWith: m.builtWith,
+    ...(until ? { untilText: fillMessage(m.backBy, { time: until }) } : {}),
+    ...(state === "error" && input.rayId
+      ? { referenceText: fillMessage(m.reference, { reference: input.rayId }) }
+      : {}),
+  };
+}
+
+/** Only a same-origin media URL may be the logo (CSP `img-src 'self'`, §1.6). */
+const sameOriginLogo = (src: string | undefined) =>
+  src && /^\/media\/[^\s"'<>]+$/.test(src) ? src : undefined;
+
+function documentOf(state: SiteState, input: StatusPageInput, css?: string): StatusDocument {
+  const s = statusStrings(state, input);
+  const message = state === "maintenance" ? input.message : undefined;
+  return {
+    state,
+    locale: s.locale,
+    dir: s.dir,
+    noindex: NOINDEX.has(state),
+    words: { title: s.title, body: s.body, builtWith: s.builtWith },
+    siteName: state === "unavailable" ? undefined : input.site?.name,
+    logo:
+      state === "not-published" || state === "unavailable"
+        ? undefined
+        : sameOriginLogo(input.site?.logo),
+    ...(message?.text.trim()
+      ? {
+          message: {
+            text: message.text,
+            locale: message.locale,
+            dir: statusDirection(message.locale),
+          },
+        }
+      : {}),
+    until: s.untilText,
+    reference: s.referenceText,
+    theme: state === "maintenance" || state === "preview-expired" ? input.theme : undefined,
+    css,
+  };
+}
+
+const NEUTRAL: StatusPageInput = { locale: "en", now: 0 };
+
+/** The same document as a string, for theme hooks that only restyle it (§1.7). Never throws. */
+export function statusPageHtml(
+  state: SiteState,
+  input: StatusPageInput,
+  options: { css?: string | undefined } = {},
+): string {
+  try {
+    return statusDocument(documentOf(state, input, options.css));
+  } catch {
+    return statusDocument(documentOf(state, NEUTRAL));
+  }
+}
+
+/** The headers every status response carries (§1.2), for an HTML page or a plain answer. */
+export function statusHeaders(
+  state: SiteState,
+  input: Pick<StatusPageInput, "until" | "now">,
+  contentType: string,
+  csp: string = STATUS_CSP,
+): Headers {
+  const headers = new Headers({
+    "content-type": contentType,
+    "cache-control": "no-store",
+    "cloudflare-cdn-cache-control": "no-store",
+    "x-cloudhal-state": state,
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "no-referrer",
+  });
+  const retry = retryAfter(state, input);
+  if (retry) headers.set("retry-after", retry);
+  if (NOINDEX.has(state)) headers.set("x-robots-tag", "noindex");
+  if (contentType.startsWith("text/html")) headers.set("content-security-policy", csp);
+  return headers;
+}
+
+export interface StatusPageOptions {
+  /** `HEAD` gets the headers without a body. */
+  readonly method?: string | undefined;
+  /**
+   * A theme's own document (§1.7), already checked by the hook runner: it replaces the built-in
+   * body and gets `csp` (the site's policy) instead of the built-in page's stricter one.
+   */
+  readonly html?: string | undefined;
+  readonly csp?: string | undefined;
+}
+
+/** The built-in page: status, headers and body. Never throws. */
+export function statusPage(
+  state: SiteState,
+  input: StatusPageInput,
+  options: StatusPageOptions = {},
+): Response {
+  const html = options.html ?? statusPageHtml(state, input);
+  const headers = statusHeaders(
+    state,
+    input,
+    "text/html; charset=utf-8",
+    options.html ? (options.csp ?? STATUS_CSP) : STATUS_CSP,
+  );
+  return new Response(options.method === "HEAD" ? null : html, {
+    status: statusCode(state),
+    headers,
+  });
+}
+
+/** Machine endpoints in the same states (§2.3): short plain text or JSON, same status and headers. */
+export function statusPlain(
+  state: SiteState,
+  input: StatusPageInput,
+  as: "text" | "json",
+  options: { method?: string | undefined } = {},
+): Response {
+  const s = statusStrings(state, input);
+  const body =
+    as === "json"
+      ? JSON.stringify({ error: state, message: `${s.title}. ${s.body}` })
+      : `${s.title}. ${s.body}\n`;
+  const headers = statusHeaders(
+    state,
+    input,
+    as === "json" ? "application/json; charset=utf-8" : "text/plain; charset=utf-8",
+  );
+  return new Response(options.method === "HEAD" ? null : body, {
+    status: statusCode(state),
+    headers,
+  });
+}
+
+/** The owner's message as the hook sees it (`messageHtml`, §1.7). */
+export { messageHtml } from "./status-html.ts";
diff --git a/packages/astro-renderer/src/status-serve.ts b/packages/astro-renderer/src/status-serve.ts
new file mode 100644
index 00000000..9a117952
--- /dev/null
+++ b/packages/astro-renderer/src/status-serve.ts
@@ -0,0 +1,112 @@
+/**
+ * What the Site Worker entry and the dev middleware need around `statusPage` (RFC-0043 §1.4,
+ * §1.6, §1.8): which paths get a page rather than the theme's own answer, the page's locale from
+ * the request's host or path prefix, and the site data each state may show. Worker-safe.
+ */
+import type { Site } from "@cloudhal/core-contracts";
+import { isCommentsPath } from "./comments.ts";
+import { localeRequest } from "./locales.ts";
+import { matchMediaRoute } from "./media-route.ts";
+import type { SiteState, StatusPageInput, StatusTheme } from "./status-page.ts";
+
+/** Feeds, sitemaps, `llms.txt`, search JSON, manifests: machines read these (§2.3). */
+export const MACHINE_PATH = /\.(?:xml|txt|json|rss|atom|webmanifest)$/i;
+
+/**
+ * True for a path that gets the status page before the first publish (§2.3): everything a
+ * person opens in a browser. `robots.txt`, media, static assets, `/.well-known/`, the
+ * operator endpoints, comment endpoints and machine paths keep their own answers.
+ */
+export function isStatusPagePath(pathname: string): boolean {
+  if (pathname === "/robots.txt") return false;
+  if (matchMediaRoute(pathname)) return false;
+  if (/^\/(?:_astro|_cloudhal|__cloudhal|\.well-known)\//.test(pathname)) return false;
+  if (isCommentsPath(pathname)) return false;
+  return !MACHINE_PATH.test(pathname);
+}
+
+/** What choosing the locale needs of a site (`localeRequest` reads nothing else). */
+export interface LocaleSite {
+  readonly locales: readonly string[];
+  readonly defaultLocale: string;
+  readonly localization?: Site["localization"] | undefined;
+}
+
+/** The path without trailing slashes (`/` for the root), in one linear pass: request text. */
+export function trimTrailingSlashes(pathname: string): string {
+  let end = pathname.length;
+  while (end > 0 && pathname.charCodeAt(end - 1) === 47) end--;
+  return end === 0 ? "/" : pathname.slice(0, end);
+}
+
+/** §1.4: the locale of the request's host or path prefix when it is the site's, else the default. */
+export function statusLocale(site: LocaleSite, host: string, pathname: string): string {
+  const path = trimTrailingSlashes(pathname);
+  try {
+    return localeRequest(site as Site, host, path).locale;
+  } catch {
+    return site.defaultLocale || "en";
+  }
+}
+
+const HEX = /^#[0-9a-f]{6}$/i;
+const FONTS: Record<string, StatusTheme["font"]> = {
+  editorial: "serif",
+  classic: "serif",
+  technical: "mono",
+  system: "sans",
+  modern: "sans",
+  humanist: "sans",
+};
+
+/**
+ * §1.3: the site's look as the status page may use it — `brand` (else `seed`), `surface` and
+ * `text` when they are `#rrggbb`, and the `typePairing` choice as a system font stack. Read from
+ * the published snapshot's site node only; everything else in `theme.config` is ignored.
+ */
+export function statusTheme(site: Pick<Site, "theme">): StatusTheme | undefined {
+  const config = (site.theme.config ?? {}) as Record<string, unknown>;
+  const color = (key: string) => {
+    const v = config[key];
+    return typeof v === "string" && HEX.test(v) ? v.toLowerCase() : undefined;
+  };
+  const pairing = config.typePairing;
+  const theme: StatusTheme = {
+    brand: color("brand") ?? color("seed"),
+    surface: color("surface"),
+    text: color("text"),
+    font: typeof pairing === "string" ? FONTS[pairing] : undefined,
+  };
+  return Object.values(theme).some((v) => v !== undefined) ? theme : undefined;
+}
+
+/** The site's logo when it is a same-origin media URL (§1.6). */
+export function statusLogo(site: Pick<Site, "brand">): string | undefined {
+  const src = site.brand?.logo?.src;
+  return src?.startsWith("/media/") ? src : undefined;
+}
+
+/**
+ * §1.6: the site data a state may show. `live` is the site node as it is now (the name only);
+ * `published` the published snapshot's, which also brings the logo and the theme tokens.
+ */
+export function statusInput(
+  state: SiteState,
+  sites: { live?: Site | undefined; published?: Site | undefined },
+  request: { host: string; pathname: string },
+  now: number,
+): StatusPageInput {
+  const site = sites.published ?? sites.live;
+  const locale = site ? statusLocale(site, request.host, request.pathname) : "en";
+  if (state === "unavailable" || state === "error" || !site) return { locale, now };
+  const showsBrand = sites.published !== undefined && state !== "not-published";
+  return {
+    locale,
+    now,
+    site: {
+      name: site.name,
+      ...(showsBrand && sites.published ? { logo: statusLogo(sites.published) } : {}),
+    },
+    ...(showsBrand && sites.published ? { theme: statusTheme(sites.published) } : {}),
+  };
+}
diff --git a/packages/astro-renderer/src/status-strings/ar.ts b/packages/astro-renderer/src/status-strings/ar.ts
new file mode 100644
index 00000000..bf06b450
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/ar.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): ar status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: b5c519cedb1faeba
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "قريبًا",
+    body: "لم يُنشر هذا الموقع بعد. عُد للزيارة قريبًا.",
+  },
+  maintenance: {
+    title: "سنعود قريبًا",
+    body: "هذا الموقع قيد الصيانة. شكرًا لصبرك.",
+  },
+  comingSoon: {
+    title: "قريبًا",
+    body: "لم يُفتح هذا الموقع بعد. عُد للزيارة قريبًا.",
+  },
+  unavailable: {
+    title: "غير متاح مؤقتًا",
+    body: "يتعذر الوصول إلى هذا الموقع الآن. يُرجى المحاولة مجددًا بعد بضع دقائق.",
+  },
+  error: {
+    title: "حدث خطأ ما",
+    body: "تعذر عرض هذه الصفحة. يُرجى المحاولة مجددًا بعد قليل.",
+  },
+  previewExpired: {
+    title: "انتهت صلاحية رابط المعاينة هذا",
+    body: "اطلب رابطًا جديدًا لعرض هذا الإصدار.",
+  },
+  backBy: "نعود بحلول {time}",
+  reference: "المرجع: {reference}",
+  builtWith: "صُنع باستخدام Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/catalog.ts b/packages/astro-renderer/src/status-strings/catalog.ts
new file mode 100644
index 00000000..6f0c8d62
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/catalog.ts
@@ -0,0 +1,52 @@
+// Generated by `pnpm i18n:import` (ADR-0034, RFC-0043 §1.5): every registered language's
+// status-page messages with its writing direction and `Intl` tag from Studio's locale registry.
+// Do not edit: add a language to `apps/studio/src/i18n/locales.ts` and import its catalogs.
+
+import { messages as ar } from "./ar.ts";
+import { messages as de } from "./de.ts";
+import { en, type StatusMessages } from "./en.ts";
+import { messages as es } from "./es.ts";
+import { messages as fa } from "./fa.ts";
+import { messages as fr } from "./fr.ts";
+import { messages as he } from "./he.ts";
+import { messages as hi } from "./hi.ts";
+import { messages as id } from "./id.ts";
+import { messages as it } from "./it.ts";
+import { messages as ja } from "./ja.ts";
+import { messages as ko } from "./ko.ts";
+import { messages as nl } from "./nl.ts";
+import { messages as pl } from "./pl.ts";
+import { messages as pt_BR } from "./pt-BR.ts";
+import { messages as ru } from "./ru.ts";
+import { messages as tr } from "./tr.ts";
+import { messages as uk } from "./uk.ts";
+import { messages as zh_Hans } from "./zh-Hans.ts";
+
+export interface StatusCatalogEntry {
+  readonly messages: StatusMessages;
+  readonly dir: "ltr" | "rtl";
+  /** The tag `Intl` formats with when it differs from the locale (Western digits, ADR-0033). */
+  readonly intl?: string;
+}
+
+export const STATUS_CATALOG: Readonly<Record<string, StatusCatalogEntry>> = {
+  en: { messages: en, dir: "ltr" },
+  tr: { messages: tr, dir: "ltr" },
+  de: { messages: de, dir: "ltr" },
+  es: { messages: es, dir: "ltr" },
+  fr: { messages: fr, dir: "ltr" },
+  it: { messages: it, dir: "ltr" },
+  "pt-BR": { messages: pt_BR, dir: "ltr" },
+  nl: { messages: nl, dir: "ltr" },
+  pl: { messages: pl, dir: "ltr" },
+  ru: { messages: ru, dir: "ltr" },
+  uk: { messages: uk, dir: "ltr" },
+  ja: { messages: ja, dir: "ltr" },
+  ko: { messages: ko, dir: "ltr" },
+  "zh-Hans": { messages: zh_Hans, dir: "ltr" },
+  hi: { messages: hi, dir: "ltr" },
+  id: { messages: id, dir: "ltr" },
+  ar: { messages: ar, dir: "rtl", intl: "ar-u-nu-latn" },
+  fa: { messages: fa, dir: "rtl", intl: "fa-u-nu-latn" },
+  he: { messages: he, dir: "rtl" },
+};
diff --git a/packages/astro-renderer/src/status-strings/de.ts b/packages/astro-renderer/src/status-strings/de.ts
new file mode 100644
index 00000000..80d876d9
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/de.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): de status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 96c78422069956fb
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Demnächst",
+    body: "Diese Website ist noch nicht veröffentlicht. Schauen Sie bald wieder vorbei.",
+  },
+  maintenance: {
+    title: "Wir sind bald zurück",
+    body: "Diese Website wird gerade gewartet. Vielen Dank für Ihre Geduld.",
+  },
+  comingSoon: {
+    title: "Demnächst",
+    body: "Diese Website ist noch nicht geöffnet. Schauen Sie bald wieder vorbei.",
+  },
+  unavailable: {
+    title: "Vorübergehend nicht erreichbar",
+    body: "Diese Website ist gerade nicht erreichbar. Bitte versuchen Sie es in ein paar Minuten erneut.",
+  },
+  error: {
+    title: "Etwas ist schiefgelaufen",
+    body: "Diese Seite konnte nicht angezeigt werden. Bitte versuchen Sie es gleich noch einmal.",
+  },
+  previewExpired: {
+    title: "Dieser Vorschaulink ist abgelaufen",
+    body: "Bitten Sie um einen neuen Link, um diese Version zu sehen.",
+  },
+  backBy: "Zurück bis {time}",
+  reference: "Referenz: {reference}",
+  builtWith: "Erstellt mit Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/en.ts b/packages/astro-renderer/src/status-strings/en.ts
new file mode 100644
index 00000000..d3ec845d
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/en.ts
@@ -0,0 +1,47 @@
+/**
+ * The words of the status pages (RFC-0043 §1.5): English is the source of truth for the keys,
+ * edited here by hand; every other registered language is generated by `pnpm i18n:import` from
+ * `.i18n/<locale>/status.json` (ADR-0034) and `catalog.ts` lists them all. Messages are ICU
+ * MessageFormat 1 restricted to simple `{argument}`s: nothing here counts or selects, so the
+ * renderer substitutes them itself and no compiler ships in the site Worker.
+ */
+export const en = {
+  /** Before the first publish (503): the site's name may sit above it. */
+  notPublished: {
+    title: "Coming soon",
+    body: "This site isn't published yet. Check back soon.",
+  },
+  /** Maintenance mode with the `maintenance` wording (503). */
+  maintenance: {
+    title: "We'll be back soon",
+    body: "This site is down for maintenance. Thanks for your patience.",
+  },
+  /** Maintenance mode with the `coming-soon` wording: a published site kept private until launch (503). */
+  comingSoon: {
+    title: "Coming soon",
+    body: "This site isn't open yet. Check back soon.",
+  },
+  /** The Worker serves no site, or its store cannot be read (503). */
+  unavailable: {
+    title: "Temporarily unavailable",
+    body: "This site can't be reached right now. Please try again in a few minutes.",
+  },
+  /** A render failure (500); the page shows a reference id a visitor can quote. */
+  error: {
+    title: "Something went wrong",
+    body: "This page couldn't be shown. Please try again in a moment.",
+  },
+  /** An expired, forged or otherwise invalid preview link (410). */
+  previewExpired: {
+    title: "This preview link has expired",
+    body: "Ask for a new link to see this version.",
+  },
+  /** When maintenance ends; {time} is a date and time in the site's time zone. */
+  backBy: "Back by {time}",
+  /** The error page's request id; {reference} is the id a visitor can quote to the owner. */
+  reference: "Reference: {reference}",
+  /** The footer of the built-in page. */
+  builtWith: "Built with Cloudhal",
+};
+
+export type StatusMessages = typeof en;
diff --git a/packages/astro-renderer/src/status-strings/es.ts b/packages/astro-renderer/src/status-strings/es.ts
new file mode 100644
index 00000000..e06f1ecf
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/es.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): es status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 328d0dacfe8b0e76
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Próximamente",
+    body: "Este sitio aún no está publicado. Vuelve pronto.",
+  },
+  maintenance: {
+    title: "Volveremos pronto",
+    body: "Este sitio está en mantenimiento. Gracias por tu paciencia.",
+  },
+  comingSoon: {
+    title: "Próximamente",
+    body: "Este sitio aún no está abierto. Vuelve pronto.",
+  },
+  unavailable: {
+    title: "Temporalmente no disponible",
+    body: "No es posible acceder a este sitio en este momento. Inténtalo de nuevo en unos minutos.",
+  },
+  error: {
+    title: "Algo salió mal",
+    body: "No se pudo mostrar esta página. Inténtalo de nuevo en un momento.",
+  },
+  previewExpired: {
+    title: "Este enlace de vista previa ha caducado",
+    body: "Pide un enlace nuevo para ver esta versión.",
+  },
+  backBy: "Volvemos el {time}",
+  reference: "Referencia: {reference}",
+  builtWith: "Creado con Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/fa.ts b/packages/astro-renderer/src/status-strings/fa.ts
new file mode 100644
index 00000000..6132131c
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/fa.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): fa status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 9902597705f57558
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "به‌زودی",
+    body: "این سایت هنوز منتشر نشده است. به‌زودی دوباره سر بزنید.",
+  },
+  maintenance: {
+    title: "به‌زودی برمی‌گردیم",
+    body: "این سایت در حال تعمیر و نگهداری است. از شکیبایی شما سپاسگزاریم.",
+  },
+  comingSoon: {
+    title: "به‌زودی",
+    body: "این سایت هنوز باز نشده است. به‌زودی دوباره سر بزنید.",
+  },
+  unavailable: {
+    title: "موقتاً در دسترس نیست",
+    body: "در حال حاضر نمی‌توان به این سایت دسترسی داشت. لطفاً چند دقیقه دیگر دوباره تلاش کنید.",
+  },
+  error: {
+    title: "مشکلی پیش آمد",
+    body: "این صفحه نمایش داده نشد. لطفاً کمی بعد دوباره تلاش کنید.",
+  },
+  previewExpired: {
+    title: "این پیوند پیش‌نمایش منقضی شده است",
+    body: "برای دیدن این نسخه، پیوند تازه‌ای درخواست کنید.",
+  },
+  backBy: "تا {time} برمی‌گردیم",
+  reference: "شناسه پیگیری: {reference}",
+  builtWith: "ساخته‌شده با Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/fr.ts b/packages/astro-renderer/src/status-strings/fr.ts
new file mode 100644
index 00000000..4c3dcb41
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/fr.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): fr status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 3766e010edaa51e7
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Bientôt disponible",
+    body: "Ce site n'est pas encore publié. Revenez bientôt.",
+  },
+  maintenance: {
+    title: "Nous revenons bientôt",
+    body: "Ce site est en maintenance. Merci de votre patience.",
+  },
+  comingSoon: {
+    title: "Bientôt disponible",
+    body: "Ce site n'est pas encore ouvert. Revenez bientôt.",
+  },
+  unavailable: {
+    title: "Temporairement indisponible",
+    body: "Ce site est inaccessible pour le moment. Veuillez réessayer dans quelques minutes.",
+  },
+  error: {
+    title: "Un problème est survenu",
+    body: "Cette page n'a pas pu être affichée. Veuillez réessayer dans un instant.",
+  },
+  previewExpired: {
+    title: "Ce lien d'aperçu a expiré",
+    body: "Demandez un nouveau lien pour voir cette version.",
+  },
+  backBy: "De retour le {time}",
+  reference: "Référence : {reference}",
+  builtWith: "Créé avec Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/he.ts b/packages/astro-renderer/src/status-strings/he.ts
new file mode 100644
index 00000000..b9b42885
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/he.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): he status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 14a7126c4a0192c8
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "בקרוב",
+    body: "האתר הזה עדיין לא פורסם. חזרו לבקר בקרוב.",
+  },
+  maintenance: {
+    title: "נחזור בקרוב",
+    body: "האתר הזה נמצא בתחזוקה. תודה על הסבלנות.",
+  },
+  comingSoon: {
+    title: "בקרוב",
+    body: "האתר הזה עדיין לא נפתח. חזרו לבקר בקרוב.",
+  },
+  unavailable: {
+    title: "לא זמין באופן זמני",
+    body: "אי אפשר להגיע לאתר כרגע. נסו שוב בעוד כמה דקות.",
+  },
+  error: {
+    title: "משהו השתבש",
+    body: "לא ניתן היה להציג את הדף הזה. נסו שוב בעוד רגע.",
+  },
+  previewExpired: {
+    title: "תוקף קישור התצוגה המקדימה פג",
+    body: "בקשו קישור חדש כדי לראות את הגרסה הזו.",
+  },
+  backBy: "נחזור עד {time}",
+  reference: "מספר אסמכתה: {reference}",
+  builtWith: "נבנה עם Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/hi.ts b/packages/astro-renderer/src/status-strings/hi.ts
new file mode 100644
index 00000000..6f3eb5b8
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/hi.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): hi status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: a36645c8efdccd2c
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "जल्द आ रहा है",
+    body: "यह साइट अभी प्रकाशित नहीं हुई है। जल्द ही दोबारा देखें।",
+  },
+  maintenance: {
+    title: "हम जल्द वापस आएंगे",
+    body: "यह साइट रखरखाव के लिए बंद है। आपके धैर्य के लिए धन्यवाद।",
+  },
+  comingSoon: {
+    title: "जल्द आ रहा है",
+    body: "यह साइट अभी खुली नहीं है। जल्द ही दोबारा देखें।",
+  },
+  unavailable: {
+    title: "अस्थायी रूप से अनुपलब्ध",
+    body: "इस साइट तक अभी नहीं पहुँचा जा सकता। कृपया कुछ मिनट बाद फिर से कोशिश करें।",
+  },
+  error: {
+    title: "कुछ गलत हो गया",
+    body: "यह पेज नहीं दिखाया जा सका। कृपया थोड़ी देर बाद फिर से कोशिश करें।",
+  },
+  previewExpired: {
+    title: "यह पूर्वावलोकन लिंक समाप्त हो गया है",
+    body: "यह संस्करण देखने के लिए नया लिंक माँगें।",
+  },
+  backBy: "{time} तक वापस",
+  reference: "संदर्भ: {reference}",
+  builtWith: "Cloudhal से बनाया गया",
+};
diff --git a/packages/astro-renderer/src/status-strings/id.ts b/packages/astro-renderer/src/status-strings/id.ts
new file mode 100644
index 00000000..c4ad5478
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/id.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): id status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 4f61cc5462b5cc67
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Segera hadir",
+    body: "Situs ini belum dipublikasikan. Kunjungi lagi nanti.",
+  },
+  maintenance: {
+    title: "Kami segera kembali",
+    body: "Situs ini sedang dalam pemeliharaan. Terima kasih atas kesabaran Anda.",
+  },
+  comingSoon: {
+    title: "Segera hadir",
+    body: "Situs ini belum dibuka. Kunjungi lagi nanti.",
+  },
+  unavailable: {
+    title: "Sementara tidak tersedia",
+    body: "Situs ini tidak dapat diakses saat ini. Coba lagi dalam beberapa menit.",
+  },
+  error: {
+    title: "Terjadi kesalahan",
+    body: "Halaman ini tidak dapat ditampilkan. Coba lagi sebentar lagi.",
+  },
+  previewExpired: {
+    title: "Tautan pratinjau ini sudah kedaluwarsa",
+    body: "Minta tautan baru untuk melihat versi ini.",
+  },
+  backBy: "Kembali pada {time}",
+  reference: "Referensi: {reference}",
+  builtWith: "Dibuat dengan Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/it.ts b/packages/astro-renderer/src/status-strings/it.ts
new file mode 100644
index 00000000..1a8f65aa
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/it.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): it status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 9e08b82495295521
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Prossimamente",
+    body: "Questo sito non è ancora pubblicato. Torna a trovarci presto.",
+  },
+  maintenance: {
+    title: "Torniamo presto",
+    body: "Questo sito è in manutenzione. Grazie per la pazienza.",
+  },
+  comingSoon: {
+    title: "Prossimamente",
+    body: "Questo sito non è ancora aperto. Torna a trovarci presto.",
+  },
+  unavailable: {
+    title: "Temporaneamente non disponibile",
+    body: "Al momento non è possibile raggiungere questo sito. Riprova tra qualche minuto.",
+  },
+  error: {
+    title: "Qualcosa è andato storto",
+    body: "Non è stato possibile mostrare questa pagina. Riprova tra poco.",
+  },
+  previewExpired: {
+    title: "Questo link di anteprima è scaduto",
+    body: "Chiedi un nuovo link per vedere questa versione.",
+  },
+  backBy: "Di ritorno entro {time}",
+  reference: "Riferimento: {reference}",
+  builtWith: "Creato con Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/ja.ts b/packages/astro-renderer/src/status-strings/ja.ts
new file mode 100644
index 00000000..9e29c170
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/ja.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): ja status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 58c8bbe001b9fdaf
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "近日公開",
+    body: "このサイトはまだ公開されていません。またのお越しをお待ちしています。",
+  },
+  maintenance: {
+    title: "まもなく再開します",
+    body: "このサイトはメンテナンス中です。しばらくお待ちください。",
+  },
+  comingSoon: {
+    title: "近日公開",
+    body: "このサイトはまだオープンしていません。またのお越しをお待ちしています。",
+  },
+  unavailable: {
+    title: "一時的にご利用いただけません",
+    body: "現在このサイトに接続できません。数分後にもう一度お試しください。",
+  },
+  error: {
+    title: "問題が発生しました",
+    body: "このページを表示できませんでした。しばらくしてからもう一度お試しください。",
+  },
+  previewExpired: {
+    title: "このプレビューリンクは期限切れです",
+    body: "このバージョンを見るには、新しいリンクを依頼してください。",
+  },
+  backBy: "{time} に再開予定",
+  reference: "参照番号: {reference}",
+  builtWith: "Cloudhal で作成",
+};
diff --git a/packages/astro-renderer/src/status-strings/ko.ts b/packages/astro-renderer/src/status-strings/ko.ts
new file mode 100644
index 00000000..e86fdb69
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/ko.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): ko status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 9e81d1a04a442f15
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "곧 공개됩니다",
+    body: "이 사이트는 아직 게시되지 않았습니다. 곧 다시 방문해 주세요.",
+  },
+  maintenance: {
+    title: "곧 돌아오겠습니다",
+    body: "이 사이트는 점검 중입니다. 기다려 주셔서 감사합니다.",
+  },
+  comingSoon: {
+    title: "곧 공개됩니다",
+    body: "이 사이트는 아직 열리지 않았습니다. 곧 다시 방문해 주세요.",
+  },
+  unavailable: {
+    title: "일시적으로 이용할 수 없습니다",
+    body: "지금은 이 사이트에 접속할 수 없습니다. 몇 분 후에 다시 시도해 주세요.",
+  },
+  error: {
+    title: "문제가 발생했습니다",
+    body: "이 페이지를 표시할 수 없습니다. 잠시 후 다시 시도해 주세요.",
+  },
+  previewExpired: {
+    title: "이 미리보기 링크가 만료되었습니다",
+    body: "이 버전을 보려면 새 링크를 요청하세요.",
+  },
+  backBy: "{time}에 다시 시작합니다",
+  reference: "참조 번호: {reference}",
+  builtWith: "Cloudhal로 제작",
+};
diff --git a/packages/astro-renderer/src/status-strings/nl.ts b/packages/astro-renderer/src/status-strings/nl.ts
new file mode 100644
index 00000000..1b9b8e4f
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/nl.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): nl status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: fe371781027a8452
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Binnenkort",
+    body: "Deze site is nog niet gepubliceerd. Kom binnenkort terug.",
+  },
+  maintenance: {
+    title: "We zijn snel terug",
+    body: "Deze site is in onderhoud. Bedankt voor uw geduld.",
+  },
+  comingSoon: {
+    title: "Binnenkort",
+    body: "Deze site is nog niet open. Kom binnenkort terug.",
+  },
+  unavailable: {
+    title: "Tijdelijk niet beschikbaar",
+    body: "Deze site is op dit moment niet bereikbaar. Probeer het over een paar minuten opnieuw.",
+  },
+  error: {
+    title: "Er is iets misgegaan",
+    body: "Deze pagina kon niet worden getoond. Probeer het zo meteen opnieuw.",
+  },
+  previewExpired: {
+    title: "Deze voorbeeldlink is verlopen",
+    body: "Vraag een nieuwe link aan om deze versie te bekijken.",
+  },
+  backBy: "Terug om {time}",
+  reference: "Referentie: {reference}",
+  builtWith: "Gemaakt met Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/pl.ts b/packages/astro-renderer/src/status-strings/pl.ts
new file mode 100644
index 00000000..9bf495d4
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/pl.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): pl status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: a0de1472a18c209e
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Już wkrótce",
+    body: "Ta strona nie została jeszcze opublikowana. Zajrzyj wkrótce.",
+  },
+  maintenance: {
+    title: "Wkrótce wracamy",
+    body: "Ta strona jest w trakcie konserwacji. Dziękujemy za cierpliwość.",
+  },
+  comingSoon: {
+    title: "Już wkrótce",
+    body: "Ta strona nie jest jeszcze otwarta. Zajrzyj wkrótce.",
+  },
+  unavailable: {
+    title: "Tymczasowo niedostępna",
+    body: "Nie można teraz połączyć się z tą stroną. Spróbuj ponownie za kilka minut.",
+  },
+  error: {
+    title: "Coś poszło nie tak",
+    body: "Nie udało się wyświetlić tej strony. Spróbuj ponownie za chwilę.",
+  },
+  previewExpired: {
+    title: "Ten link do podglądu wygasł",
+    body: "Poproś o nowy link, aby zobaczyć tę wersję.",
+  },
+  backBy: "Wracamy {time}",
+  reference: "Numer referencyjny: {reference}",
+  builtWith: "Stworzone z Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/pt-BR.ts b/packages/astro-renderer/src/status-strings/pt-BR.ts
new file mode 100644
index 00000000..0f0a7d24
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/pt-BR.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): pt-BR status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 85bbd6c18a5d4a89
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Em breve",
+    body: "Este site ainda não foi publicado. Volte em breve.",
+  },
+  maintenance: {
+    title: "Voltamos em breve",
+    body: "Este site está em manutenção. Obrigado pela paciência.",
+  },
+  comingSoon: {
+    title: "Em breve",
+    body: "Este site ainda não está aberto. Volte em breve.",
+  },
+  unavailable: {
+    title: "Temporariamente indisponível",
+    body: "Não é possível acessar este site agora. Tente novamente em alguns minutos.",
+  },
+  error: {
+    title: "Algo deu errado",
+    body: "Não foi possível mostrar esta página. Tente novamente em instantes.",
+  },
+  previewExpired: {
+    title: "Este link de pré-visualização expirou",
+    body: "Peça um novo link para ver esta versão.",
+  },
+  backBy: "De volta em {time}",
+  reference: "Referência: {reference}",
+  builtWith: "Feito com Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/ru.ts b/packages/astro-renderer/src/status-strings/ru.ts
new file mode 100644
index 00000000..208b5fc9
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/ru.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): ru status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 2ea252bc0f9d24f4
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Скоро",
+    body: "Этот сайт ещё не опубликован. Загляните позже.",
+  },
+  maintenance: {
+    title: "Мы скоро вернёмся",
+    body: "На сайте ведутся технические работы. Спасибо за терпение.",
+  },
+  comingSoon: {
+    title: "Скоро",
+    body: "Этот сайт ещё не открыт. Загляните позже.",
+  },
+  unavailable: {
+    title: "Временно недоступен",
+    body: "Сайт сейчас недоступен. Попробуйте снова через несколько минут.",
+  },
+  error: {
+    title: "Что-то пошло не так",
+    body: "Не удалось показать эту страницу. Попробуйте снова чуть позже.",
+  },
+  previewExpired: {
+    title: "Срок действия ссылки на предпросмотр истёк",
+    body: "Запросите новую ссылку, чтобы увидеть эту версию.",
+  },
+  backBy: "Вернёмся к {time}",
+  reference: "Код обращения: {reference}",
+  builtWith: "Создано с помощью Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/tr.ts b/packages/astro-renderer/src/status-strings/tr.ts
new file mode 100644
index 00000000..7c12afc7
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/tr.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): tr status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: ca071f0a31b002dd
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Çok yakında",
+    body: "Bu site henüz yayımlanmadı. Yakında tekrar bakın.",
+  },
+  maintenance: {
+    title: "Yakında geri döneceğiz",
+    body: "Bu site bakım nedeniyle kapalı. Sabrınız için teşekkürler.",
+  },
+  comingSoon: {
+    title: "Çok yakında",
+    body: "Bu site henüz açılmadı. Yakında tekrar bakın.",
+  },
+  unavailable: {
+    title: "Geçici olarak erişilemiyor",
+    body: "Bu siteye şu anda ulaşılamıyor. Lütfen birkaç dakika sonra tekrar deneyin.",
+  },
+  error: {
+    title: "Bir sorun oluştu",
+    body: "Bu sayfa gösterilemedi. Lütfen birazdan tekrar deneyin.",
+  },
+  previewExpired: {
+    title: "Bu önizleme bağlantısının süresi doldu",
+    body: "Bu sürümü görmek için yeni bir bağlantı isteyin.",
+  },
+  backBy: "{time} itibarıyla geri döneceğiz",
+  reference: "Referans: {reference}",
+  builtWith: "Cloudhal ile yapıldı",
+};
diff --git a/packages/astro-renderer/src/status-strings/uk.ts b/packages/astro-renderer/src/status-strings/uk.ts
new file mode 100644
index 00000000..7d92ffa5
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/uk.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): uk status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: 4c4d6784cfecafac
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "Незабаром",
+    body: "Цей сайт ще не опубліковано. Завітайте пізніше.",
+  },
+  maintenance: {
+    title: "Ми скоро повернемося",
+    body: "На сайті тривають технічні роботи. Дякуємо за терпіння.",
+  },
+  comingSoon: {
+    title: "Незабаром",
+    body: "Цей сайт ще не відкрито. Завітайте пізніше.",
+  },
+  unavailable: {
+    title: "Тимчасово недоступний",
+    body: "Сайт зараз недоступний. Спробуйте ще раз за кілька хвилин.",
+  },
+  error: {
+    title: "Щось пішло не так",
+    body: "Не вдалося показати цю сторінку. Спробуйте ще раз за мить.",
+  },
+  previewExpired: {
+    title: "Термін дії посилання на попередній перегляд минув",
+    body: "Попросіть нове посилання, щоб побачити цю версію.",
+  },
+  backBy: "Повернемося до {time}",
+  reference: "Код звернення: {reference}",
+  builtWith: "Створено за допомогою Cloudhal",
+};
diff --git a/packages/astro-renderer/src/status-strings/zh-Hans.ts b/packages/astro-renderer/src/status-strings/zh-Hans.ts
new file mode 100644
index 00000000..50f62af3
--- /dev/null
+++ b/packages/astro-renderer/src/status-strings/zh-Hans.ts
@@ -0,0 +1,34 @@
+// Generated by `pnpm i18n:import` (ADR-0034): zh-Hans status page messages.
+// Do not edit: change the translation file and import it; only English is edited here.
+// hash: f2bdbed0cee0a7bb
+import type { StatusMessages } from "./en.ts";
+
+export const messages: StatusMessages = {
+  notPublished: {
+    title: "即将上线",
+    body: "此网站尚未发布，请稍后再来。",
+  },
+  maintenance: {
+    title: "我们很快回来",
+    body: "此网站正在维护中，感谢您的耐心等待。",
+  },
+  comingSoon: {
+    title: "即将上线",
+    body: "此网站尚未开放，请稍后再来。",
+  },
+  unavailable: {
+    title: "暂时无法访问",
+    body: "目前无法连接此网站，请几分钟后重试。",
+  },
+  error: {
+    title: "出了点问题",
+    body: "无法显示此页面，请稍后重试。",
+  },
+  previewExpired: {
+    title: "此预览链接已过期",
+    body: "请索取新的链接以查看此版本。",
+  },
+  backBy: "预计 {time} 恢复",
+  reference: "参考编号：{reference}",
+  builtWith: "由 Cloudhal 构建",
+};
diff --git a/packages/astro-renderer/test/status-page.test.ts b/packages/astro-renderer/test/status-page.test.ts
new file mode 100644
index 00000000..03c11683
--- /dev/null
+++ b/packages/astro-renderer/test/status-page.test.ts
@@ -0,0 +1,510 @@
+/**
+ * RFC-0043 §1: the status pages as a pure function — every state's status, headers and
+ * `noindex`; the locale order and the catalog match (RTL included); the 8 KB and CSP budgets
+ * in every language; the owner's message escaped and never linked; the theme tokens typed; the
+ * machine variant; and the theme hook with each of its fallbacks.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Site } from "@cloudhal/core-contracts";
+import { describe, expect, it } from "vitest";
+import {
+  renderStatus,
+  resetHookFailures,
+  type StatusContext,
+  type StatusPageHook,
+  themeStatusHook,
+} from "../src/status-hook.ts";
+import { contrastRatio } from "../src/status-html.ts";
+import {
+  catalogLocale,
+  fillMessage,
+  HOOK_HTML_LIMIT,
+  SITE_STATES,
+  type SiteState,
+  STATUS_CSP,
+  STATUS_PAGE_LIMIT,
+  statusDirection,
+  statusPage,
+  statusPageHtml,
+  statusPlain,
+  statusStrings,
+} from "../src/status-page.ts";
+import {
+  isStatusPagePath,
+  statusInput,
+  statusLocale,
+  statusTheme,
+  trimTrailingSlashes,
+} from "../src/status-serve.ts";
+import { STATUS_CATALOG } from "../src/status-strings/catalog.ts";
+import { en } from "../src/status-strings/en.ts";
+
+const NOW = Date.parse("2026-11-08T10:00:00Z");
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Studio's locale registry (`apps/studio/src/i18n/locales.ts`), read as text: the catalog must
+ * list the same languages with the same direction and `Intl` tag, and the renderer's tsconfig
+ * cannot import across the apps/ boundary.
+ */
+function studioRegistry(): Record<string, { dir: string; intl?: string }> {
+  const source = readFileSync(
+    path.resolve(here, "../../../apps/studio/src/i18n/locales.ts"),
+    "utf8",
+  );
+  const body = source.slice(source.indexOf("LOCALE_REGISTRY = {"), source.indexOf("} as const"));
+  const out: Record<string, { dir: string; intl?: string }> = {};
+  for (const m of body.matchAll(
+    /^\s+"?([A-Za-z-]+)"?: \{ name: "[^"]*", dir: "(ltr|rtl)"[^}]*?(?:intl: "([^"]+)")?\s*\},?$/gm,
+  ))
+    out[m[1] as string] = { dir: m[2] as string, ...(m[3] ? { intl: m[3] } : {}) };
+  return out;
+}
+const base = { locale: "en", now: NOW };
+const bytes = (s: string) => new TextEncoder().encode(s).length;
+
+describe("statusPage: states, codes and headers (§1.2)", () => {
+  const expected: Record<SiteState, { status: number; retry?: string; noindex: boolean }> = {
+    "not-published": { status: 503, retry: "3600", noindex: true },
+    maintenance: { status: 503, retry: "3600", noindex: false },
+    unavailable: { status: 503, retry: "300", noindex: false },
+    error: { status: 500, noindex: false },
+    "preview-expired": { status: 410, noindex: true },
+  };
+
+  for (const state of SITE_STATES) {
+    it(`${state}: ${expected[state].status}`, async () => {
+      const res = statusPage(state, { ...base, rayId: "ray-1" });
+      const e = expected[state];
+      expect(res.status).toBe(e.status);
+      expect(res.headers.get("retry-after")).toBe(e.retry ?? null);
+      expect(res.headers.get("x-robots-tag")).toBe(e.noindex ? "noindex" : null);
+      expect(res.headers.get("cache-control")).toBe("no-store");
+      expect(res.headers.get("cloudflare-cdn-cache-control")).toBe("no-store");
+      expect(res.headers.get("x-cloudhal-state")).toBe(state);
+      expect(res.headers.get("content-type")).toBe("text/html; charset=utf-8");
+      expect(res.headers.get("content-security-policy")).toBe(STATUS_CSP);
+      expect(res.headers.get("x-content-type-options")).toBe("nosniff");
+      expect(res.headers.get("referrer-policy")).toBe("no-referrer");
+      const html = await res.text();
+      expect(html).toMatch(/^<!doctype html>/);
+      expect(html).toContain(`data-state="${state}"`);
+      expect(html.includes('<meta name="robots" content="noindex">')).toBe(e.noindex);
+      // exactly one h1, no scripts, no requests
+      expect(html.match(/<h1/g)).toHaveLength(1);
+      expect(html).not.toMatch(/<script/i);
+      expect(html).not.toMatch(/https?:\/\//);
+    });
+  }
+
+  it("HEAD gets the headers without a body", async () => {
+    const res = statusPage("not-published", base, { method: "HEAD" });
+    expect(res.status).toBe(503);
+    expect(res.headers.get("retry-after")).toBe("3600");
+    expect(await res.text()).toBe("");
+  });
+
+  it("maintenance: Retry-After counts to the end, at least 60 s, 3600 without an end", () => {
+    const until = (seconds: number) => ({
+      at: new Date(NOW + seconds * 1000).toISOString(),
+    });
+    const retry = (u?: { at: string }) =>
+      statusPage("maintenance", { ...base, until: u }).headers.get("retry-after");
+    expect(retry(until(600))).toBe("600");
+    expect(retry(until(10))).toBe("60");
+    expect(retry(until(-100))).toBe("60");
+    expect(retry()).toBe("3600");
+    expect(retry({ at: "not a date" })).toBe("3600");
+  });
+
+  it("error shows only the reference id", async () => {
+    const html = await statusPage("error", {
+      ...base,
+      rayId: "8f1c<script>",
+      site: { name: "Edge" },
+    }).text();
+    expect(html).toContain("Reference: 8f1c&lt;script&gt;");
+    expect(html).not.toContain("<script>");
+    expect(html).toContain("Edge");
+  });
+
+  it("the coming-soon wording and the owner's message, escaped and never linked", async () => {
+    const html = await statusPage("maintenance", {
+      ...base,
+      page: "coming-soon",
+      site: { name: "Launch <Co>" },
+      message: {
+        text: "Back on Monday.\nSee https://example.com <b>now</b> & 'then'",
+        locale: "en",
+      },
+    }).text();
+    expect(html).toContain(en.comingSoon.title);
+    expect(html).toContain("Launch &lt;Co&gt;");
+    expect(html).toContain("Back on Monday.<br>See https://example.com &lt;b&gt;now&lt;/b&gt;");
+    expect(html).not.toContain("<a ");
+    expect(html).not.toContain("<b>");
+  });
+
+  it("a message in another language gets its own lang and dir", async () => {
+    const html = await statusPage("maintenance", {
+      ...base,
+      locale: "en",
+      message: { text: "سنعود قريبًا", locale: "ar" },
+    }).text();
+    expect(html).toContain('<html lang="en" dir="ltr">');
+    expect(html).toContain('class="ch-status__message" lang="ar" dir="rtl"');
+  });
+
+  it("formats the end time in the site's zone, with Western digits for Arabic", () => {
+    const until = { at: "2026-11-02T08:00:00Z", timeZone: "Europe/Istanbul" };
+    const s = statusStrings("maintenance", { ...base, locale: "en", until });
+    expect(s.untilText).toMatch(/^Back by .*11:00/);
+    const ar = statusStrings("maintenance", { ...base, locale: "ar", until });
+    expect(ar.untilText).toMatch(/11:00/);
+    expect(ar.untilText).not.toMatch(/[٠-٩]/);
+    const bad = statusStrings("maintenance", {
+      ...base,
+      until: { at: until.at, timeZone: "Mars/Olympus" },
+    });
+    expect(bad.untilText).toMatch(/08:00/);
+  });
+
+  it("never throws on a broken input", async () => {
+    const res = statusPage("maintenance", {
+      locale: undefined as unknown as string,
+      now: Number.NaN,
+      message: { text: 1 as unknown as string, locale: "en" },
+      until: { at: "x" },
+    });
+    expect(res.status).toBe(503);
+    expect(await res.text()).toContain('data-state="maintenance"');
+  });
+});
+
+describe("language and direction (§1.4, §1.5)", () => {
+  it("matches the catalog exactly, then by language, then English", () => {
+    expect(catalogLocale("tr")).toBe("tr");
+    expect(catalogLocale("pt-PT")).toBe("pt-BR");
+    expect(catalogLocale("zh-HK")).toBe("zh-Hans");
+    expect(catalogLocale("de-AT")).toBe("de");
+    expect(catalogLocale("xx")).toBe("en");
+  });
+
+  it("sets lang and dir from the catalog; RTL by script for unlisted locales", async () => {
+    for (const locale of ["ar", "fa", "he"]) {
+      expect(statusDirection(locale)).toBe("rtl");
+      const html = await statusPage("not-published", { ...base, locale }).text();
+      expect(html).toContain(`<html lang="${locale}" dir="rtl">`);
+      expect(html).toContain(STATUS_CATALOG[locale]?.messages.notPublished.title);
+    }
+    expect(statusDirection("ur")).toBe("rtl");
+    expect(statusDirection("ku-Latn")).toBe("ltr");
+    expect(statusDirection("tr")).toBe("ltr");
+    expect(await statusPage("not-published", { ...base, locale: "tr" }).text()).toContain(
+      'lang="tr"',
+    );
+  });
+
+  it("carries every registered Studio language with its direction and Intl tag", () => {
+    const registry = studioRegistry();
+    expect(Object.keys(registry).length).toBeGreaterThan(10);
+    expect(Object.keys(STATUS_CATALOG).sort()).toEqual(Object.keys(registry).sort());
+    for (const [locale, info] of Object.entries(registry)) {
+      expect(STATUS_CATALOG[locale]?.dir, locale).toBe(info.dir);
+      expect(STATUS_CATALOG[locale]?.intl, locale).toBe(info.intl);
+    }
+  });
+
+  it("uses simple ICU arguments only, the same in every language", () => {
+    const flat = (o: object, prefix = ""): [string, string][] =>
+      Object.entries(o).flatMap(([k, v]) =>
+        typeof v === "string" ? [[`${prefix}${k}`, v]] : flat(v as object, `${prefix}${k}.`),
+      );
+    const args = (m: string) => [...m.matchAll(/\{([^}]*)\}/g)].map((x) => x[1]).sort();
+    const english = new Map(flat(en));
+    for (const [locale, entry] of Object.entries(STATUS_CATALOG)) {
+      const messages = new Map(flat(entry.messages));
+      expect([...messages.keys()].sort(), locale).toEqual([...english.keys()].sort());
+      for (const [key, value] of messages) {
+        expect(value, `${locale} ${key}`).not.toMatch(
+          /\{[^}]*,\s*(plural|select|selectordinal|number)/,
+        );
+        expect(args(value), `${locale} ${key}`).toEqual(args(english.get(key) as string));
+      }
+    }
+    expect(fillMessage("Back by {time}", { time: "noon" })).toBe("Back by noon");
+    expect(fillMessage("{a} {b}", { a: "x" })).toBe("x {b}");
+  });
+
+  it("chooses the request's locale from the host or path prefix, else the default (§1.4)", () => {
+    const site = {
+      locales: ["en", "tr", "de"],
+      defaultLocale: "en",
+      localization: { domains: { de: "de.example" } },
+    };
+    expect(statusLocale(site, "example.com", "/")).toBe("en");
+    expect(statusLocale(site, "example.com", "/tr/about/")).toBe("tr");
+    expect(statusLocale(site, "de.example", "/")).toBe("de");
+    expect(statusLocale(site, "example.com", "/fr/")).toBe("en");
+    expect(statusLocale({ locales: ["tr"], defaultLocale: "tr" }, "x", "/")).toBe("tr");
+  });
+
+  it("trims trailing slashes in linear time, however many there are", () => {
+    expect(trimTrailingSlashes("/")).toBe("/");
+    expect(trimTrailingSlashes("///")).toBe("/");
+    expect(trimTrailingSlashes("/tr/about/")).toBe("/tr/about");
+    expect(trimTrailingSlashes("/tr/about")).toBe("/tr/about");
+    const long = `/tr${"/".repeat(200_000)}`;
+    const started = performance.now();
+    expect(trimTrailingSlashes(long)).toBe("/tr");
+    expect(statusLocale({ locales: ["en", "tr"], defaultLocale: "en" }, "x", long)).toBe("tr");
+    expect(performance.now() - started).toBeLessThan(500);
+  });
+});
+
+describe("budget, CSP and site data (§1.3, §1.6)", () => {
+  it("stays under 8 KB in every state and language, with the longest message", () => {
+    const message = { text: "x".repeat(280), locale: "en" };
+    const until = { at: "2026-11-02T08:00:00Z", timeZone: "Europe/Istanbul" };
+    for (const locale of Object.keys(STATUS_CATALOG))
+      for (const state of SITE_STATES) {
+        const html = statusPageHtml(state, {
+          ...base,
+          locale,
+          site: {
+            name: "A site with a fairly long name for the budget",
+            logo: "/media/ab/logo.png",
+          },
+          message,
+          until,
+          rayId: "8f1c2d3e4a5b6c7d",
+          theme: { brand: "#123456", surface: "#ffffff", text: "#111111", font: "serif" },
+        });
+        expect(bytes(html), `${state} ${locale}`).toBeLessThanOrEqual(STATUS_PAGE_LIMIT);
+      }
+  });
+
+  it("uses logical properties only (ADR-0033)", () => {
+    const html = statusPageHtml("maintenance", { ...base, message: { text: "hi", locale: "en" } });
+    const css = html.match(/<style>([\s\S]*)<\/style>/)?.[1] ?? "";
+    expect(css).not.toMatch(
+      /(?:margin|padding|border)-(?:left|right)|(?<![-\w])(?:left|right)\s*:/,
+    );
+    expect(css).toContain("padding-inline");
+  });
+
+  it("shows the name and a same-origin logo only where the state allows (§1.6)", async () => {
+    const site = { name: "Edge", logo: "/media/ab12/logo.png" };
+    expect(await statusPage("not-published", { ...base, site }).text()).not.toContain("/media/");
+    expect(await statusPage("not-published", { ...base, site }).text()).toContain("Edge");
+    expect(await statusPage("preview-expired", { ...base, site }).text()).toContain(
+      'src="/media/ab12/logo.png"',
+    );
+    expect(await statusPage("unavailable", { ...base, site }).text()).not.toContain("Edge");
+    const external = { name: "Edge", logo: "https://cdn.example/logo.png" };
+    expect(await statusPage("maintenance", { ...base, site: external }).text()).not.toContain(
+      "cdn.example",
+    );
+  });
+
+  it("applies typed theme tokens on maintenance and preview-expired only, when they contrast", async () => {
+    const theme = { brand: "#123456", surface: "#ffffff", text: "#111111", font: "serif" as const };
+    const html = await statusPage("maintenance", { ...base, theme }).text();
+    expect(html).toContain("--ch-status-brand:#123456");
+    expect(html).toContain("--ch-status-surface:#ffffff;--ch-status-text:#111111");
+    expect(html).toContain("--ch-status-font:ui-serif");
+    expect(await statusPage("not-published", { ...base, theme }).text()).not.toContain("#123456");
+    // a pair that does not contrast is dropped, never "fixed"; a bad value never reaches CSS
+    const low = await statusPage("maintenance", {
+      ...base,
+      theme: { brand: "red;}body{display:none", surface: "#ffffff", text: "#eeeeee" },
+    }).text();
+    expect(low).not.toContain("display:none");
+    expect(low).not.toContain("--ch-status-surface:#ffffff");
+    expect(contrastRatio("#ffffff", "#111111")).toBeGreaterThan(15);
+  });
+
+  it("reads the tokens and the logo from a published site node (§1.3)", () => {
+    const site = {
+      theme: {
+        name: "blog",
+        config: { brand: "#2563EB", surface: "#fff", typePairing: "classic" },
+      },
+      brand: { logo: { src: "/media/ab12/logo.png", alt: "" } },
+    } as unknown as Site;
+    expect(statusTheme(site)).toEqual({
+      brand: "#2563eb",
+      surface: undefined,
+      text: undefined,
+      font: "serif",
+    });
+    expect(statusTheme({ theme: { name: "blog" } } as Site)).toBeUndefined();
+    const live = { ...site, name: "Live", locales: ["en"], defaultLocale: "en" } as Site;
+    const published = { ...live, name: "Published" } as Site;
+    const req = { host: "example.com", pathname: "/" };
+    expect(statusInput("not-published", { live }, req, NOW)).toEqual({
+      locale: "en",
+      now: NOW,
+      site: { name: "Live" },
+    });
+    expect(statusInput("preview-expired", { live, published }, req, NOW)).toMatchObject({
+      site: { name: "Published", logo: "/media/ab12/logo.png" },
+      theme: { brand: "#2563eb", font: "serif" },
+    });
+    expect(statusInput("unavailable", {}, req, NOW)).toEqual({ locale: "en", now: NOW });
+  });
+
+  it("statusPlain answers machines with the same status and headers", async () => {
+    const text = statusPlain("not-published", base, "text");
+    expect(text.status).toBe(503);
+    expect(text.headers.get("content-type")).toBe("text/plain; charset=utf-8");
+    expect(text.headers.get("retry-after")).toBe("3600");
+    expect(text.headers.get("cache-control")).toBe("no-store");
+    expect(text.headers.has("content-security-policy")).toBe(false);
+    expect(await text.text()).toBe(`${en.notPublished.title}. ${en.notPublished.body}\n`);
+    const json = statusPlain("maintenance", base, "json");
+    expect(await json.json()).toEqual({
+      error: "maintenance",
+      message: `${en.maintenance.title}. ${en.maintenance.body}`,
+    });
+  });
+
+  it("knows which paths get a page (§2.3)", () => {
+    for (const p of ["/", "/about", "/tr/hakkinda", "/search", "/posts/hello-world"])
+      expect(isStatusPagePath(p), p).toBe(true);
+    for (const p of [
+      "/robots.txt",
+      "/rss.xml",
+      "/sitemap.xml",
+      "/llms.txt",
+      "/search.json",
+      "/site.webmanifest",
+      "/media/0123456789abcdef/x.png",
+      "/_astro/x.css",
+      "/_cloudhal/p.js",
+      "/__cloudhal/comments",
+      "/.well-known/security.txt",
+    ])
+      expect(isStatusPagePath(p), p).toBe(false);
+  });
+});
+
+describe("theme hook (§1.7)", () => {
+  const input = { ...base, site: { name: "Edge" } };
+  const seen: string[] = [];
+  const log = (m: string) => seen.push(m);
+
+  it("a theme's document replaces the body; the renderer keeps status, headers and the site CSP", async () => {
+    const hook: StatusPageHook = (state, ctx) => {
+      expect(state).toBe("not-published");
+      expect(ctx.status).toBe(503);
+      expect(ctx.strings.title).toBe(en.notPublished.title);
+      return `<!doctype html><html><body><p>${ctx.strings.title} / ${ctx.site?.name}</p></body></html>`;
+    };
+    const res = await renderStatus("not-published", input, { hook, csp: "default-src 'self'" });
+    expect(res.status).toBe(503);
+    expect(res.headers.get("retry-after")).toBe("3600");
+    expect(res.headers.get("x-robots-tag")).toBe("noindex");
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect(res.headers.get("content-security-policy")).toBe("default-src 'self'");
+    expect(await res.text()).toBe(
+      "<!doctype html><html><body><p>Coming soon / Edge</p></body></html>",
+    );
+  });
+
+  it("defaultHtml restyles the built-in page; messageHtml and untilText are ready to use", async () => {
+    let ctx: StatusContext | undefined;
+    const hook: StatusPageHook = (_s, c) => {
+      ctx = c;
+      return c.defaultHtml({ css: "body{--hooked:1}" });
+    };
+    const html = await (
+      await renderStatus(
+        "maintenance",
+        {
+          ...input,
+          message: { text: "a <b>\nc", locale: "en" },
+          until: { at: "2026-11-02T08:00:00Z" },
+        },
+        { hook },
+      )
+    ).text();
+    expect(html).toContain("body{--hooked:1}");
+    expect(ctx?.messageHtml).toBe("a &lt;b&gt;<br>c");
+    expect(ctx?.untilText).toMatch(/^Back by /);
+    expect(ctx?.dir).toBe("ltr");
+  });
+
+  it("falls back to the built-in page on undefined, a throw, a non-string, > 64 KB or > 50 ms, logged once per state", async () => {
+    resetHookFailures();
+    seen.length = 0;
+    const cases: [string, StatusPageHook][] = [
+      ["undefined", () => undefined],
+      [
+        "throw",
+        () => {
+          throw new Error("boom");
+        },
+      ],
+      ["non-string", () => 42 as unknown as string],
+      ["too large", () => "x".repeat(HOOK_HTML_LIMIT + 1)],
+      ["too slow", () => new Promise((r) => setTimeout(() => r("<p>late</p>"), 40))],
+    ];
+    for (const [name, hook] of cases) {
+      const res = await renderStatus("not-published", input, {
+        hook,
+        onFailure: log,
+        timeoutMs: 10,
+      });
+      const html = await res.text();
+      expect(html, name).toContain('data-state="not-published"');
+      expect(res.headers.get("content-security-policy"), name).toBe(STATUS_CSP);
+    }
+    // four failures (undefined is not one), logged once for the state
+    expect(seen).toHaveLength(1);
+    expect(seen[0]).toContain("not-published");
+    const other = await renderStatus("maintenance", input, {
+      hook: () => {
+        throw new Error("boom");
+      },
+      onFailure: log,
+    });
+    expect(await other.text()).toContain('data-state="maintenance"');
+    expect(seen).toHaveLength(2);
+  });
+
+  it("never runs for error", async () => {
+    let called = false;
+    const hook: StatusPageHook = () => {
+      called = true;
+      return "<p>themed</p>";
+    };
+    const res = await renderStatus("error", { ...input, rayId: "r" }, { hook });
+    expect(called).toBe(false);
+    expect(await res.text()).toContain("Reference: r");
+  });
+
+  it("loads the theme module lazily and tolerates a theme without the export or that fails to load", async () => {
+    let loads = 0;
+    const withHook = themeStatusHook(async () => {
+      loads++;
+      return { statusPage: () => "<p>t</p>" };
+    });
+    expect(typeof (await withHook())).toBe("function");
+    await withHook();
+    expect(loads).toBe(1);
+    expect(await themeStatusHook(async () => ({ components: {} }))()).toBeUndefined();
+    const errors: string[] = [];
+    expect(
+      await themeStatusHook(
+        async () => {
+          throw new Error("no theme");
+        },
+        (m) => errors.push(m),
+      )(),
+    ).toBeUndefined();
+    expect(errors).toHaveLength(1);
+  });
+});
diff --git a/packages/cli/test/cloudflare-deploy.test.ts b/packages/cli/test/cloudflare-deploy.test.ts
index 820c77d0..5f46e62c 100644
--- a/packages/cli/test/cloudflare-deploy.test.ts
+++ b/packages/cli/test/cloudflare-deploy.test.ts
@@ -131,7 +131,12 @@ describe("Cloudflare deployment (admin + site Workers)", () => {
     // a missing build file is a real 404 (never the SPA shell under a script URL)
     expect((await adminFetch("/assets/Old-abc123.js")).status).toBe(404);
     expect((await adminFetch("/api/health")).status).toBe(200);
-    expect((await siteFetch("/")).status).toBe(500); // site row not pushed yet
+    // site row not pushed yet: `unavailable` (RFC-0043 §1.2), not the runtime's default error
+    const missing = await siteFetch("/");
+    expect(missing.status).toBe(503);
+    expect(missing.headers.get("x-cloudhal-state")).toBe("unavailable");
+    expect(missing.headers.get("retry-after")).toBe("300");
+    expect(missing.headers.get("cache-control")).toBe("no-store");
   });
 
   it("pushes the local project, then an agent publishes through MCP with human approval", async () => {
@@ -150,7 +155,10 @@ describe("Cloudflare deployment (admin + site Workers)", () => {
       body: JSON.stringify(bundle),
     });
     expect(pushed.status, await pushed.clone().text()).toBe(200);
-    expect((await siteFetch("/")).status).toBe(503); // pushed, never published
+    // pushed, never published: the not-published page (RFC-0043 §1.2)
+    const unpublished = await siteFetch("/");
+    expect(unpublished.status).toBe(503);
+    expect(unpublished.headers.get("x-cloudhal-state")).toBe("not-published");
 
     // the owner signs up and mints an agent key
     const browser = { origin: "https://admin.example" };
diff --git a/packages/cli/test/cloudflare-multisite.test.ts b/packages/cli/test/cloudflare-multisite.test.ts
index df52d967..94645ceb 100644
--- a/packages/cli/test/cloudflare-multisite.test.ts
+++ b/packages/cli/test/cloudflare-multisite.test.ts
@@ -2,7 +2,9 @@
  * RFC-0034 phase B: one Site Worker serves two sites of an installation, picked by hostname from
  * `site_hosts`, on real workerd (wrangler's test harness) against local D1 + R2. Unknown hosts get
  * a short-cached 404, never another site; the workers.dev host shows the first site, `noindex`; a
- * purge names its site and stays tag-only.
+ * purge names its site and stays tag-only. RFC-0043 §1.2: a third, unpublished site on its own
+ * host gets the status page while its siblings serve, with `no-store` and `Vary: Host`, so the
+ * path-keyed edge cache never hands one host's answer to another.
  */
 import { mkdtemp, rm, symlink } from "node:fs/promises";
 import os from "node:os";
@@ -29,6 +31,7 @@ describe("multi-site Site Worker on workerd (RFC-0034 §4)", () => {
   let tmp: string;
   let english: string;
   let turkish: string;
+  let unpublished: string;
   let harness: ReturnType<typeof createTestHarness>;
 
   beforeAll(async () => {
@@ -56,12 +59,26 @@ describe("multi-site Site Worker on workerd (RFC-0034 §4)", () => {
       const snap = await local.store.createSnapshot(id, { actor: human, reason: "publish" });
       await local.store.publish((await local.store.getSite(id)) as Site, snap.id);
     }
+    // RFC-0043: a third site with a hostname but no publish yet.
+    unpublished = (
+      await seedStarterSite(local.store, {
+        name: "New Edition",
+        slug: "new",
+        locale: "de",
+        projectId: first.projectId,
+      })
+    ).id;
+    const fresh = (await local.store.getSite(unpublished)) as Site;
+    await local.store.updateSite({
+      ...fresh,
+      domains: [{ hostname: "new.example.test", primary: true }],
+    });
     await writeWranglerConfig(
       siteConfigPath(projectDir),
       siteWorkerConfig({
         name: "multi-test",
         siteId: english,
-        siteIds: [english, turkish],
+        siteIds: [english, turkish, unpublished],
         databaseId: "00000000-0000-0000-0000-0000000c0de2",
       }),
       "test",
@@ -78,6 +95,7 @@ describe("multi-site Site Worker on workerd (RFC-0034 §4)", () => {
     // `cloudhal push` of both sites; the import writes their hostnames into site_hosts.
     await copySite(local, target, english);
     await copySite(local, target, turkish);
+    await copySite(local, target, unpublished);
     await local.close();
   }, 600_000);
 
@@ -101,6 +119,37 @@ describe("multi-site Site Worker on workerd (RFC-0034 §4)", () => {
     expect(trHtml).not.toContain("English Edition");
   });
 
+  it("gives an unpublished site its own status page, never a sibling's (RFC-0043 §1.2)", async () => {
+    const res = await harness.fetch("https://new.example.test/");
+    const html = await res.text();
+    expect(res.status, html.slice(0, 300)).toBe(503);
+    expect(res.headers.get("x-cloudhal-state")).toBe("not-published");
+    // nothing to key on a path-only edge cache, and a host variant on top
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect(res.headers.get("cloudflare-cdn-cache-control")).toBe("no-store");
+    expect(res.headers.get("vary")).toBe("Host");
+    expect(html).toContain('<html lang="de"');
+    expect(html).toContain("New Edition");
+    expect(html).not.toContain("English Edition");
+    // the siblings keep serving on their hosts
+    const en = await harness.fetch("https://en.example.test/");
+    expect(en.status).toBe(200);
+    expect(en.headers.get("x-cloudhal-state")).toBeNull();
+    expect(await en.text()).not.toContain("New Edition");
+    expect(
+      await (await harness.fetch("https://new.example.test/__cloudhal/health")).json(),
+    ).toEqual({
+      ok: true,
+      state: "not-published",
+    });
+    expect(await (await harness.fetch("https://tr.example.test/__cloudhal/health")).json()).toEqual(
+      {
+        ok: true,
+        state: "published",
+      },
+    );
+  });
+
   it("answers an unknown hostname with a short-cached 404, never another site", async () => {
     const res = await harness.fetch("https://unknown.example.test/");
     expect(res.status).toBe(404);
@@ -129,7 +178,11 @@ describe("multi-site Site Worker on workerd (RFC-0034 §4)", () => {
     // Without a site: every served site's tag, never purgeEverything.
     const all = (await (await purge({})).json()) as { tags?: string[] };
     expect(all.tags?.sort()).toEqual(
-      [`cloudhal-site-${english}`, `cloudhal-site-${turkish}`].sort(),
+      [
+        `cloudhal-site-${english}`,
+        `cloudhal-site-${turkish}`,
+        `cloudhal-site-${unpublished}`,
+      ].sort(),
     );
   });
 });
diff --git a/packages/cli/test/cloudflare-status.test.ts b/packages/cli/test/cloudflare-status.test.ts
new file mode 100644
index 00000000..4e724495
--- /dev/null
+++ b/packages/cli/test/cloudflare-status.test.ts
@@ -0,0 +1,172 @@
+/**
+ * RFC-0043 §1 on real workerd (wrangler's test harness): before the first publish the Site
+ * Worker answers page paths with the renderer's status page (503, `Retry-After`, `no-store`,
+ * `noindex`, its own CSP) before Astro runs, restyled by the project's `statusPage` theme hook;
+ * machine paths get the starter's plain answer; `/__cloudhal/health` says `not-published`; a
+ * preview token that does not verify answers 410 instead of the published page. A publish turns
+ * all of it into the real site.
+ */
+import { appendFile, mkdtemp, rm, symlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Site } from "@cloudhal/core-contracts";
+import { copySite, mintPreviewToken, SiteGraphStore } from "@cloudhal/core-ts";
+import { openLocalStore } from "@cloudhal/core-ts/local";
+import { migrate, migrations } from "@cloudhal/storage";
+import { D1Driver } from "@cloudhal/storage/d1";
+import { R2BlobStore } from "@cloudhal/storage/r2";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createTestHarness } from "wrangler";
+import { buildSiteWorker } from "../src/cloudflare/build.ts";
+import { siteConfigPath, siteWorkerConfig, writeWranglerConfig } from "../src/cloudflare/config.ts";
+import { init, readProjectConfig } from "../src/index.ts";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const STARTER_NODE_MODULES = path.resolve(here, "../../../starters/blog/node_modules");
+const PREVIEW_SECRET = "status-worker-test-preview-secret-32b!";
+const PURGE_TOKEN = "status-worker-test-purge-token";
+const human = { kind: "human" as const, id: "user_cfstatus001", name: "Halil" };
+
+/** The project's theme hook (§1.7): restyles every page but maintenance, which stays built in. */
+const THEME_HOOK = `
+// test: the status pages' theme hook (RFC-0043 §1.7)
+import type { StatusPageHook } from "@cloudhal/astro-renderer/status-page";
+export const statusPage: StatusPageHook = (state, ctx) =>
+  state === "maintenance" ? undefined : ctx.defaultHtml({ css: "/* hooked by the theme */" });
+`;
+
+describe("Site Worker status pages on workerd (RFC-0043 §1)", () => {
+  let tmp: string;
+  let siteId: string;
+  let harness: ReturnType<typeof createTestHarness>;
+  let remote: SiteGraphStore;
+
+  beforeAll(async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), "cloudhal-cf-status-"));
+    const projectDir = path.join(tmp, "site");
+    siteId = (await init({ dir: projectDir, name: "Edge Status <Site>" })).siteId;
+    await symlink(STARTER_NODE_MODULES, path.join(projectDir, "node_modules"), "dir");
+    await appendFile(path.join(projectDir, "src/theme.ts"), THEME_HOOK);
+    await writeWranglerConfig(
+      siteConfigPath(projectDir),
+      siteWorkerConfig({
+        name: "status-test",
+        siteId,
+        databaseId: "00000000-0000-0000-0000-0000000c0de3",
+      }),
+      "test",
+    );
+    const config = await buildSiteWorker(projectDir);
+    harness = createTestHarness({
+      root: projectDir,
+      workers: [
+        {
+          configPath: config,
+          secrets: { CLOUDHAL_PREVIEW_SECRET: PREVIEW_SECRET, CLOUDHAL_PURGE_TOKEN: PURGE_TOKEN },
+        },
+      ],
+    });
+    await harness.listen();
+    const env = (await harness.getWorker().getEnv()) as { DB: D1Database; BLOBS: R2Bucket };
+    const target = { sql: new D1Driver(env.DB), blobs: new R2BlobStore(env.BLOBS) };
+    await migrate(target.sql, migrations);
+    // `cloudhal push` of a project nobody has published yet.
+    const cfg = await readProjectConfig(projectDir);
+    const local = await openLocalStore(path.join(projectDir, cfg.dataDir));
+    await copySite(local, target, siteId);
+    await local.close();
+    remote = new SiteGraphStore(target);
+  }, 600_000);
+
+  afterAll(async () => {
+    await harness?.close();
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const get = (p: string, init?: Parameters<typeof harness.fetch>[1]) =>
+    harness.fetch(`https://status.example${p}`, init);
+
+  it("answers page paths with the not-published page before the first publish", async () => {
+    const res = await get("/");
+    const html = await res.text();
+    expect(res.status, html.slice(0, 300)).toBe(503);
+    expect(res.headers.get("x-cloudhal-state")).toBe("not-published");
+    expect(res.headers.get("retry-after")).toBe("3600");
+    expect(res.headers.get("x-robots-tag")).toBe("noindex");
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect(res.headers.get("cloudflare-cdn-cache-control")).toBe("no-store");
+    expect(res.headers.get("vary")).toBe("Host");
+    expect(res.headers.get("content-type")).toContain("text/html");
+    // the theme hook restyled the built-in page: the site CSP, not the built-in one
+    expect(html).toContain("/* hooked by the theme */");
+    expect(res.headers.get("content-security-policy")).toContain("script-src 'self'");
+    expect(html).toContain("<h1>Coming soon</h1>");
+    expect(html).toContain("Edge Status &lt;Site&gt;");
+    expect(html).not.toContain("<script");
+    expect(html).not.toMatch(/https?:\/\//);
+    expect(new TextEncoder().encode(html).length).toBeLessThanOrEqual(8192);
+    expect((await get("/about")).status).toBe(503);
+    expect((await get("/posts/hello-world")).headers.get("x-cloudhal-state")).toBe("not-published");
+    const head = await get("/", { method: "HEAD" });
+    expect(head.status).toBe(503);
+    expect(await head.text()).toBe("");
+  });
+
+  it("machine paths and robots.txt keep their own answers", async () => {
+    const rss = await get("/rss.xml");
+    expect(rss.status).toBe(503);
+    expect(rss.headers.get("content-type")).toContain("text/plain");
+    expect(rss.headers.get("x-cloudhal-state")).toBe("not-published");
+    expect(await rss.text()).toContain("Coming soon.");
+    const robots = await get("/robots.txt");
+    expect(robots.status).toBe(503);
+    expect(await robots.text()).toContain("Disallow: /");
+    expect((await get("/sitemap.xml")).status).toBe(503);
+  });
+
+  it("health says not-published with the admin's shape", async () => {
+    const res = await get("/__cloudhal/health");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("cache-control")).toBe("no-store");
+    expect(res.headers.get("x-robots-tag")).toBe("noindex");
+    expect(await res.json()).toEqual({ ok: true, state: "not-published" });
+  });
+
+  it("a preview token that does not verify answers 410; a valid one shows the draft", async () => {
+    const bad = await get("/?cloudhal-preview=not-a-token");
+    expect(bad.status).toBe(410);
+    expect(bad.headers.get("x-cloudhal-state")).toBe("preview-expired");
+    expect(bad.headers.get("x-robots-tag")).toBe("noindex");
+    expect(bad.headers.get("cache-control")).toBe("no-store");
+    expect(await bad.text()).toContain("This preview link has expired");
+    const token = await mintPreviewToken(PREVIEW_SECRET, { site: siteId, target: "live" });
+    const ok = await get(`/?cloudhal-preview=${token}`);
+    expect(ok.status).toBe(200);
+    expect(ok.headers.get("x-cloudhal-mode")).toBe("preview");
+  });
+
+  it("a publish turns the pages, the feed and health into the real site", async () => {
+    const site = (await remote.getSite(siteId)) as Site;
+    const snap = await remote.createSnapshot(siteId, { actor: human, reason: "publish" });
+    await remote.publish(site, snap.id);
+    const purge = await get("/__cloudhal/purge", {
+      method: "POST",
+      headers: { authorization: `Bearer ${PURGE_TOKEN}` },
+    });
+    expect(purge.status).toBe(200);
+    const res = await get("/");
+    expect(res.status).toBe(200);
+    expect(res.headers.get("x-cloudhal-mode")).toBe("published");
+    expect(res.headers.get("x-cloudhal-state")).toBeNull();
+    expect((await get("/rss.xml")).status).toBe(200);
+    expect(await (await get("/__cloudhal/health")).json()).toEqual({
+      ok: true,
+      state: "published",
+    });
+    // an invalid preview link still never falls back to the published page (§1.2)
+    const bad = await get("/about?cloudhal-preview=expired");
+    expect(bad.status).toBe(410);
+    expect(await bad.text()).toContain("Edge Status &lt;Site&gt;");
+  });
+});
diff --git a/packages/cli/test/cloudflare.test.ts b/packages/cli/test/cloudflare.test.ts
index 7058c323..30fcbb1e 100644
--- a/packages/cli/test/cloudflare.test.ts
+++ b/packages/cli/test/cloudflare.test.ts
@@ -188,10 +188,14 @@ describe("Site Worker on workerd", () => {
       expect(href).toContain(`cloudhal-preview=${encodeURIComponent(token)}`);
     // without the token: the published version
     expect(await aboutTitle()).toBe("About");
-    // a forged token falls back to published and is not cacheable
+    // a forged token answers the preview-expired page (RFC-0043 §1.2), never the published
+    // page and never cacheable, so a reviewer cannot approve the wrong version
     const forged = await get(`/about?cloudhal-preview=${token.slice(0, -4)}AAAA`);
-    expect(forged.headers.get("x-cloudhal-mode")).toBe("published");
-    expect(forged.headers.get("x-cloudhal-preview-error")).toMatch(/signature/);
+    expect(forged.status).toBe(410);
+    expect(forged.headers.get("x-cloudhal-state")).toBe("preview-expired");
+    expect(forged.headers.get("cache-control")).toBe("no-store");
+    expect(forged.headers.get("cloudflare-cdn-cache-control")).toBe("no-store");
+    expect(await forged.text()).toContain("This preview link has expired");
   });
 
   it("only lets the admin purge", async () => {
diff --git a/packages/cli/test/dev-status.test.ts b/packages/cli/test/dev-status.test.ts
new file mode 100644
index 00000000..87c520e3
--- /dev/null
+++ b/packages/cli/test/dev-status.test.ts
@@ -0,0 +1,132 @@
+/**
+ * RFC-0043 §1.8 in a real `cloudhal dev` (a child process: Astro disables its dev middleware
+ * under Vitest): dev renders the working copy, so real pages never get a status page, and the
+ * status middleware draws each state on demand at `/__cloudhal/status/<state>` through the
+ * same module and the project's theme hook.
+ */
+import { type ChildProcess, spawn } from "node:child_process";
+import { appendFile, mkdtemp, rm, symlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { init } from "../src/index.ts";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const STARTER_NODE_MODULES = path.resolve(here, "../../../starters/blog/node_modules");
+const BIN = path.resolve(here, "../bin/cloudhal.ts");
+
+const THEME_HOOK = `
+// test: the status pages' theme hook (RFC-0043 §1.7)
+import type { StatusPageHook } from "@cloudhal/astro-renderer/status-page";
+export const statusPage: StatusPageHook = (state, ctx) =>
+  state === "maintenance" ? undefined : ctx.defaultHtml({ css: "/* hooked in dev */" });
+`;
+
+async function spawnDev(
+  projectDir: string,
+  port: number,
+): Promise<{ child: ChildProcess; url: string }> {
+  const { VITEST: _v, NODE_ENV: _n, ...env } = process.env;
+  const child = spawn(process.execPath, [BIN, "dev", "--port", String(port)], {
+    cwd: projectDir,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let output = "";
+  const url = await new Promise<string>((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`cloudhal dev did not start:\n${output}`)),
+      60_000,
+    );
+    const onData = (chunk: Buffer) => {
+      output += chunk.toString();
+      const m = output.match(/cloudhal dev → (http:\/\/\S+)/);
+      if (m) {
+        clearTimeout(timer);
+        resolve(m[1] as string);
+      }
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      reject(new Error(`cloudhal dev exited with ${code}:\n${output}`));
+    });
+  });
+  return { child, url };
+}
+
+describe("cloudhal dev status pages (RFC-0043 §1.8)", () => {
+  let tmp: string;
+  let projectDir: string;
+
+  beforeAll(async () => {
+    tmp = await mkdtemp(path.join(os.tmpdir(), "cloudhal-dev-status-"));
+    projectDir = path.join(tmp, "site");
+    // never published: dev still renders the working copy
+    await init({ dir: projectDir, name: "Dev Status" });
+    await symlink(STARTER_NODE_MODULES, path.join(projectDir, "node_modules"), "dir");
+    await appendFile(path.join(projectDir, "src/theme.ts"), THEME_HOOK);
+  });
+
+  afterAll(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  it("renders real pages, and draws each status page on demand with the theme hook", async () => {
+    const port = 40000 + Math.floor(Math.random() * 20000);
+    const server = await spawnDev(projectDir, port);
+    try {
+      let home: Response | undefined;
+      for (let i = 0; i < 40; i++) {
+        home = await fetch(new URL("/", server.url));
+        if (home.status === 200 && (await home.clone().text()).includes("<h1")) break;
+        await new Promise((r) => setTimeout(r, 250));
+      }
+      expect(home?.status).toBe(200);
+
+      const tr = await fetch(new URL("/__cloudhal/status/not-published?locale=tr", server.url));
+      const trHtml = await tr.text();
+      expect(tr.status).toBe(503);
+      expect(tr.headers.get("x-cloudhal-state")).toBe("not-published");
+      expect(tr.headers.get("retry-after")).toBe("3600");
+      expect(tr.headers.get("cache-control")).toBe("no-store");
+      expect(trHtml).toContain('<html lang="tr" dir="ltr">');
+      expect(trHtml).toContain("Çok yakında");
+      expect(trHtml).toContain("Dev Status");
+      expect(trHtml).toContain("/* hooked in dev */");
+
+      const until = new Date(Date.now() + 3600_000).toISOString();
+      const m = await fetch(
+        new URL(
+          `/__cloudhal/status/maintenance?page=coming-soon&message=Launching%20soon&until=${until}`,
+          server.url,
+        ),
+      );
+      const mHtml = await m.text();
+      expect(m.status).toBe(503);
+      expect(m.headers.get("x-robots-tag")).toBeNull();
+      expect(Number(m.headers.get("retry-after"))).toBeGreaterThan(3000);
+      // the hook left maintenance to the built-in page: its own CSP, no theme CSS
+      expect(m.headers.get("content-security-policy")).toContain("default-src 'none'");
+      expect(mHtml).not.toContain("/* hooked in dev */");
+      expect(mHtml).toContain("Launching soon");
+      expect(mHtml).toContain("Back by ");
+      expect(mHtml).toContain("<h1>Coming soon</h1>");
+
+      const ar = await fetch(new URL("/__cloudhal/status/preview-expired?locale=ar", server.url));
+      expect(ar.status).toBe(410);
+      expect(await ar.text()).toContain('<html lang="ar" dir="rtl">');
+
+      const error = await fetch(new URL("/__cloudhal/status/error", server.url));
+      expect(error.status).toBe(500);
+      expect(await error.text()).toContain("Reference: dev-preview");
+
+      expect((await fetch(new URL("/__cloudhal/status/nope", server.url))).status).toBe(404);
+    } finally {
+      server.child.kill("SIGTERM");
+      await new Promise((r) => server.child.once("exit", r));
+    }
+  });
+});
diff --git a/scripts/i18n-exchange.ts b/scripts/i18n-exchange.ts
index 88a8d33a..5f76aab0 100644
--- a/scripts/i18n-exchange.ts
+++ b/scripts/i18n-exchange.ts
@@ -10,33 +10,48 @@
  *                                              the catalog tests
  *   node scripts/i18n-exchange.ts check        fails if a non-English catalog was edited by hand
  *
- * `<file>` is `core` (the core catalog) or a namespace. Only `en.ts` and `lazy/<ns>.en.ts` are
- * edited by hand: every other catalog is generated and carries a hash of its messages, so a hand
- * edit fails `check` (and `test/i18n-messages.test.ts`).
+ * `<file>` is `core` (the core catalog), a namespace, or `status` (the renderer's status pages,
+ * RFC-0043 §1.5, in `packages/astro-renderer/src/status-strings/`). Only `en.ts`,
+ * `lazy/<ns>.en.ts` and `status-strings/en.ts` are edited by hand: every other catalog is
+ * generated and carries a hash of its messages, so a hand edit fails `check` (and
+ * `test/i18n-messages.test.ts`).
  */
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { LOCALE_LIST } from "../apps/studio/src/i18n/locales.ts";
+import { LOCALE_LIST, LOCALE_REGISTRY } from "../apps/studio/src/i18n/locales.ts";
 import { compileMessage } from "../packages/messages/src/compile.ts";
 import { catalogEntries } from "./i18n-codemod/catalog-entries.ts";
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const STUDIO = path.join(ROOT, "apps/studio");
 const I18N = path.join(STUDIO, "src/i18n");
+/** The renderer's status-page catalog (RFC-0043 §1.5): the same flow, one file per language. */
+const STATUS = path.join(ROOT, "packages/astro-renderer/src/status-strings");
 type Tree = { [key: string]: string | Tree };
 
-/** Every catalog file of `locale`: `core` and each namespace, with its path. */
-function files(locale: string): { name: string; file: string; ns?: string }[] {
+interface CatalogFile {
+  name: string;
+  file: string;
+  ns?: string;
+  kind: "core" | "lazy" | "status";
+}
+
+/** Every catalog file of `locale`: `core`, each namespace and `status`, with its path. */
+function files(locale: string): CatalogFile[] {
   const lazy = readdirSync(path.join(I18N, "lazy"))
     .filter((f) => f.endsWith(`.${locale}.ts`))
-    .map((f) => {
+    .map((f): CatalogFile => {
       const ns = f.slice(0, -`.${locale}.ts`.length);
-      return { name: ns, file: path.join(I18N, "lazy", f), ns };
+      return { name: ns, file: path.join(I18N, "lazy", f), ns, kind: "lazy" };
     });
-  return [{ name: "core", file: path.join(I18N, `${locale}.ts`) }, ...lazy];
+  return [
+    { name: "core", file: path.join(I18N, `${locale}.ts`), kind: "core" },
+    ...lazy,
+    { name: "status", file: path.join(STATUS, `${locale}.ts`), kind: "status" },
+  ];
 }
 
 /** Languages with catalogs on disk (export, check). */
@@ -63,6 +78,8 @@ async function exportAll(out: string) {
   for (const locale of locales()) {
     mkdirSync(path.join(out, locale), { recursive: true });
     for (const { name, file, ns } of files(locale)) {
+      // a language registered after its last import has no status catalog yet
+      if (!existsSync(file)) continue;
       const tree = await load(file, locale === "en", ns);
       writeFileSync(path.join(out, locale, `${name}.json`), `${JSON.stringify(tree, null, 2)}\n`);
       if (locale !== "en") continue;
@@ -101,23 +118,84 @@ const literal = (tree: Tree) =>
   JSON.stringify(tree, null, 2).replace(/^(\s*)"([A-Za-z_$][\w$]*)":/gm, "$1$2:");
 
 /** The generated module for one catalog file, keeping what follows its messages (`dropped`). */
-function render(locale: string, name: string, tree: Tree, previous: string | undefined): string {
-  const ns = name === "core" ? undefined : name;
+function render(
+  locale: string,
+  entry: CatalogFile,
+  tree: Tree,
+  previous: string | undefined,
+): string {
+  const ns = entry.ns;
   const extras = previous?.match(/\n\};\n([\s\S]*)$/)?.[1]?.trim();
   const body = ns ? { [ns]: tree } : tree;
+  const what = ns ? `\`${ns}.*\`` : entry.kind === "status" ? "status page" : "core";
+  const type =
+    entry.kind === "status"
+      ? { import: 'import type { StatusMessages } from "./en.ts";', name: "StatusMessages" }
+      : ns
+        ? {
+            import: 'import type { NamespaceMessages } from "../namespaces.ts";',
+            name: `NamespaceMessages<"${ns}">`,
+          }
+        : { import: 'import type { Messages } from "./en.ts";', name: "Messages" };
   const head = [
-    `// Generated by \`pnpm i18n:import\` (ADR-0034): ${locale} ${ns ? `\`${ns}.*\`` : "core"} messages.`,
+    `// Generated by \`pnpm i18n:import\` (ADR-0034): ${locale} ${what} messages.`,
     "// Do not edit: change the translation file and import it; only English is edited here.",
     `// hash: ${hashOf(tree)}`,
-    ns
-      ? 'import type { NamespaceMessages } from "../namespaces.ts";'
-      : 'import type { Messages } from "./en.ts";',
+    type.import,
     "",
-    `export const messages: ${ns ? `NamespaceMessages<"${ns}">` : "Messages"} = ${literal(body)};`,
+    `export const messages: ${type.name} = ${literal(body)};`,
   ];
   return `${head.join("\n")}\n${extras ? `\n${extras}\n` : ""}`;
 }
 
+/** Where `locale`'s generated catalog for `entry` is written. */
+function targetOf(locale: string, entry: CatalogFile): string {
+  if (entry.kind === "status") return path.join(STATUS, `${locale}.ts`);
+  if (entry.ns) return path.join(I18N, "lazy", `${entry.ns}.${locale}.ts`);
+  return path.join(I18N, `${locale}.ts`);
+}
+
+/**
+ * The renderer's catalog index (RFC-0043 §1.5): every registered language's status messages
+ * with its writing direction and `Intl` tag from the registry, so a language added to Studio
+ * reaches the site Worker with its first import and nothing is wired by hand.
+ */
+function statusCatalogModule(): string {
+  const ident = (l: string) => l.replace(/-/g, "_");
+  const entries = registered().map((l) => {
+    const info = LOCALE_REGISTRY[l];
+    const intl = info.intl ? `, intl: "${info.intl}"` : "";
+    return `  "${l}": { messages: ${l === "en" ? "en" : ident(l)}, dir: "${info.dir}"${intl} },`;
+  });
+  // in Biome's import order, so the generated file passes `pnpm lint` as written
+  const imports = [...registered()]
+    .sort((a, b) => a.localeCompare(b, "en"))
+    .map((l) =>
+      l === "en"
+        ? 'import { en, type StatusMessages } from "./en.ts";'
+        : `import { messages as ${ident(l)} } from "./${l}.ts";`,
+    );
+  return [
+    "// Generated by `pnpm i18n:import` (ADR-0034, RFC-0043 §1.5): every registered language's",
+    "// status-page messages with its writing direction and `Intl` tag from Studio's locale registry.",
+    "// Do not edit: add a language to `apps/studio/src/i18n/locales.ts` and import its catalogs.",
+    "",
+    ...imports,
+    "",
+    "export interface StatusCatalogEntry {",
+    "  readonly messages: StatusMessages;",
+    '  readonly dir: "ltr" | "rtl";',
+    "  /** The tag `Intl` formats with when it differs from the locale (Western digits, ADR-0033). */",
+    "  readonly intl?: string;",
+    "}",
+    "",
+    "export const STATUS_CATALOG: Readonly<Record<string, StatusCatalogEntry>> = {",
+    ...entries,
+    "};",
+    "",
+  ].join("\n");
+}
+
 /** Where `locale`'s lazy namespaces load from, kept out of the first load (`namespaces.ts`). */
 const loaderModule = (locale: string) =>
   [
@@ -134,7 +212,8 @@ async function importAll(out: string, only: string | undefined, check: boolean)
   for (const locale of registered().filter((l) => l !== "en" && (!only || l === only))) {
     const errors: string[] = [];
     const rendered: [string, string][] = [];
-    for (const { name, file, ns } of files("en")) {
+    for (const entry of files("en")) {
+      const { name, file, ns } = entry;
       const english = await load(file, true, ns);
       const json = path.join(out, locale, `${name}.json`);
       if (!existsSync(json)) {
@@ -147,11 +226,9 @@ async function importAll(out: string, only: string | undefined, check: boolean)
         ns ? `${ns}.` : "",
         errors,
       );
-      const target = ns
-        ? path.join(I18N, "lazy", `${ns}.${locale}.ts`)
-        : path.join(I18N, `${locale}.ts`);
+      const target = targetOf(locale, entry);
       const previous = existsSync(target) ? readFileSync(target, "utf8") : undefined;
-      rendered.push([target, render(locale, name, tree, previous)]);
+      rendered.push([target, render(locale, entry, tree, previous)]);
     }
     rendered.push([path.join(I18N, "loaders", `${locale}.ts`), loaderModule(locale)]);
     if (errors.length) throw new Error(`${locale}: nothing written\n  ${errors.join("\n  ")}`);
@@ -159,6 +236,11 @@ async function importAll(out: string, only: string | undefined, check: boolean)
     for (const [target, text] of rendered) writeFileSync(target, text);
     written.push(...rendered.map(([t]) => t));
   }
+  if (written.length) {
+    const catalog = path.join(STATUS, "catalog.ts");
+    writeFileSync(catalog, statusCatalogModule());
+    written.push(catalog);
+  }
   if (written.length)
     execFileSync("pnpm", ["exec", "biome", "format", "--write", ...written], {
       cwd: ROOT,
@@ -181,6 +263,7 @@ export async function handEdited(): Promise<string[]> {
   const out: string[] = [];
   for (const locale of locales().filter((l) => l !== "en"))
     for (const { file, ns } of files(locale)) {
+      if (!existsSync(file)) continue;
       const hash = readFileSync(file, "utf8").match(/^\/\/ hash: ([0-9a-f]+)$/m)?.[1];
       const tree = await load(file, false, ns);
       if (hash !== hashOf(tree)) out.push(path.relative(ROOT, file));
diff --git a/starters/blog/src/pages/[...path].astro b/starters/blog/src/pages/[...path].astro
index 83c3b723..e08aa75d 100644
--- a/starters/blog/src/pages/[...path].astro
+++ b/starters/blog/src/pages/[...path].astro
@@ -48,6 +48,7 @@ import {
   siteOrigin,
   withStructuredData,
 } from "@cloudhal/astro-renderer/seo";
+import { statusPage } from "@cloudhal/astro-renderer/status-page";
 import { loadSurfaceSources, surfaceSources } from "@cloudhal/astro-renderer/surfaces";
 import {
   entryTaxonomy,
@@ -114,7 +115,8 @@ export async function getStaticPaths() {
 }
 
 const source = await getSource(config, Astro);
-if (!source) return new Response("This site has not been published yet.", { status: 503 });
+// RFC-0043 §1.8: on Cloudflare and in dev the renderer answers before this; the fallback is its page.
+if (!source) return statusPage("not-published", { locale: "en", now: Date.now() });
 const site = await source.site();
 const requested = Astro.params.path ? `/${Astro.params.path}` : "/";
 // RFC-0033 §4: the locale is in the path prefix or the host; a non-canonical locale URL moves.
diff --git a/starters/blog/src/pages/[...path]/llms.txt.ts b/starters/blog/src/pages/[...path]/llms.txt.ts
index 97a37e4f..e64e22c8 100644
--- a/starters/blog/src/pages/[...path]/llms.txt.ts
+++ b/starters/blog/src/pages/[...path]/llms.txt.ts
@@ -4,6 +4,7 @@ import { llmsTxt } from "@cloudhal/astro-renderer/locale-feeds";
 import { localeRequest } from "@cloudhal/astro-renderer/locales";
 import { getSource } from "@cloudhal/astro-renderer/runtime";
 import { siteOrigin } from "@cloudhal/astro-renderer/seo";
+import { statusPlain } from "@cloudhal/astro-renderer/status-page";
 import type { APIRoute } from "astro";
 
 /** Static builds: `/<locale>/llms.txt` for every other locale served on this host. */
@@ -23,7 +24,7 @@ export async function getStaticPaths() {
 export const GET: APIRoute = async ({ request, url, params }) => {
   const headers = new Headers();
   const source = await getSource(config, { request, response: { headers } });
-  if (!source) return new Response("This site has not been published yet.", { status: 503 });
+  if (!source) return statusPlain("not-published", { locale: "en", now: Date.now() }, "text");
   const site = await source.site();
   const lr = localeRequest(site, url.host, `/${params.path ?? ""}`);
   if (lr.path !== "/") return new Response(null, { status: 404 });
diff --git a/starters/blog/src/pages/[...path]/rss.xml.ts b/starters/blog/src/pages/[...path]/rss.xml.ts
index 17e6908e..01266e73 100644
--- a/starters/blog/src/pages/[...path]/rss.xml.ts
+++ b/starters/blog/src/pages/[...path]/rss.xml.ts
@@ -12,6 +12,7 @@ import { loadAssetIndex } from "@cloudhal/astro-renderer/media";
 import { resolveRoute, staticPaths } from "@cloudhal/astro-renderer/routing";
 import { getSource } from "@cloudhal/astro-renderer/runtime";
 import { siteOrigin } from "@cloudhal/astro-renderer/seo";
+import { statusPlain } from "@cloudhal/astro-renderer/status-page";
 import type { APIRoute } from "astro";
 import { ARCHIVE_PAGE_SIZE } from "../../theme.ts";
 
@@ -46,7 +47,7 @@ export async function getStaticPaths() {
 export const GET: APIRoute = async ({ request, url, params }) => {
   const headers = new Headers();
   const source = await getSource(config, { request, response: { headers } });
-  if (!source) return new Response("This site has not been published yet.", { status: 503 });
+  if (!source) return statusPlain("not-published", { locale: "en", now: Date.now() }, "text");
   const site = await source.site();
   const origin = siteOrigin(site, url);
   const lr = localeRequest(site, url.host, `/${params.path ?? ""}`);
diff --git a/starters/blog/src/pages/llms.txt.ts b/starters/blog/src/pages/llms.txt.ts
index dca67a6d..c51e3b37 100644
--- a/starters/blog/src/pages/llms.txt.ts
+++ b/starters/blog/src/pages/llms.txt.ts
@@ -4,13 +4,14 @@ import { llmsTxt } from "@cloudhal/astro-renderer/locale-feeds";
 import { hostLocale } from "@cloudhal/astro-renderer/locales";
 import { getSource } from "@cloudhal/astro-renderer/runtime";
 import { siteOrigin } from "@cloudhal/astro-renderer/seo";
+import { statusPlain } from "@cloudhal/astro-renderer/status-page";
 import type { APIRoute } from "astro";
 
 /** `llms.txt` (llmstxt.org) in the host's locale; other locales at `/<locale>/llms.txt` (RFC-0033). */
 export const GET: APIRoute = async ({ request, url }) => {
   const headers = new Headers();
   const source = await getSource(config, { request, response: { headers } });
-  if (!source) return new Response("This site has not been published yet.", { status: 503 });
+  if (!source) return statusPlain("not-published", { locale: "en", now: Date.now() }, "text");
   const site = await source.site();
   headers.set("content-type", "text/plain; charset=utf-8");
   addCacheTags(headers, [listCacheTag(site.id)]);
diff --git a/starters/blog/src/pages/rss.xml.ts b/starters/blog/src/pages/rss.xml.ts
index b92a06ae..6b60ccaf 100644
--- a/starters/blog/src/pages/rss.xml.ts
+++ b/starters/blog/src/pages/rss.xml.ts
@@ -4,6 +4,7 @@ import { localeFeedXml } from "@cloudhal/astro-renderer/locale-feeds";
 import { hostLocale } from "@cloudhal/astro-renderer/locales";
 import { getSource } from "@cloudhal/astro-renderer/runtime";
 import { siteOrigin } from "@cloudhal/astro-renderer/seo";
+import { statusPlain } from "@cloudhal/astro-renderer/status-page";
 import type { APIRoute } from "astro";
 
 /**
@@ -13,7 +14,7 @@ import type { APIRoute } from "astro";
 export const GET: APIRoute = async ({ request, url }) => {
   const headers = new Headers();
   const source = await getSource(config, { request, response: { headers } });
-  if (!source) return new Response("This site has not been published yet.", { status: 503 });
+  if (!source) return statusPlain("not-published", { locale: "en", now: Date.now() }, "text");
   const site = await source.site();
   headers.set("content-type", "application/rss+xml; charset=utf-8");
   // Lists every collection's newest entries: any entry change purges it (`cloudhal-list-<site>`).
diff --git a/starters/blog/src/pages/sitemap.xml.ts b/starters/blog/src/pages/sitemap.xml.ts
index 7475ac2b..21bde422 100644
--- a/starters/blog/src/pages/sitemap.xml.ts
+++ b/starters/blog/src/pages/sitemap.xml.ts
@@ -4,6 +4,7 @@ import { sitemapXml } from "@cloudhal/astro-renderer/feeds";
 import { localizedSitemap } from "@cloudhal/astro-renderer/locale-feeds";
 import { getSource } from "@cloudhal/astro-renderer/runtime";
 import { siteOrigin } from "@cloudhal/astro-renderer/seo";
+import { statusPlain } from "@cloudhal/astro-renderer/status-page";
 import type { APIRoute } from "astro";
 
 /**
@@ -13,7 +14,7 @@ import type { APIRoute } from "astro";
 export const GET: APIRoute = async ({ request, url }) => {
   const headers = new Headers();
   const source = await getSource(config, { request, response: { headers } });
-  if (!source) return new Response("This site has not been published yet.", { status: 503 });
+  if (!source) return statusPlain("not-published", { locale: "en", now: Date.now() }, "text");
   const site = await source.site();
   headers.set("content-type", "application/xml; charset=utf-8");
   // Lists every page, entry and indexable archive: any entry or term change purges it.