diff --git a/.changeset/prune-unroutable-ssr-island.md b/.changeset/prune-unroutable-ssr-island.md
new file mode 100644
index 0000000000..4d8838a0c9
--- /dev/null
+++ b/.changeset/prune-unroutable-ssr-island.md
@@ -0,0 +1,5 @@
+---
+"@agent-native/core": patch
+---
+
+Stop shipping the SSR page/asset module island inside the background and integration-recovery function clones. Those entries overwrite `url.pathname` unconditionally before delegating to `main.mjs`, so they can never route to the page or asset handlers they inherited — yet Netlify zips and uploads every function separately, so the island was paid for on every deploy. The pruner walks the clone's real import graph (including backtick dynamic imports) and refuses to prune at all when a relative dynamic import cannot be resolved statically. Measured on calendar: total upload 42.2MB → 35.8MB.
diff --git a/.changeset/shrink-serverless-function-payloads.md b/.changeset/shrink-serverless-function-payloads.md
new file mode 100644
index 0000000000..5f80cc9d59
--- /dev/null
+++ b/.changeset/shrink-serverless-function-payloads.md
@@ -0,0 +1,5 @@
+---
+"@agent-native/core": patch
+---
+
+Cut serverless function payloads across every app. `@xterm/*` is now stubbed out of the SSR graph by default (it is only reachable through a `React.lazy` boundary the server can never take), and `formatExtensionHtml` loads `prettier/standalone` plus the four plugins the HTML printer actually reaches instead of prettier's main entry, which `import()`s all 13 parsers and inlines ~3.5MB of flow/typescript/yaml parsers. Measured: calendar 46.7MB → 21.1MB, docs 51MB → 26MB.
diff --git a/packages/core/src/deploy/build.spec.ts b/packages/core/src/deploy/build.spec.ts
index 98cc6da599..399cbf93d1 100644
--- a/packages/core/src/deploy/build.spec.ts
+++ b/packages/core/src/deploy/build.spec.ts
@@ -70,6 +70,7 @@ import {
   shouldBundleFfmpegStaticForServerless,
   writeSingleTemplateNetlifyRedirects,
 } from "./build.js";
+import { pruneSsrIslandFromRewritingClone } from "./function-bundle.js";
 import { IMMUTABLE_ASSET_CACHE_CONTROL } from "./immutable-assets.js";
 import {
   renderNetlifyStaticHeaders,
@@ -3444,3 +3445,67 @@ describe("bundleImportsLibsqlNativeAddon", () => {
     expect(bundleImportsLibsqlNativeAddon(dir)).toBe(false);
   });
 });
+
+describe("pruneSsrIslandFromRewritingClone", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "ssr-island-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const REWRITING_ENTRY =
+    'const url = new URL(req.url);\nurl.pathname = "/_x";\n';
+
+  function scaffold(): void {
+    fs.writeFileSync(
+      path.join(dir, "main.mjs"),
+      'import "./_...page_.get.mjs";\nimport "./_process-run.mjs";\n',
+    );
+    // Rolldown emits backtick dynamic imports; a quote-only scan would miss this
+    // edge and delete a chunk the background function still needs.
+    fs.writeFileSync(
+      path.join(dir, "_process-run.mjs"),
+      "export const run = () => import(`./keep.mjs`);\n",
+    );
+    fs.writeFileSync(path.join(dir, "keep.mjs"), "export default 1;\n");
+    fs.writeFileSync(
+      path.join(dir, "_...page_.get.mjs"),
+      'import "./page-only.mjs";\n',
+    );
+    fs.writeFileSync(path.join(dir, "page-only.mjs"), "export default 2;\n");
+  }
+
+  it("drops the page island and keeps what the background entry still reaches", () => {
+    scaffold();
+
+    pruneSsrIslandFromRewritingClone(dir, REWRITING_ENTRY);
+
+    expect(fs.existsSync(path.join(dir, "_...page_.get.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "page-only.mjs"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "main.mjs"))).toBe(true);
+    expect(fs.existsSync(path.join(dir, "keep.mjs"))).toBe(true);
+  });
+
+  it("refuses to prune a clone whose entry does not rewrite the pathname", () => {
+    scaffold();
+
+    expect(() =>
+      pruneSsrIslandFromRewritingClone(dir, "export default handler;\n"),
+    ).toThrow(/rewrites url\.pathname/);
+  });
+
+  it("prunes nothing when a relative dynamic import cannot be resolved", () => {
+    scaffold();
+    fs.writeFileSync(
+      path.join(dir, "_process-run.mjs"),
+      "export const run = (n) => import(`./${n}.mjs`);\n",
+    );
+
+    expect(pruneSsrIslandFromRewritingClone(dir, REWRITING_ENTRY)).toBe(0);
+    expect(fs.existsSync(path.join(dir, "page-only.mjs"))).toBe(true);
+  });
+});
diff --git a/packages/core/src/deploy/build.ts b/packages/core/src/deploy/build.ts
index 9d661bc3c2..6891096a76 100644
--- a/packages/core/src/deploy/build.ts
+++ b/packages/core/src/deploy/build.ts
@@ -72,7 +72,11 @@ import {
   createAgentNativeConfigContext,
   loadResolvedAgentNativeConfig,
 } from "../vite/agent-native-config-loader.js";
-import { cloneServerBundleForFunction, copyDir } from "./function-bundle.js";
+import {
+  cloneServerBundleForFunction,
+  copyDir,
+  pruneSsrIslandFromRewritingClone,
+} from "./function-bundle.js";
 import {
   collectImmutableAssetPaths,
   IMMUTABLE_ASSET_CACHE_CONTROL,
@@ -3523,6 +3527,17 @@ export const config = {
 };
 `;
   fs.writeFileSync(path.join(dest, `${backgroundName}.mjs`), entry);
+  {
+    // The clone rewrites url.pathname unconditionally, so it can never
+    // route to the SSR page/asset handlers it inherited. Netlify zips and
+    // uploads every function separately, so that island is paid for twice.
+    const freed = pruneSsrIslandFromRewritingClone(dest, entry);
+    if (freed > 0) {
+      console.log(
+        `[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`,
+      );
+    }
+  }
   assertEmittedBackgroundFunctionOnDisk(dest, backgroundName);
   console.log(
     `[build] Emitted durable-background function "${backgroundName}" into the ` +
@@ -3628,6 +3643,17 @@ export const config = {
 };
 `;
   fs.writeFileSync(path.join(dest, `${functionName}.mjs`), entry);
+  {
+    // The clone rewrites url.pathname unconditionally, so it can never route to
+    // the SSR page/asset handlers it inherited. Netlify zips and uploads every
+    // function separately, so that island is paid for on every deploy.
+    const freed = pruneSsrIslandFromRewritingClone(dest, entry);
+    if (freed > 0) {
+      console.log(
+        `[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`,
+      );
+    }
+  }
 }
 
 /**
diff --git a/packages/core/src/deploy/function-bundle.ts b/packages/core/src/deploy/function-bundle.ts
index e72711eae0..c114529272 100644
--- a/packages/core/src/deploy/function-bundle.ts
+++ b/packages/core/src/deploy/function-bundle.ts
@@ -98,3 +98,102 @@ function copyTree(
     }
   }
 }
+
+/** Nitro's SSR page/asset route entries. Only the `/*` server function uses these. */
+const SSR_ENTRY_FILES = [
+  "_...page_.get.mjs",
+  "_...page_.head.mjs",
+  "_...asset_.get.mjs",
+];
+
+// Rolldown emits `import(`./x.mjs`)` with BACKTICKS; a quote-only pattern
+// under-reports the graph by tens of MB and would delete reachable chunks.
+const SPECIFIER = /(?:from|import|require)\s*\(?\s*(["'`])([^"'`]*)\1/g;
+
+// `import(`${pkg}/server`)` is a BARE specifier and can never name a local
+// chunk. Only a specifier that is relative BEFORE the interpolation is
+// genuinely unresolvable, and that is when we must not guess.
+const RELATIVE_INTERPOLATED = /import\s*\(\s*`\s*[./][^`]*\$\{/;
+
+/**
+ * Every file reachable from `main.mjs`, treating `removed` as already deleted.
+ * Returns null when the graph cannot be resolved statically, so the caller
+ * prunes nothing rather than deleting a chunk something still imports.
+ */
+function reachableFiles(dir: string, removed: Set<string>): Set<string> | null {
+  const seen = new Set<string>();
+  const visit = (file: string): boolean => {
+    if (seen.has(file)) return true;
+    seen.add(file);
+    let src: string;
+    try {
+      src = fs.readFileSync(file, "utf-8");
+    } catch {
+      return true;
+    }
+    if (RELATIVE_INTERPOLATED.test(src)) return false;
+    SPECIFIER.lastIndex = 0;
+    for (let m: RegExpExecArray | null; (m = SPECIFIER.exec(src)); ) {
+      const spec = m[2];
+      if (!spec.startsWith(".")) continue;
+      const base = path.resolve(path.dirname(file), spec);
+      const hit = [
+        base,
+        `${base}.mjs`,
+        `${base}.js`,
+        path.join(base, "index.mjs"),
+      ].find((c) => fs.existsSync(c) && fs.statSync(c).isFile());
+      // Docs prose inside the bundle contains path-shaped strings that are not
+      // imports; a specifier resolving to nothing is not an edge.
+      if (!hit) continue;
+      if (removed.has(path.relative(dir, hit))) continue;
+      if (!visit(hit)) return false;
+    }
+    return true;
+  };
+  return visit(path.join(dir, "main.mjs")) ? seen : null;
+}
+
+/**
+ * Drop the SSR page/asset island from a clone that can never route to it.
+ *
+ * The background and integration-recovery entries overwrite `url.pathname`
+ * unconditionally before delegating to `main.mjs`, so those clones cannot reach
+ * the page or asset handlers — yet each shipped a full copy of that island, and
+ * Netlify zips and uploads every function separately. Deleting from the clone is
+ * safe under hard links: only an in-place WRITE would reach the source bundle.
+ */
+export function pruneSsrIslandFromRewritingClone(
+  dest: string,
+  entryText: string,
+): number {
+  if (!/^\s*url\.pathname\s*=/m.test(entryText)) {
+    throw new Error(
+      "[deploy] SSR prune requires a clone entry that rewrites url.pathname unconditionally",
+    );
+  }
+  const full = reachableFiles(dest, new Set());
+  const lean = reachableFiles(dest, new Set(SSR_ENTRY_FILES));
+  if (!full || !lean) {
+    console.warn(
+      "[deploy] SSR prune skipped: unresolvable relative dynamic import in the clone.",
+    );
+    return 0;
+  }
+
+  let bytes = 0;
+  for (const file of full) {
+    if (lean.has(file)) continue;
+    try {
+      bytes += fs.statSync(file).size;
+      fs.rmSync(file, { force: true });
+    } catch {
+      // coercion-ok: a file already gone is the goal state, and its bytes were
+      // read before the unlink, so the reported total stays honest.
+    }
+  }
+  for (const name of SSR_ENTRY_FILES) {
+    fs.rmSync(path.join(dest, name), { force: true });
+  }
+  return bytes;
+}
diff --git a/packages/core/src/deploy/workspace-deploy.ts b/packages/core/src/deploy/workspace-deploy.ts
index 4a8d3f12f4..b4c8155cae 100644
--- a/packages/core/src/deploy/workspace-deploy.ts
+++ b/packages/core/src/deploy/workspace-deploy.ts
@@ -52,7 +52,10 @@ import {
   assertEmittedBackgroundFunctionOnDisk,
   isRecurringJobsDeployEnabled,
 } from "./build.js";
-import { cloneServerBundleForFunction } from "./function-bundle.js";
+import {
+  cloneServerBundleForFunction,
+  pruneSsrIslandFromRewritingClone,
+} from "./function-bundle.js";
 import {
   collectImmutableAssetPaths,
   IMMUTABLE_ASSET_CACHE_HEADERS,
@@ -1012,6 +1015,17 @@ export const config = {
   // is the function entrypoint, mirroring patchNetlifyFunctionEntry.
   fs.rmSync(path.join(dest, "server.mjs"), { force: true });
   fs.writeFileSync(path.join(dest, `${backgroundName}.mjs`), server);
+  {
+    // The clone rewrites url.pathname unconditionally, so it can never
+    // route to the SSR page/asset handlers it inherited. Netlify zips and
+    // uploads every function separately, so that island is paid for twice.
+    const freed = pruneSsrIslandFromRewritingClone(dest, server);
+    if (freed > 0) {
+      console.log(
+        `[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`,
+      );
+    }
+  }
   assertEmittedBackgroundFunctionOnDisk(dest, backgroundName);
   console.log(
     `[workspace-deploy] Emitted durable-background function "${backgroundName}" ` +
@@ -1119,6 +1133,17 @@ export const config = {
 };
 `;
   fs.writeFileSync(path.join(dest, `${functionName}.mjs`), entry);
+  {
+    // The clone rewrites url.pathname unconditionally, so it can never route to
+    // the SSR page/asset handlers it inherited. Netlify zips and uploads every
+    // function separately, so that island is paid for on every deploy.
+    const freed = pruneSsrIslandFromRewritingClone(dest, entry);
+    if (freed > 0) {
+      console.log(
+        `[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unroutable SSR modules from ${path.basename(dest)}.`,
+      );
+    }
+  }
 }
 
 function patchNetlifyFunctionEntry(
diff --git a/packages/core/src/extensions/content-patch.ts b/packages/core/src/extensions/content-patch.ts
index b5ed207d96..c2b64a2957 100644
--- a/packages/core/src/extensions/content-patch.ts
+++ b/packages/core/src/extensions/content-patch.ts
@@ -137,10 +137,22 @@ async function applyExtensionContentUpdateUnchecked(
 
 export async function formatExtensionHtml(content: string): Promise<string> {
   try {
-    const prettier = await import("prettier");
-    const formatted = await prettier.format(content, {
+    // prettier's main entry `import()`s all 13 parser plugins, so a bundler
+    // inlines ~3.5MB of flow/typescript/yaml/markdown parsers just to format
+    // HTML. Load the standalone core plus only the plugins the HTML printer
+    // reaches, which still formats embedded <style> (postcss) and <script>
+    // (babel + estree).
+    const [{ format }, ...plugins] = await Promise.all([
+      import("prettier/standalone"),
+      import("prettier/plugins/html"),
+      import("prettier/plugins/postcss"),
+      import("prettier/plugins/babel"),
+      import("prettier/plugins/estree"),
+    ]);
+    const formatted = await format(content, {
       parser: "html",
       htmlWhitespaceSensitivity: "ignore",
+      plugins,
     });
     return typeof formatted === "string" ? formatted : content;
   } catch (err: any) {
diff --git a/packages/core/src/vite/client.ts b/packages/core/src/vite/client.ts
index 889363db1c..731329d820 100644
--- a/packages/core/src/vite/client.ts
+++ b/packages/core/src/vite/client.ts
@@ -2536,6 +2536,19 @@ function rolldownInputFix(): Plugin {
  * The template lists the packages in its `defineConfig({ ssrStubs })` call —
  * the framework never hardcodes package names.
  */
+/**
+ * Optional peers reached only through a `React.lazy` boundary whose module body
+ * guards on `typeof window === "undefined"`. The server can never import them,
+ * so their SSR chunk is pure unpack weight in every app that ships a terminal
+ * surface. Defaulted here rather than repeated in sixteen vite configs, where
+ * it would drift.
+ */
+const ALWAYS_SSR_STUBBED = [
+  "@xterm/xterm",
+  "@xterm/addon-fit",
+  "@xterm/addon-web-links",
+];
+
 function ssrStubPlugin(packages: string[]): Plugin | null {
   if (!packages.length) return null;
   const stubbed = new Set(packages);
@@ -3445,7 +3458,7 @@ function createAgentNativePlugins(
     // don't bloat the edge worker. Opt-in per template — the framework
     // hardcodes nothing (e.g. docs sites legitimately import `shiki` on
     // the server, so we can't blanket-stub it here).
-    ssrStubPlugin(options.ssrStubs ?? []),
+    ssrStubPlugin([...ALWAYS_SSR_STUBBED, ...(options.ssrStubs ?? [])]),
     ...userPlugins,
     appChangelogRawPlugin(),
     actionTypesPlugin(),
diff --git a/packages/docs/app/components/docs-availability.ts b/packages/docs/app/components/docs-availability.ts
index c757dafa4c..f02fa5f126 100644
--- a/packages/docs/app/components/docs-availability.ts
+++ b/packages/docs/app/components/docs-availability.ts
@@ -4,31 +4,12 @@ import {
   isDocsLocale,
   type DocsLocale,
 } from "./docs-locale";
-
-// SEO only needs to know whether a source file exists. Keep these globs lazy so
-// importing the root layout does not pull the full markdown corpus into every
-// page's initial module graph.
-const defaultDocLoaders = {
-  ...import.meta.glob("../../../core/docs/content/*.md", {
-    query: "?raw",
-    import: "default",
-  }),
-  ...import.meta.glob("../../../core/docs/content/*.mdx", {
-    query: "?raw",
-    import: "default",
-  }),
-};
-
-const localizedDocLoaders = {
-  ...import.meta.glob("../../../core/docs/content/locales/*/*.md", {
-    query: "?raw",
-    import: "default",
-  }),
-  ...import.meta.glob("../../../core/docs/content/locales/*/*.mdx", {
-    query: "?raw",
-    import: "default",
-  }),
-};
+// SEO only needs to know whether a source file exists, so this reads only the
+// KEYS of the shared map — the loaders are never called here.
+import {
+  docSourceLoaders as defaultDocLoaders,
+  localizedDocLoaders,
+} from "./docs-source-loaders";
 
 function sourceExists(
   sources: Record<string, unknown>,
diff --git a/packages/docs/app/components/docs-content.ts b/packages/docs/app/components/docs-content.ts
index c612e0c680..7faceeabbc 100644
--- a/packages/docs/app/components/docs-content.ts
+++ b/packages/docs/app/components/docs-content.ts
@@ -17,37 +17,9 @@ import {
   isDocsLocale,
   type DocsLocale,
 } from "./docs-locale";
+import { docSourceLoaders, localizedDocLoaders } from "./docs-source-loaders";
 import { slugifyHeading } from "./heading-slug";
 
-// Keep default docs route-lazy. Eagerly importing and parsing the whole corpus
-// makes every SSR cold start pay for documents unrelated to the requested page.
-// During the migration `.mdx` wins when both source files exist for a slug;
-// `.md` remains a fallback.
-const docSourceLoaders = {
-  ...import.meta.glob("../../../core/docs/content/*.md", {
-    query: "?raw",
-    import: "default",
-  }),
-  ...import.meta.glob("../../../core/docs/content/*.mdx", {
-    query: "?raw",
-    import: "default",
-  }),
-} as Record<string, () => Promise<string>>;
-
-// Optional locale-specific docs live under packages/core/docs/content/locales/.
-// Keep these lazy. Translated Markdown should load per locale + route, not all
-// at startup, so non-English docs do not bloat the initial docs bundle.
-const localizedDocLoaders = {
-  ...import.meta.glob("../../../core/docs/content/locales/*/*.md", {
-    query: "?raw",
-    import: "default",
-  }),
-  ...import.meta.glob("../../../core/docs/content/locales/*/*.mdx", {
-    query: "?raw",
-    import: "default",
-  }),
-} as Record<string, () => Promise<string>>;
-
 export interface DocEntry {
   slug: string;
   title: string;
diff --git a/packages/docs/app/components/docs-source-loaders.ts b/packages/docs/app/components/docs-source-loaders.ts
new file mode 100644
index 0000000000..2059b8e46d
--- /dev/null
+++ b/packages/docs/app/components/docs-source-loaders.ts
@@ -0,0 +1,37 @@
+/**
+ * The single glob map over the docs corpus.
+ *
+ * `docs-content` and `docs-availability` both need it, and declaring it twice
+ * made Rollup emit two byte-identical copies of the 1447-entry lazy-import map
+ * into the server bundle. One module, one map.
+ *
+ * Keep these loaders LAZY. Eagerly importing and parsing the whole corpus makes
+ * every SSR cold start pay for documents unrelated to the requested page, and
+ * pulls the full markdown corpus into the root layout's module graph.
+ */
+export const docSourceLoaders = {
+  ...import.meta.glob("../../../core/docs/content/*.md", {
+    query: "?raw",
+    import: "default",
+  }),
+  ...import.meta.glob("../../../core/docs/content/*.mdx", {
+    query: "?raw",
+    import: "default",
+  }),
+} as Record<string, () => Promise<string>>;
+
+/**
+ * Optional locale-specific docs under `packages/core/docs/content/locales/`.
+ * Lazy for the same reason: translated Markdown should load per locale + route,
+ * never all at startup.
+ */
+export const localizedDocLoaders = {
+  ...import.meta.glob("../../../core/docs/content/locales/*/*.md", {
+    query: "?raw",
+    import: "default",
+  }),
+  ...import.meta.glob("../../../core/docs/content/locales/*/*.mdx", {
+    query: "?raw",
+    import: "default",
+  }),
+} as Record<string, () => Promise<string>>;
diff --git a/packages/docs/package.json b/packages/docs/package.json
index 3bf2eab19f..fc9e0dd984 100644
--- a/packages/docs/package.json
+++ b/packages/docs/package.json
@@ -18,7 +18,7 @@
     "migrate:production": "tsx scripts/migrate-production.ts",
     "validate-doc-blocks": "vitest run app/components/docBlocks.validate.test.tsx",
     "prebuild": "tsx scripts/generate-source-index.ts && vitest run app/components/docBlocks.validate.test.tsx",
-    "build": "agent-native build",
+    "build": "agent-native build && tsx scripts/prune-locale-doc-chunks.ts",
     "start": "agent-native start",
     "typecheck": "agent-native typecheck",
     "test": "vitest run --passWithNoTests"
diff --git a/packages/docs/scripts/prune-locale-doc-chunks.ts b/packages/docs/scripts/prune-locale-doc-chunks.ts
new file mode 100644
index 0000000000..0bf8a47f5c
--- /dev/null
+++ b/packages/docs/scripts/prune-locale-doc-chunks.ts
@@ -0,0 +1,210 @@
+/**
+ * Drop translated docs markdown from the deployed serverless functions.
+ *
+ * `docs-content.ts` globs `core/docs/content/locales/<locale>/*.md{,x}` with
+ * `query: "?raw"`, so Vite emits one lazy chunk per translated file — 1251 of
+ * them, 19.2MB, roughly 40% of a 51MB docs function. Netlify's
+ * `nodeBundler: "none"` + `includedFiles: ["**"]` ships every one, and the
+ * function unzips all of it on each cold start.
+ *
+ * It can never serve them. Every localized docs page is prerendered to a static
+ * file at build time, so the CDN answers those URLs from the publish directory
+ * and the render function is never invoked for them. The globs stay: the chunk
+ * KEYS still drive `localizedDocKey` and the locale-availability enumeration,
+ * so hreflang and the locale switcher keep working with the target files gone.
+ *
+ * This runs after `agent-native build`, when the emitted functions are final.
+ * It deletes nothing it cannot prove is prerendered — see `assertPrerendered`.
+ */
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { DOCS_SLUG_REDIRECTS } from "../app/components/docs-slug-redirects.js";
+
+const DOCS_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const FUNCTIONS_DIR = path.join(DOCS_ROOT, ".netlify", "functions-internal");
+const PUBLISH_DIR = path.join(DOCS_ROOT, "dist");
+const LOCALES_DIR = path.resolve(DOCS_ROOT, "../core/docs/content/locales");
+
+/** `"../../../core/docs/content/locales/ar-SA/x.mdx":()=>import(`./x-HASH.mjs`)` */
+const GLOB_ENTRY =
+  /"([^"]*\/core\/docs\/content\/(?:locales\/[^/"]+\/)?[^"]+\.mdx?)"\s*:\s*\(\)\s*=>\s*import\(\s*[`"']\.\/([^`"']+)[`"']\s*\)/g;
+
+type Attribution = {
+  localeOnly: Set<string>;
+  keysByChunk: Map<string, string[]>;
+};
+
+/**
+ * Map each emitted chunk to the glob keys that reference it. A chunk is
+ * locale-only when every key that reaches it lives under `locales/`. Reading
+ * the emitted bundle rather than a manifest means this cannot drift from what
+ * the build actually produced.
+ */
+function attributeChunks(chunksDir: string): Attribution {
+  const keysByChunk = new Map<string, string[]>();
+  for (const name of readdirSync(chunksDir)) {
+    if (!name.endsWith(".mjs")) continue;
+    let source: string;
+    try {
+      source = readFileSync(path.join(chunksDir, name), "utf8");
+    } catch {
+      continue;
+    }
+    GLOB_ENTRY.lastIndex = 0;
+    for (let m: RegExpExecArray | null; (m = GLOB_ENTRY.exec(source)); ) {
+      const [, key, chunk] = m;
+      const list = keysByChunk.get(chunk) ?? [];
+      list.push(key);
+      keysByChunk.set(chunk, list);
+    }
+  }
+
+  const localeOnly = new Set<string>();
+  for (const [chunk, keys] of keysByChunk) {
+    if (keys.every((key) => key.includes("/locales/"))) localeOnly.add(chunk);
+  }
+  return { localeOnly, keysByChunk };
+}
+
+function slugFromKey(key: string): string {
+  return path.basename(key).replace(/\.mdx?$/, "");
+}
+
+function localeFromKey(key: string): string | undefined {
+  return /\/locales\/([^/]+)\//.exec(key)?.[1];
+}
+
+function isDraft(key: string): boolean {
+  // A draft is excluded from prerender, so the function is still its only
+  // renderer. `docs-content` loads the chunk before it decides visibility.
+  const absolute = path.resolve(
+    LOCALES_DIR,
+    "..",
+    key.replace(/^.*core\/docs\/content\//, ""),
+  );
+  try {
+    return /^---[\s\S]*?\bdraft:\s*["']?true/m.test(
+      readFileSync(absolute, "utf8"),
+    );
+  } catch {
+    // Unreadable source is not provably prerendered, so keep its chunk.
+    return true;
+  }
+}
+
+/**
+ * Refuse to delete a chunk whose page is not actually prerendered. A missing
+ * static page would turn a translated doc into a 500 the moment the function
+ * tried to load a chunk this script removed, so an unproven page aborts the
+ * build instead.
+ */
+function assertPrerendered(keys: string[]): string[] {
+  const missing: string[] = [];
+  for (const key of keys) {
+    const locale = localeFromKey(key);
+    const slug = slugFromKey(key);
+    if (!locale) continue;
+    const candidates =
+      slug === "getting-started"
+        ? [path.join(PUBLISH_DIR, locale, "docs", "index.html")]
+        : [path.join(PUBLISH_DIR, locale, "docs", slug, "index.html")];
+    if (!candidates.some((file) => existsSync(file)))
+      missing.push(`${locale}/${slug}`);
+  }
+  return missing;
+}
+
+function pruneFunction(functionDir: string): {
+  removed: number;
+  bytes: number;
+} {
+  const chunksDir = path.join(functionDir, "_chunks");
+  if (!existsSync(chunksDir)) return { removed: 0, bytes: 0 };
+
+  const { localeOnly, keysByChunk } = attributeChunks(chunksDir);
+  const redirectSlugs = new Set(Object.keys(DOCS_SLUG_REDIRECTS));
+
+  const prunable: string[] = [];
+  const provenKeys: string[] = [];
+  for (const chunk of localeOnly) {
+    const keys = keysByChunk.get(chunk) ?? [];
+    // A redirect slug never renders its own page, and a draft is not
+    // prerendered; both keep their chunk rather than gamble on the 301/500.
+    if (
+      keys.some((key) => redirectSlugs.has(slugFromKey(key)) || isDraft(key))
+    ) {
+      continue;
+    }
+    prunable.push(chunk);
+    provenKeys.push(...keys);
+  }
+
+  const missing = assertPrerendered(provenKeys);
+  if (missing.length > 0) {
+    throw new Error(
+      `prune-locale-doc-chunks: refusing to prune — ${missing.length} translated doc(s) have no prerendered page, ` +
+        `so the function is still their only renderer: ${missing.slice(0, 8).join(", ")}` +
+        (missing.length > 8 ? ` (+${missing.length - 8} more)` : ""),
+    );
+  }
+
+  let removed = 0;
+  let bytes = 0;
+  for (const chunk of prunable) {
+    const file = path.join(chunksDir, chunk);
+    try {
+      bytes += statSync(file).size;
+      rmSync(file);
+      removed += 1;
+      // A chunk already gone is the goal state, not a failure: the sibling
+      // function directory is hardlinked in some layouts, so the first prune
+      // removes it for both. The reported byte count stays honest because the
+      // size is read before the unlink.
+      // coercion-ok: absent and removed are the same outcome here.
+    } catch {}
+  }
+  return { removed, bytes };
+}
+
+function main(): void {
+  if (!existsSync(FUNCTIONS_DIR)) {
+    console.log("[docs] No emitted functions; skipping locale chunk prune.");
+    return;
+  }
+
+  let removed = 0;
+  let bytes = 0;
+  for (const entry of readdirSync(FUNCTIONS_DIR, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    // Netlify zips each function separately, so a chunk must be deleted from
+    // every emitted copy to actually leave the upload.
+    const result = pruneFunction(path.join(FUNCTIONS_DIR, entry.name));
+    removed += result.removed;
+    bytes += result.bytes;
+  }
+
+  console.log(
+    `[docs] Pruned ${removed} translated-doc chunk(s) (${(bytes / 1024 / 1024).toFixed(1)}MB) from the ` +
+      `serverless functions; every localized page is prerendered and served statically.`,
+  );
+}
+
+if (
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+) {
+  main();
+}
+
+export { attributeChunks, assertPrerendered, pruneFunction };
diff --git a/packages/docs/tests/prune-locale-doc-chunks.test.ts b/packages/docs/tests/prune-locale-doc-chunks.test.ts
new file mode 100644
index 0000000000..36f3475ad9
--- /dev/null
+++ b/packages/docs/tests/prune-locale-doc-chunks.test.ts
@@ -0,0 +1,91 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  assertPrerendered,
+  attributeChunks,
+} from "../scripts/prune-locale-doc-chunks";
+
+/**
+ * The pruner deletes real files out of a deployed function, so the two things
+ * worth pinning are the ones whose failure is silent: attributing a chunk to
+ * the wrong side (deleting an English page's content) and deleting a page that
+ * was never prerendered (a 500 on a translated doc).
+ */
+describe("prune-locale-doc-chunks", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(os.tmpdir(), "prune-locale-"));
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  function writeChunk(name: string, entries: Array<[string, string]>): void {
+    const body = entries
+      .map(([key, chunk]) => `"${key}":()=>import(\`./${chunk}\`)`)
+      .join(",");
+    writeFileSync(path.join(dir, name), `const m={${body}};export default m;`);
+  }
+
+  it("treats a chunk reached only by locale keys as locale-only", () => {
+    writeChunk("docs-content.mjs", [
+      [
+        "../../../core/docs/content/locales/de-DE/actions.mdx",
+        "actions-DE.mjs",
+      ],
+      ["../../../core/docs/content/actions.mdx", "actions-EN.mjs"],
+    ]);
+
+    const { localeOnly } = attributeChunks(dir);
+
+    expect(localeOnly.has("actions-DE.mjs")).toBe(true);
+    expect(localeOnly.has("actions-EN.mjs")).toBe(false);
+  });
+
+  it("keeps a chunk shared by an English key, even if a locale key also reaches it", () => {
+    // Deleting this would strip content the function genuinely still renders.
+    writeChunk("docs-content.mjs", [
+      ["../../../core/docs/content/locales/ja-JP/shared.mdx", "shared.mjs"],
+      ["../../../core/docs/content/shared.mdx", "shared.mjs"],
+    ]);
+
+    const { localeOnly } = attributeChunks(dir);
+
+    expect(localeOnly.has("shared.mjs")).toBe(false);
+  });
+
+  it("reports a translated doc with no prerendered page instead of pruning it", () => {
+    const missing = assertPrerendered([
+      "../../../core/docs/content/locales/fr-FR/never-prerendered.mdx",
+    ]);
+
+    expect(missing).toEqual(["fr-FR/never-prerendered"]);
+  });
+
+  it("accepts a translated doc whose prerendered page exists", () => {
+    const publish = path.resolve(
+      path.dirname(new URL(import.meta.url).pathname),
+      "..",
+      "dist",
+    );
+    mkdirSync(path.join(publish, "de-DE", "docs", "actions-overview"), {
+      recursive: true,
+    });
+    writeFileSync(
+      path.join(publish, "de-DE", "docs", "actions-overview", "index.html"),
+      "<html></html>",
+    );
+
+    const missing = assertPrerendered([
+      "../../../core/docs/content/locales/de-DE/actions-overview.mdx",
+    ]);
+
+    expect(missing).toEqual([]);
+  });
+});
diff --git a/packages/docs/vite.config.ts b/packages/docs/vite.config.ts
index f989c065c6..f056952bdc 100644
--- a/packages/docs/vite.config.ts
+++ b/packages/docs/vite.config.ts
@@ -30,11 +30,40 @@ export default defineConfig({
       // 62.8MB -> 55.9MB, and the deploy uploads two copies of it, so 125.6MB
       // -> 111.8MB. Excalidraw does not resolve from this package directly; it
       // arrives through @agent-native/core, which is why naming it still works.
+      // The editor stack and terminal are client-only here: docs never
+      // server-renders the agent sidebar or the resource editor, but their leaf
+      // code still landed in the SSR bundle. lowlight stays real (core's doc
+      // block highlighter runs server-side via preloadDocBlocksContent), and so
+      // do yjs/y-protocols/lib0 (core collab uses yjs on the server).
       ssrStubs: [
         "shiki",
         "mermaid",
         "@excalidraw/excalidraw",
         "@excalidraw/mermaid-to-excalidraw",
+        "@assistant-ui/react",
+        "@tiptap/core",
+        "@tiptap/react",
+        "@tiptap/pm",
+        "@tiptap/starter-kit",
+        "@tiptap/extension-blockquote",
+        "@tiptap/extension-code",
+        "@tiptap/extension-code-block-lowlight",
+        "@tiptap/extension-collaboration",
+        "@tiptap/extension-collaboration-caret",
+        "@tiptap/extension-color",
+        "@tiptap/extension-image",
+        "@tiptap/extension-link",
+        "@tiptap/extension-placeholder",
+        "@tiptap/extension-table",
+        "@tiptap/extension-table-cell",
+        "@tiptap/extension-table-header",
+        "@tiptap/extension-table-row",
+        "@tiptap/extension-task-item",
+        "@tiptap/extension-task-list",
+        "@tiptap/extension-text-style",
+        "@tiptap/y-tiptap",
+        "tiptap-markdown",
+        "prosemirror-markdown",
       ],
       // Warm routes as they enter the real viewport. Render-warming the whole
       // docs graph stampedes uncached SSR/function calls after every mount.
diff --git a/templates/clips/app/routes/access-request.approve.tsx b/templates/clips/app/routes/access-request.approve.tsx
index ba0b9e8af5..9365bc7555 100644
--- a/templates/clips/app/routes/access-request.approve.tsx
+++ b/templates/clips/app/routes/access-request.approve.tsx
@@ -43,16 +43,23 @@ export default function ApproveRecordingAccessRequestRoute() {
   const approvalTokenFromUrl = searchParams.get("token") ?? "";
   const approvalTokenStorageKey =
     recordingAccessApprovalSessionKey(recordingId);
-  const [approvalToken, setApprovalToken] = useState(() => {
-    if (approvalTokenFromUrl) return approvalTokenFromUrl;
-    if (typeof window === "undefined" || !recordingId) return "";
+  // Only the URL token is knowable on the server, so reading storage in the
+  // initializer makes the first client render disagree with the server's and
+  // React re-renders the page from scratch. Adopt the stored token after mount.
+  const [approvalToken, setApprovalToken] = useState(
+    () => approvalTokenFromUrl ?? "",
+  );
+
+  useEffect(() => {
+    if (approvalTokenFromUrl || !recordingId) return;
     try {
-      return sessionStorage.getItem(approvalTokenStorageKey) ?? "";
-    } catch {
-      // coercion-ok: unavailable tab storage is an absent continuation.
-      return "";
-    }
-  });
+      const stored = sessionStorage.getItem(approvalTokenStorageKey);
+      if (stored) setApprovalToken(stored);
+      // Unavailable tab storage is an absent continuation: the page then asks
+      // for the token rather than silently continuing without one.
+      // coercion-ok: the absent case is visible to the user, not swallowed.
+    } catch {}
+  }, [approvalTokenFromUrl, recordingId, approvalTokenStorageKey]);
   const [state, setState] = useState<ApprovalState>({ kind: "loading" });
 
   useEffect(() => {
diff --git a/templates/clips/app/routes/embed.$shareId.tsx b/templates/clips/app/routes/embed.$shareId.tsx
index 22192f3a07..93796989e5 100644
--- a/templates/clips/app/routes/embed.$shareId.tsx
+++ b/templates/clips/app/routes/embed.$shareId.tsx
@@ -71,14 +71,24 @@ export default function EmbedRoute() {
     [searchParams],
   );
 
-  const [password, setPassword] = useState<string | null>(() => {
-    if (typeof window === "undefined" || !shareId) return null;
+  // Same hydration trap the share route had: reading sessionStorage in the
+  // initializer makes the first client render disagree with the server's,
+  // which has no storage and always renders the locked state. React discards
+  // the hydrated tree and re-renders from scratch, so an embedded player goes
+  // blank for a returning viewer. Start where the server started and adopt the
+  // stored password after mount.
+  const [password, setPassword] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!shareId) return;
     try {
-      return sessionStorage.getItem(STORAGE_KEY_PREFIX + shareId);
-    } catch {
-      return null;
-    }
-  });
+      const stored = sessionStorage.getItem(STORAGE_KEY_PREFIX + shareId);
+      if (stored) setPassword(stored);
+      // Unreadable storage and no stored password are the same state here:
+      // both leave `password` null, which renders the password prompt.
+      // coercion-ok: the fallback is visible to the viewer, not swallowed.
+    } catch {}
+  }, [shareId]);
   const [pwError, setPwError] = useState<string | null>(null);
   const readyMediaPollRef = useRef<{ key: string; until: number } | null>(null);
 
diff --git a/templates/slides/app/routes/access-request.approve.tsx b/templates/slides/app/routes/access-request.approve.tsx
index 8fe22324b8..717f8cd110 100644
--- a/templates/slides/app/routes/access-request.approve.tsx
+++ b/templates/slides/app/routes/access-request.approve.tsx
@@ -42,16 +42,23 @@ export default function ApproveDeckAccessRequestRoute() {
   const deckId = searchParams.get("deckId") ?? "";
   const approvalTokenFromUrl = searchParams.get("token") ?? "";
   const approvalTokenStorageKey = deckAccessApprovalSessionKey(deckId);
-  const [approvalToken, setApprovalToken] = useState(() => {
-    if (approvalTokenFromUrl) return approvalTokenFromUrl;
-    if (typeof window === "undefined" || !deckId) return "";
+  // Only the URL token is knowable on the server, so reading storage in the
+  // initializer makes the first client render disagree with the server's and
+  // React re-renders the page from scratch. Adopt the stored token after mount.
+  const [approvalToken, setApprovalToken] = useState(
+    () => approvalTokenFromUrl ?? "",
+  );
+
+  useEffect(() => {
+    if (approvalTokenFromUrl || !deckId) return;
     try {
-      return sessionStorage.getItem(approvalTokenStorageKey) ?? "";
-    } catch {
-      // coercion-ok: unavailable tab storage is an absent continuation.
-      return "";
-    }
-  });
+      const stored = sessionStorage.getItem(approvalTokenStorageKey);
+      if (stored) setApprovalToken(stored);
+      // Unavailable tab storage is an absent continuation: the page then asks
+      // for the token rather than silently continuing without one.
+      // coercion-ok: the absent case is visible to the user, not swallowed.
+    } catch {}
+  }, [approvalTokenFromUrl, deckId, approvalTokenStorageKey]);
   const [state, setState] = useState<ApprovalState>({ kind: "loading" });
 
   useEffect(() => {
diff --git a/templates/slides/server/lib/slide-content-patch.ts b/templates/slides/server/lib/slide-content-patch.ts
index 589717c940..11e9920f52 100644
--- a/templates/slides/server/lib/slide-content-patch.ts
+++ b/templates/slides/server/lib/slide-content-patch.ts
@@ -86,10 +86,21 @@ export async function applySlideContentEdits(
 
 export async function formatSlideHtml(content: string): Promise<string> {
   try {
-    const prettier = await import("prettier");
-    return await prettier.format(content, {
+    // prettier's main entry `import()`s all 13 parser plugins, so a bundler
+    // inlines ~3.5MB of flow/typescript/yaml/markdown parsers just to format
+    // HTML. Load the standalone core plus only the plugins the HTML printer
+    // reaches, which still formats embedded <style> and <script>.
+    const [{ format }, ...plugins] = await Promise.all([
+      import("prettier/standalone"),
+      import("prettier/plugins/html"),
+      import("prettier/plugins/postcss"),
+      import("prettier/plugins/babel"),
+      import("prettier/plugins/estree"),
+    ]);
+    return await format(content, {
       parser: "html",
       htmlWhitespaceSensitivity: "ignore",
+      plugins,
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);