diff --git a/alias.ts b/alias.ts
index 3e8986693..8a5893640 100644
--- a/alias.ts
+++ b/alias.ts
@@ -48,6 +48,7 @@ export const alias = {
   'devframe/adapters/embedded': r('devframe/src/adapters/embedded.ts'),
   'devframe/initiate': r('devframe/src/adapters/initiate.ts'),
   'devframe/adapters/mcp': r('devframe/src/adapters/mcp/index.ts'),
+  '@devframes/hub/build': r('hub/src/node/build.ts'),
   '@devframes/hub/client': r('hub/src/client/index.ts'),
   '@devframes/hub/constants': r('hub/src/constants.ts'),
   '@devframes/hub/initiate': r('hub/src/node/initiate.ts'),
diff --git a/docs/content/1.guide/18.hub-initiate.md b/docs/content/1.guide/18.hub-initiate.md
index 06ba2debb..843e242b0 100644
--- a/docs/content/1.guide/18.hub-initiate.md
+++ b/docs/content/1.guide/18.hub-initiate.md
@@ -99,6 +99,24 @@ A devframe's SPA and RPC client are byte-identical in both cases; only the envir
 | MCP | `<base>__mcp`, this devframe's tools | the hub-level aggregate |
 | Isolation | hard (own context, own transport) | cooperative (shared context) |
 
+## Static builds
+
+`buildHub()` from `@devframes/hub/build` is the hub counterpart of the [build adapter](/adapters/build): it bakes the whole hub into a directory any static file server can serve. Each devframe's SPA is copied to `<outDir>/<id>/` (absolute-path page scripts alongside at `<id>/__page-script/`), the UI slot's viewer and `embedded.js` next to them, and `__connection.json` (`backend: 'static'`) plus a shared [RPC dump](/adapters/build) at the hub base, with a snapshot of every shared-state key (docks, commands, renderer manifest) baked in - so `createDevframeClientRuntime()` and every panel boot from the dump with no live server.
+
+```ts
+import { buildHub } from '@devframes/hub/build'
+
+await buildHub({
+  outDir: 'dist/__devframes', // corresponds to `base` at serve time
+  devframes: [createA11yDevframe(), createMessagesDevframe()],
+  ui: createUi(),
+})
+```
+
+Browser-side tools keep working in full: a page script still loads into the host page and talks to its panel over the [in-page channel](/guide/in-page-channel) (the a11y inspector scans a production app exactly as it does in dev). Reads resolve from the baked dump (`static`/`snapshot` RPCs, shared-state snapshots); live writes (messages, command execution) have no server, so the browser clients degrade to local no-ops, and a panel's dock-activation deep links ride a same-origin `BroadcastChannel` instead of the RPC relay.
+
+A devframe whose value is inherently live declares `capabilities.build: false` and silently stays out of the build entirely - no dock, no SPA copy, no RPCs in the dump. The built-in terminals, code-server, and assets devframes declare it, so a hub mounting every built-in bakes only the tools that mean something statically. See the [buildHub options](/references/hub-api#buildhub-options) reference, and [`examples/a11y-messages-playground`](https://github.com/devframes/devframe/tree/main/examples/a11y-messages-playground) for a Vite host whose `vite build` output ships the hub.
+
 ## Bring your own context
 
 Host frameworks that assemble `createHubContext` + `ctx.install` themselves pass the context instead of a `devframes` list:
diff --git a/docs/content/2.adapters/4.build.md b/docs/content/2.adapters/4.build.md
index dd7def6e1..84e6e7365 100644
--- a/docs/content/2.adapters/4.build.md
+++ b/docs/content/2.adapters/4.build.md
@@ -28,3 +28,5 @@ await createBuild(myDevframe, {
 | `pretty` | `false` | Pretty-print dump JSON. |
 
 The RPC client runs read-only. For a custom URL base, build with relative asset paths (`vite.base: './'`).
+
+`buildHub()` from `@devframes/hub/build` produces the same kind of deploy for a whole hub: [Static builds](/guide/hub-initiate#static-builds).
diff --git a/docs/content/3.frameworks/1.vite.md b/docs/content/3.frameworks/1.vite.md
index ad9a564e7..4f770e5a8 100644
--- a/docs/content/3.frameworks/1.vite.md
+++ b/docs/content/3.frameworks/1.vite.md
@@ -63,3 +63,5 @@ export default defineConfig({
 ```
 
 Pass `ui` to swap the hub UI provider, `ui: false` for headless (via `@devframes/vite/hub/client`'s `mountDevframeHubClient()`). Vite DevTools (`@vitejs/devtools-kit`) supports this natively; recommended once (`{ quiet: true }` to silence).
+
+`build: true` also bakes the hub into `vite build` output: [`buildHub`](/guide/hub-initiate#static-builds) writes the static hub subtree into `<outDir><base>` and the UI's `embedded.js` tag is injected into the built HTML, so the deployed app ships working devtools against a `static` backend (baked reads, no live server).
diff --git a/docs/content/6.errors/DF8005.md b/docs/content/6.errors/DF8005.md
index 31685d678..67067d357 100644
--- a/docs/content/6.errors/DF8005.md
+++ b/docs/content/6.errors/DF8005.md
@@ -30,4 +30,4 @@ initHub({
 
 ## Source
 
-- [`packages/hub/src/node/initiate.ts`](https://github.com/devframes/devframe/blob/main/packages/hub/src/node/initiate.ts): `initHub()` emits this while mounting each devframe when the hub turned MCP off but the devframe requests one.
+- [`packages/hub/src/node/assemble.ts`](https://github.com/devframes/devframe/blob/main/packages/hub/src/node/assemble.ts): `mountDevframes()` emits this while mounting each devframe when the hub turned MCP off but the devframe requests one.
diff --git a/docs/content/6.errors/DF8006.md b/docs/content/6.errors/DF8006.md
new file mode 100644
index 000000000..2b964be16
--- /dev/null
+++ b/docs/content/6.errors/DF8006.md
@@ -0,0 +1,33 @@
+---
+title: 'DF8006: Static Build Mount Escapes the Hub Base'
+description: 'A static hub build can only write mounts under its own base: "{urlBase}" escapes "{base}".'
+---
+
+## Message
+
+> A static hub build can only write mounts under its own base: "`{urlBase}`" escapes "`{base}`"
+
+## Cause
+
+`buildHub` maps every mounted URL base to a directory under its `outDir` (which corresponds to the hub `base` at serve time), so a mount whose base lies outside the hub base has no on-disk location in the output. This happens when a devframe is installed with an explicit base outside the hub base, e.g. `ctx.install(devframe, { base: '/elsewhere/' })` from `configure`.
+
+## Example
+
+```ts
+await buildHub({
+  outDir: 'dist/__devframes',
+  async configure(ctx) {
+    // ✗ Bad: `/tools/x/` is not under the `/__devframes/` hub base
+    await ctx.install(myDevframe, { base: '/tools/x/' })
+  },
+})
+```
+
+## Fix
+
+- Drop the `base` override so the devframe mounts at `<hub base><id>/`, or point it somewhere under the hub base.
+- Or move the hub `base` up (e.g. `base: '/'`) so it contains every mount.
+
+## Source
+
+- [`packages/hub/src/node/build.ts`](https://github.com/devframes/devframe/blob/main/packages/hub/src/node/build.ts): `buildHub()`'s mount-to-disk mapping throws this for any mount base outside the hub base.
diff --git a/docs/content/8.references/3.events.md b/docs/content/8.references/3.events.md
index 17da5c9e3..96fb817f8 100644
--- a/docs/content/8.references/3.events.md
+++ b/docs/content/8.references/3.events.md
@@ -66,6 +66,14 @@ A hub-aware RPC client reads or subscribes via `rpc.client.register(...)`; the [
 | `devframe:user-settings` | shared state | Persisted project-scope hub settings (`DevframeDocksUserSettings`). |
 | `devframe:terminals` | streaming channel | Live terminal output stream, keyed by session id. |
 
+### Same-origin `BroadcastChannel`s
+
+Used on a `static` backend, where no live server can relay a client's request to its sibling browsing contexts.
+
+| Name | Posted by | Carries |
+|---|---|---|
+| `devframe:docks:activate` | a panel iframe (e.g. the messages panel's activate actions) | The `{ dockId, params? }` activation; the client runtime in the host page switches the dock locally. |
+
 ## Core devframe events
 
 This map covers notifications only; request/response RPC endpoints (`devframe:rpc:server-state:*`, `devframe:streaming:subscribe`, `anonymous:devframe:auth`, …) are typed in `types/rpc-augments.ts`, not events.
diff --git a/docs/content/8.references/6.hub-api.md b/docs/content/8.references/6.hub-api.md
index 418676578..b5b3cfb33 100644
--- a/docs/content/8.references/6.hub-api.md
+++ b/docs/content/8.references/6.hub-api.md
@@ -84,6 +84,16 @@ What `initHub()` serves under its `base`: [The namespace](/guide/hub-initiate#th
 | `__client-imports.js` | dock client-script import map for hub UI providers |
 | `__mcp` | aggregate MCP endpoint over the tool registry (`mcp: 'auto'` default: mounted once agent tools exist) |
 
+## `buildHub` options
+
+The options of `buildHub()` from `@devframes/hub/build`: [Static builds](/guide/hub-initiate#static-builds). `devframes`, `services`, `rpcDeclarations`, `configure`, `ui`, `renderers`, `name`, `version`, `cwd`, and `getStorageDir` carry the same contracts as their `initHub` counterparts.
+
+| Option | Purpose |
+|---|---|
+| `outDir` | Output directory for the hub subtree; corresponds to `base` at serve time (build `base: '/__devframes/'` into `dist/__devframes`). |
+| `base` | Mount base baked into every absolute URL the build emits. Default `/__devframes/`. |
+| `pretty` | Pretty-print RPC dump JSON shards. Default `false` (minified). |
+
 ## Client runtime options
 
 The options of `createDevframeClientRuntime()`: [The client runtime](/guide/client-context#the-client-runtime).
diff --git a/examples/a11y-messages-playground/README.md b/examples/a11y-messages-playground/README.md
index acab15ef5..054aab92f 100644
--- a/examples/a11y-messages-playground/README.md
+++ b/examples/a11y-messages-playground/README.md
@@ -21,6 +21,22 @@ The `dev` script builds the workspace first (the a11y page-script bundle and bot
 devframe SPAs must exist), then starts Vite bound to `0.0.0.0`. Open the printed
 URL.
 
+## Production build
+
+```sh
+pnpm --filter a11y-messages-playground build    # vite build + buildHub -> dist/
+pnpm --filter a11y-messages-playground preview  # serve dist/ statically
+```
+
+`vite build` bakes the whole hub into `dist/__hub/` via `buildHub()` from
+`@devframes/hub/build`: both devframe SPAs, the a11y page-script bundle, a
+`backend: 'static'` connection meta, and the RPC dump (shared-state snapshots,
+the a11y config, the baked messages feed). Served from any static file server,
+the production page boots the client runtime against the static backend - the
+a11y inspector scans the built app over the in-page channel exactly as in dev,
+and the baked message's **Open a11y inspector** action still switches docks
+(riding a same-origin `BroadcastChannel` instead of the RPC relay).
+
 ## What you'll see
 
 The window is split in two:
diff --git a/examples/a11y-messages-playground/package.json b/examples/a11y-messages-playground/package.json
index ef1366587..9a36c1435 100644
--- a/examples/a11y-messages-playground/package.json
+++ b/examples/a11y-messages-playground/package.json
@@ -8,6 +8,7 @@
   "scripts": {
     "dev": "pnpm -C ../.. run build && vite --host",
     "build": "vite build",
+    "preview": "vite preview --host",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
diff --git a/examples/a11y-messages-playground/src/a11y-messages-playground.ts b/examples/a11y-messages-playground/src/a11y-messages-playground.ts
index ae427ad79..8a0e3492c 100644
--- a/examples/a11y-messages-playground/src/a11y-messages-playground.ts
+++ b/examples/a11y-messages-playground/src/a11y-messages-playground.ts
@@ -1,10 +1,11 @@
 import type { HubInstance } from '@devframes/hub/initiate'
-import type { DevframeDefinition } from 'devframe'
+import type { DevframeDefinition, DevframeStorageScope } from 'devframe'
 import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite'
 import { Server as NodeHttpServer } from 'node:http'
 import { homedir } from 'node:os'
+import { buildHub } from '@devframes/hub/build'
 import { initHub } from '@devframes/hub/initiate'
-import { join } from 'pathe'
+import { join, resolve } from 'pathe'
 
 export interface A11yMessagesPlaygroundOptions {
   /** Mount base the hub answers under. Default: `/__hub/`. */
@@ -28,9 +29,16 @@ export function a11yMessagesPlayground(options: A11yMessagesPlaygroundOptions =
   let viteConfig: ResolvedConfig | undefined
   let hub: HubInstance | undefined
 
+  const storageDirs = (cwd: string) => (scope: DevframeStorageScope): string => {
+    if (scope === 'workspace')
+      return join(cwd, '.devframe')
+    if (scope === 'project')
+      return join(cwd, 'node_modules/.a11y-messages-playground')
+    return join(homedir(), '.a11y-messages-playground')
+  }
+
   return {
     name: 'a11y-messages-playground',
-    apply: 'serve',
 
     configResolved(config) {
       viteConfig = config
@@ -55,13 +63,7 @@ export function a11yMessagesPlayground(options: A11yMessagesPlaygroundOptions =
         auth: false,
         ...(options.port == null && httpServer ? { server: httpServer } : {}),
         ...(ws ? { ws } : {}),
-        getStorageDir(scope) {
-          if (scope === 'workspace')
-            return join(cwd, '.devframe')
-          if (scope === 'project')
-            return join(cwd, 'node_modules/.a11y-messages-playground')
-          return join(homedir(), '.a11y-messages-playground')
-        },
+        getStorageDir: storageDirs(cwd),
         devframes: options.devframes ?? [],
         /**
          * List the playground alongside standalone devframes in discovery
@@ -84,6 +86,38 @@ export function a11yMessagesPlayground(options: A11yMessagesPlaygroundOptions =
     async closeBundle() {
       await hub?.close().catch(() => {})
       hub = undefined
+
+      // Production build: bake the whole hub statically into the app's dist
+      // (`<outDir><base>`), so the built page works from any static file
+      // server - the a11y page script still loads, its in-page channel still
+      // scans, and the panels boot from the baked RPC dump.
+      if (viteConfig?.command !== 'build')
+        return
+      const cwd = viteConfig.root
+      await buildHub({
+        base,
+        cwd,
+        outDir: join(resolve(cwd, viteConfig.build.outDir), base.slice(1)),
+        getStorageDir: storageDirs(cwd),
+        devframes: options.devframes ?? [],
+        async configure(ctx) {
+          // Bake one demo entry into the static feed snapshot; its activate
+          // action exercises the message → dock navigation, which rides a
+          // same-origin BroadcastChannel on the static backend.
+          await ctx.messages.add({
+            message: 'Static hub build',
+            description: 'This feed is a build-time snapshot; live entries need the dev server.',
+            level: 'info',
+            category: 'hub',
+            actions: [{
+              id: 'open-a11y',
+              label: 'Open a11y inspector',
+              kind: 'activate',
+              activate: { dockId: 'devframes_plugin_a11y' },
+            }],
+          })
+        },
+      })
     },
   }
 }
diff --git a/examples/hub-vite-minimal/README.md b/examples/hub-vite-minimal/README.md
index 4419e1aa2..001475d95 100644
--- a/examples/hub-vite-minimal/README.md
+++ b/examples/hub-vite-minimal/README.md
@@ -18,3 +18,12 @@ Open the printed URL - the host page carries the floating dock via one injected
 - `transformIndexHtml` injects `<script type="module" src="/__devframes/embedded.js">` into the host page, so the floating dock mounts itself.
 
 The same `initHub` instance mounts identically on Nitro, Hono, Next.js, and Rsbuild - see the sibling `hub-*-minimal` examples.
+
+## Production build
+
+```sh
+pnpm --filter hub-vite-minimal build    # vite build + the baked hub -> dist/
+pnpm --filter hub-vite-minimal preview  # serve dist/ statically
+```
+
+`build: true` on `viteDevframeHub` bakes the hub into `dist/__devframes/` and injects the `embedded.js` tag into the built HTML, so the production bundle ships the docks against a `static` backend: the floating dock and standalone viewer boot from the baked RPC dump (each panel's snapshot reads, e.g. the Open Graph report of `defaultUrl`). Inherently-live tools (terminals, code-server, assets) declare `capabilities.build: false` and stay out of the static output entirely.
diff --git a/examples/hub-vite-minimal/package.json b/examples/hub-vite-minimal/package.json
index 0d252d524..0f377ef4a 100644
--- a/examples/hub-vite-minimal/package.json
+++ b/examples/hub-vite-minimal/package.json
@@ -7,6 +7,8 @@
   "homepage": "https://github.com/devframes/devframe/tree/main/examples/hub-vite-minimal",
   "scripts": {
     "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview --host",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
diff --git a/examples/hub-vite-minimal/vite.config.ts b/examples/hub-vite-minimal/vite.config.ts
index 65487f43a..0e524826c 100644
--- a/examples/hub-vite-minimal/vite.config.ts
+++ b/examples/hub-vite-minimal/vite.config.ts
@@ -26,7 +26,9 @@ const builtinDevframes = [
   createDataInspectorDevframe({ id: 'devframes_plugin_data-inspector' }),
   createA11yDevframe(),
   createMessagesDevframe(),
-  createOgDevframe(),
+  // `defaultUrl` doubles as the snapshot the static build bakes for the OG
+  // panel (its dump fetches the page at build time).
+  createOgDevframe({ defaultUrl: 'https://vite.dev' }),
   createAssetsDevframe({ watch: false }),
 ]
 
@@ -69,6 +71,13 @@ export default defineConfig({
   plugins: [
     viteDevframeHub({
       quiet: true,
+      /**
+       * Bake the hub into `vite build` output too (`dist/__devframes/`), so
+       * the production bundle ships the same docks against a `static`
+       * backend: baked reads (each panel's snapshot RPCs), no live server.
+       * Preview with `pnpm build && pnpm preview`.
+       */
+      build: true,
       devframes: builtinDevframes,
       /**
        * Rebrand the reference UI to Vite's own purple in one field, no CSS:
diff --git a/knip.jsonc b/knip.jsonc
index 2a4b420d1..e7939d4e1 100644
--- a/knip.jsonc
+++ b/knip.jsonc
@@ -152,7 +152,7 @@
       ]
     },
     "packages/hub": {
-      "entry": ["src/{index,constants}.ts", "src/{client,node,types}/index.ts", "src/node/{index,initiate}.ts"]
+      "entry": ["src/{index,constants}.ts", "src/{client,node,types}/index.ts", "src/node/{index,initiate,build}.ts"]
     },
     "packages/hub-ui": {
       // `playground/client-scripts/*.ts` are dock `action` entries the
diff --git a/packages/devframe/src/adapters/build.ts b/packages/devframe/src/adapters/build.ts
index d22cca376..c5128643c 100644
--- a/packages/devframe/src/adapters/build.ts
+++ b/packages/devframe/src/adapters/build.ts
@@ -7,19 +7,17 @@ import fs from 'node:fs/promises'
 import process from 'node:process'
 import { colors as c } from 'devframe/utils/colors'
 import { resolveStaticAssetsSource } from 'devframe/utils/remote-assets'
-import { structuredCloneStringify } from 'devframe/utils/structured-clone'
-import { dirname, resolve } from 'pathe'
+import { resolve } from 'pathe'
 import { resolveClientAssets } from '../client-assets'
 import {
   DEVFRAME_CONNECTION_META_FILENAME,
-  DEVFRAME_RPC_DUMP_DIRNAME,
   DEVFRAME_RPC_DUMP_MANIFEST_FILENAME,
 } from '../constants'
 import { createHostContext } from '../node/context'
 import { diagnostics } from '../node/diagnostics'
 import { createH3DevframeHost } from '../node/host-h3'
 import { collectStaticRpcDump } from '../rpc/dump/static'
-import { strictJsonStringify } from '../rpc/serialization'
+import { writeStaticRpcDump } from '../rpc/dump/write'
 
 export interface CreateBuildOptions {
   /** Output directory. Defaults to `dist-static`. */
@@ -95,18 +93,11 @@ export async function createBuild(d: DevframeDefinition, options: CreateBuildOpt
   // registered definitions, since the service itself defines none.
   applySnapshotRpc(ctx, d.rpc?.snapshot)
 
-  await fs.mkdir(resolve(outDir, DEVFRAME_RPC_DUMP_DIRNAME), { recursive: true })
-
   await writeConnectionMeta(ctx, outDir)
 
   console.log(c.cyan`[devframe] writing RPC dump to ${resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME)}`)
   const dump = await collectStaticRpcDump(ctx.rpc.definitions.values(), ctx)
-  await writeDumpFiles(dump, outDir, options.pretty ? 2 : undefined)
-  await fs.writeFile(
-    resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME),
-    JSON.stringify(dump.manifest, null, 2),
-    'utf-8',
-  )
+  await writeStaticRpcDump(dump, outDir, { pretty: options.pretty })
 
   console.log(c.green`[devframe] built "${d.id}" -> ${outDir}`)
 }
@@ -136,29 +127,6 @@ async function writeConnectionMeta(ctx: DevframeNodeContext, outDir: string): Pr
   )
 }
 
-/** Encode and write each sharded RPC dump file under `outDir`. */
-async function writeDumpFiles(
-  dump: Awaited<ReturnType<typeof collectStaticRpcDump>>,
-  outDir: string,
-  indent: number | undefined,
-): Promise<void> {
-  for (const [filepath, file] of Object.entries(dump.files)) {
-    const fullpath = resolve(outDir, filepath)
-    await fs.mkdir(dirname(fullpath), { recursive: true })
-    const text = file.serialization === 'structured-clone'
-      ? structuredCloneStringify(file.data)
-      : strictJsonStringify(file.data, file.fnName)
-    await fs.writeFile(
-      fullpath,
-      // structured-clone-es output is single-line; only JSON honors `indent`.
-      file.serialization === 'json' && indent != null
-        ? JSON.stringify(JSON.parse(text), null, indent)
-        : text,
-      'utf-8',
-    )
-  }
-}
-
 /**
  * Attach a `dump` to each {@link DevframeRpcOptions.snapshot} target so the
  * static collector bakes it, even though the (service-owned) definition
diff --git a/packages/devframe/src/client/connection.ts b/packages/devframe/src/client/connection.ts
index bb7bf1f0c..19bca4e8b 100644
--- a/packages/devframe/src/client/connection.ts
+++ b/packages/devframe/src/client/connection.ts
@@ -168,9 +168,17 @@ export async function setupDevframeConnection(
         throw new Error(`Failed to fetch connection meta from ${metaUrl}: ${response.status}`)
 
       const connectionMeta = await response.json() as ConnectionMeta
+      const loadedFrom = response.url || metaUrl
       const connection: DevframeConnection = {
         connectionMeta,
-        metaBaseUrl: response.url || metaUrl,
+        /**
+         * A served `baseUrl` re-points relative resolution (RPC dump shards,
+         * transport paths) at the meta that owns them: a static hub build's
+         * per-frame meta directs each frame SPA at the hub's own dump.
+         */
+        metaBaseUrl: connectionMeta.baseUrl
+          ? new URL(connectionMeta.baseUrl, loadedFrom).href
+          : loadedFrom,
         authToken: readStoredAuthToken(
           options.authToken ?? connectionMeta.authToken,
         ),
diff --git a/packages/devframe/src/node/rpc-shared-state.ts b/packages/devframe/src/node/rpc-shared-state.ts
index 1720bd338..72857f70b 100644
--- a/packages/devframe/src/node/rpc-shared-state.ts
+++ b/packages/devframe/src/node/rpc-shared-state.ts
@@ -113,10 +113,13 @@ export function createRpcSharedStateServerHost(
     },
     /**
      * Pre-compute snapshots for the build-mode static dump so the SPA
-     * can read them without a live server.
+     * can read them without a live server. The `undefined` fallback makes
+     * a key the build never created resolve like the live handler does
+     * (returning `undefined`) instead of failing the dump lookup.
      */
     dump: () => ({
       inputs: host.keys().map(key => [key] as [string]),
+      fallback: undefined,
     }),
   })
 
diff --git a/packages/devframe/src/rpc/dump/index.ts b/packages/devframe/src/rpc/dump/index.ts
index c6c377cfc..49c738b37 100644
--- a/packages/devframe/src/rpc/dump/index.ts
+++ b/packages/devframe/src/rpc/dump/index.ts
@@ -1,3 +1,4 @@
 export * from './collect'
 export * from './error'
 export * from './static'
+export * from './write'
diff --git a/packages/devframe/src/rpc/dump/write.ts b/packages/devframe/src/rpc/dump/write.ts
new file mode 100644
index 000000000..c24cc8246
--- /dev/null
+++ b/packages/devframe/src/rpc/dump/write.ts
@@ -0,0 +1,49 @@
+import type { StaticRpcDumpCollection } from './static'
+import fs from 'node:fs/promises'
+import { DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME } from 'devframe/constants'
+import { structuredCloneStringify } from 'devframe/utils/structured-clone'
+import { dirname, resolve } from 'pathe'
+import { strictJsonStringify } from '../serialization'
+
+export interface WriteStaticRpcDumpOptions {
+  /**
+   * Pretty-print RPC dump JSON files. Defaults to `false` so payload
+   * shards (which can be multiple MB for graph-heavy tools) ship
+   * minified. Set `true` when you need to diff / read the dumps by hand.
+   */
+  pretty?: boolean
+}
+
+/**
+ * Write a collected static RPC dump to disk: every sharded record file plus
+ * the `__rpc-dump/index.json` manifest, under `outDir`. Shared by the build
+ * adapter (`createBuild`) and `@devframes/hub`'s `buildHub`.
+ */
+export async function writeStaticRpcDump(
+  dump: StaticRpcDumpCollection,
+  outDir: string,
+  options: WriteStaticRpcDumpOptions = {},
+): Promise<void> {
+  const indent = options.pretty ? 2 : undefined
+  await fs.mkdir(resolve(outDir, DEVFRAME_RPC_DUMP_DIRNAME), { recursive: true })
+  for (const [filepath, file] of Object.entries(dump.files)) {
+    const fullpath = resolve(outDir, filepath)
+    await fs.mkdir(dirname(fullpath), { recursive: true })
+    const text = file.serialization === 'structured-clone'
+      ? structuredCloneStringify(file.data)
+      : strictJsonStringify(file.data, file.fnName)
+    await fs.writeFile(
+      fullpath,
+      // structured-clone-es output is single-line; only JSON honors `indent`.
+      file.serialization === 'json' && indent != null
+        ? JSON.stringify(JSON.parse(text), null, indent)
+        : text,
+      'utf-8',
+    )
+  }
+  await fs.writeFile(
+    resolve(outDir, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME),
+    JSON.stringify(dump.manifest, null, 2),
+    'utf-8',
+  )
+}
diff --git a/packages/devframe/src/types/context.ts b/packages/devframe/src/types/context.ts
index 1a037a52f..5af5215ce 100644
--- a/packages/devframe/src/types/context.ts
+++ b/packages/devframe/src/types/context.ts
@@ -187,12 +187,19 @@ export interface ConnectionMeta {
    */
   jsonSerializableMethods?: string[]
   /**
-   * Absolute URL of the `__connection.json` this meta was loaded from.
-   * Annotated by the client (not served) when it publishes the meta on a
-   * shared window for same-origin inheritance: a relative `websocket.path`
-   * resolves against this, so a child SPA mounted at another base (e.g. a hub
-   * mounting several devframes at `/__foo/`, `/__bar/`, …) inherits a dialable
-   * endpoint rather than resolving the path against its own mount.
+   * URL of the `__connection.json` that owns this meta's relative paths.
+   * Two producers write it:
+   *
+   *   - The client annotates it (absolute) when it publishes the meta on a
+   *     shared window for same-origin inheritance: a relative
+   *     `websocket.path` resolves against this, so a child SPA mounted at
+   *     another base (e.g. a hub mounting several devframes at `/__foo/`,
+   *     `/__bar/`, …) inherits a dialable endpoint rather than resolving the
+   *     path against its own mount.
+   *   - A static hub build serves it (base-absolute, e.g.
+   *     `/__devframes/__connection.json`) in each **per-frame** meta, so a
+   *     frame SPA that fetched its own copy still resolves the shared RPC
+   *     dump from the hub base. Resolved against the fetched URL.
    */
   baseUrl?: string
   /**
diff --git a/packages/devframe/src/types/devframe.ts b/packages/devframe/src/types/devframe.ts
index bedc81e1d..6e39f18d5 100644
--- a/packages/devframe/src/types/devframe.ts
+++ b/packages/devframe/src/types/devframe.ts
@@ -413,10 +413,11 @@ export interface DevframeDefinition {
    * act on a `false` before doing any work:
    *
    * - `build: false`: `createCac` skips registering the `build` subcommand,
-   *   and `createBuild` refuses (throws `DF0042`) unless `{ force: true }`.
-   *   Useful for a devframe whose value is inherently live (e.g. it manages
-   *   real files on disk), so a static export would only ever produce a
-   *   broken, write-less shell of the tool.
+   *   `createBuild` refuses (throws `DF0042`) unless `{ force: true }`, and
+   *   a hub static build (`buildHub`) silently skips the devframe - no dock,
+   *   no SPA copy, no RPCs in the dump. Useful for a devframe whose value is
+   *   inherently live (e.g. it manages real files on disk), so a static
+   *   export would only ever produce a broken, write-less shell of the tool.
    * - `dev: false`: `createDevServer` refuses (throws `DF0058`) unless
    *   `{ force: true }`. Useful for a devframe that only makes sense as a
    *   static export (e.g. a report generator with nothing to serve live).
diff --git a/packages/hub/package.json b/packages/hub/package.json
index d92309e3d..9d2195609 100644
--- a/packages/hub/package.json
+++ b/packages/hub/package.json
@@ -22,6 +22,7 @@
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.mjs",
+    "./build": "./dist/node/build.mjs",
     "./client": "./dist/client/index.mjs",
     "./constants": "./dist/constants.mjs",
     "./initiate": "./dist/node/initiate.mjs",
diff --git a/packages/hub/src/client/host.ts b/packages/hub/src/client/host.ts
index 3cc73c9e3..3243ac3d5 100644
--- a/packages/hub/src/client/host.ts
+++ b/packages/hub/src/client/host.ts
@@ -218,6 +218,15 @@ export async function createDevframeClientRuntime(
     })
   }
 
+  // On a static backend no server can relay `hub:docks:activate`, so a panel
+  // iframe posts its activation on a same-origin BroadcastChannel instead and
+  // this runtime switches the dock locally.
+  if (rpc.connectionMeta?.backend === 'static' && typeof BroadcastChannel !== 'undefined') {
+    const activateChannel = new BroadcastChannel(HUB_EVENTS.broadcastChannel.docksActivate)
+    activateChannel.onmessage = event => activateHandler(event.data as { dockId?: string })
+    disposers.push(() => activateChannel.close())
+  }
+
   if (getDevframeClientContext()) {
     console.warn(
       '[@devframes/hub] A client context is already published on this page; replacing it. '
diff --git a/packages/hub/src/client/messages.ts b/packages/hub/src/client/messages.ts
index 681886ece..5807a533f 100644
--- a/packages/hub/src/client/messages.ts
+++ b/packages/hub/src/client/messages.ts
@@ -24,6 +24,12 @@ export interface MessagesClientOptions {
  * dock client script reports into the very feed the server writes to.
  */
 export function createMessagesClient(rpc: DevframeRpcClient, options: MessagesClientOptions = {}): DevframeMessagesClient {
+  // A static backend has no messages host to write into: keep handles local
+  // so a client script that reports as it goes (e.g. the a11y page script
+  // mirroring scans) runs unchanged against a static build.
+  if (rpc.connectionMeta?.backend === 'static')
+    return createLocalMessagesClient(options)
+
   const { call } = rpc
 
   function makeHandle(entry: DevframeMessageEntry): DevframeMessageHandle {
@@ -66,3 +72,51 @@ export function createMessagesClient(rpc: DevframeRpcClient, options: MessagesCl
     debug: levelShortcut('debug'),
   }
 }
+
+/** In-page-only writes for a static backend: same surface, no wire. */
+function createLocalMessagesClient(options: MessagesClientOptions): DevframeMessagesClient {
+  let nextId = 0
+
+  function makeEntry(input: DevframeMessageEntryInput): DevframeMessageEntry {
+    return {
+      timestamp: Date.now(),
+      ...options.defaults,
+      ...input,
+      id: input.id ?? `local-${++nextId}`,
+      from: 'browser',
+    }
+  }
+
+  function makeHandle(entry: DevframeMessageEntry): DevframeMessageHandle {
+    let current = entry
+    return {
+      get entry() {
+        return current
+      },
+      get id() {
+        return current.id
+      },
+      async update(patch) {
+        current = { ...current, ...patch, id: current.id, from: current.from }
+        return current
+      },
+      dismiss: async () => {},
+    }
+  }
+
+  const add = async (input: DevframeMessageEntryInput): Promise<DevframeMessageHandle> => makeHandle(makeEntry(input))
+  function levelShortcut(level: DevframeMessageLevel) {
+    return (message: string, extra?: DevframeMessageShortcutInput) =>
+      add({ ...extra, message, level })
+  }
+  return {
+    add,
+    remove: async () => {},
+    clear: async () => {},
+    info: levelShortcut('info'),
+    warn: levelShortcut('warn'),
+    error: levelShortcut('error'),
+    success: levelShortcut('success'),
+    debug: levelShortcut('debug'),
+  }
+}
diff --git a/packages/hub/src/events.ts b/packages/hub/src/events.ts
index bd6aeb375..c93893335 100644
--- a/packages/hub/src/events.ts
+++ b/packages/hub/src/events.ts
@@ -70,4 +70,13 @@ export const HUB_EVENTS = {
   postMessage: {
     frameNav: 'devframe:frame-nav',
   },
+  /**
+   * Same-origin `BroadcastChannel` names, `devframe:` prefix. Used on a
+   * `static` backend, where no live server can relay a client's request to
+   * its sibling browsing contexts (e.g. a panel iframe steering the host
+   * page's dock selection).
+   */
+  broadcastChannel: {
+    docksActivate: 'devframe:docks:activate',
+  },
 } as const
diff --git a/packages/hub/src/node/__tests__/build.test.ts b/packages/hub/src/node/__tests__/build.test.ts
new file mode 100644
index 000000000..cbe9539f0
--- /dev/null
+++ b/packages/hub/src/node/__tests__/build.test.ts
@@ -0,0 +1,125 @@
+import type { DevframeDefinition, DevframeNodeContext } from 'devframe/types'
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { HUB_EVENTS } from '../../events'
+import { buildHub } from '../build'
+
+function makeDist(html: string): string {
+  const dir = mkdtempSync(join(tmpdir(), 'hub-build-dist-'))
+  writeFileSync(join(dir, 'index.html'), html, 'utf-8')
+  return dir
+}
+
+function makePageScript(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'hub-build-script-'))
+  writeFileSync(join(dir, 'inject.js'), 'export default () => {}\n', 'utf-8')
+  return join(dir, 'inject.js')
+}
+
+function makeFrame(id: string, options: { distDir?: string, clientScript?: string } = {}): DevframeDefinition {
+  return {
+    id,
+    name: `Frame ${id}`,
+    version: '0.0.0',
+    packageName: `@test/${id}`,
+    homepage: '',
+    description: '',
+    ...(options.distDir ? { clientAssets: options.distDir } : {}),
+    ...(options.clientScript ? { dock: { clientScript: { importFrom: options.clientScript } } } : {}),
+    setup(ctx: DevframeNodeContext) {
+      ctx.rpc.register({
+        name: `${id}:probe`,
+        type: 'static',
+        jsonSerializable: true,
+        handler: () => `ok:${id}`,
+      })
+    },
+  }
+}
+
+describe('buildHub', () => {
+  it('bakes a self-contained static hub: SPAs, page scripts, metas, and the RPC dump', async () => {
+    const outDir = join(mkdtempSync(join(tmpdir(), 'hub-build-out-')), 'hub')
+    const pageScript = makePageScript()
+
+    await buildHub({
+      outDir,
+      base: '/__hub/',
+      cwd: mkdtempSync(join(tmpdir(), 'hub-build-cwd-')),
+      devframes: [
+        makeFrame('alpha', { distDir: makeDist('<h1>alpha</h1>'), clientScript: pageScript }),
+        makeFrame('beta', { distDir: makeDist('<h1>beta</h1>') }),
+      ],
+    })
+
+    // Each SPA copied verbatim, the page script served under its frame base.
+    expect(readFileSync(join(outDir, 'alpha/index.html'), 'utf-8')).toContain('alpha')
+    expect(existsSync(join(outDir, 'alpha/__page-script/inject.js'))).toBe(true)
+    expect(readFileSync(join(outDir, 'beta/index.html'), 'utf-8')).toContain('beta')
+
+    // Hub meta is static; per-frame metas point back at the hub's own meta.
+    const hubMeta = JSON.parse(readFileSync(join(outDir, '__connection.json'), 'utf-8'))
+    expect(hubMeta.backend).toBe('static')
+    const frameMeta = JSON.parse(readFileSync(join(outDir, 'alpha/__connection.json'), 'utf-8'))
+    expect(frameMeta.baseUrl).toBe('/__hub/__connection.json')
+
+    // The dump bakes each devframe's static RPC and the shared-state
+    // snapshots (docks with the rewritten page-script URL among them).
+    const manifest = JSON.parse(readFileSync(join(outDir, '__rpc-dump/index.json'), 'utf-8'))
+    expect(manifest['alpha:probe']).toMatchObject({ type: 'static' })
+    const stateEntry = manifest['devframe:rpc:server-state:get']
+    expect(stateEntry.type).toBe('query')
+    const recordFiles = Object.values(stateEntry.records) as string[]
+    const records = recordFiles.map(path => readFileSync(join(outDir, path), 'utf-8'))
+    const docksRecord = records.find(text => text.includes(HUB_EVENTS.sharedState.docks))
+    expect(docksRecord).toContain('/__hub/alpha/__page-script/inject.js')
+
+    // Discovery documents.
+    const index = JSON.parse(readFileSync(join(outDir, '__index.json'), 'utf-8'))
+    expect(index.frames.map((frame: { id: string }) => frame.id)).toEqual(['alpha', 'beta'])
+    expect(readFileSync(join(outDir, '__client-imports.js'), 'utf-8')).toContain('/__hub/alpha/__page-script/inject.js')
+  })
+
+  it('skips a devframe declaring capabilities.build: false', async () => {
+    const outDir = join(mkdtempSync(join(tmpdir(), 'hub-build-out-')), 'hub')
+    const live: DevframeDefinition = {
+      ...makeFrame('live', { distDir: makeDist('<h1>live</h1>') }),
+      capabilities: { build: false },
+    }
+
+    await buildHub({
+      outDir,
+      base: '/__hub/',
+      cwd: mkdtempSync(join(tmpdir(), 'hub-build-cwd-')),
+      devframes: [makeFrame('alpha', { distDir: makeDist('<h1>alpha</h1>') }), live],
+    })
+
+    // Nothing of the skipped devframe lands in the output: no SPA, no frame
+    // entry, no RPCs in the dump, no dock in the baked shared state.
+    expect(existsSync(join(outDir, 'live'))).toBe(false)
+    const index = JSON.parse(readFileSync(join(outDir, '__index.json'), 'utf-8'))
+    expect(index.frames.map((frame: { id: string }) => frame.id)).toEqual(['alpha'])
+    const manifest = JSON.parse(readFileSync(join(outDir, '__rpc-dump/index.json'), 'utf-8'))
+    expect(manifest['live:probe']).toBeUndefined()
+    const stateEntry = manifest['devframe:rpc:server-state:get']
+    const records = (Object.values(stateEntry.records) as string[])
+      .map(path => readFileSync(join(outDir, path), 'utf-8'))
+    const docksRecord = records.find(text => text.includes(HUB_EVENTS.sharedState.docks))
+    expect(docksRecord).toContain('alpha')
+    expect(docksRecord).not.toContain('Frame live')
+  })
+
+  it('rejects a mount base outside the hub base', async () => {
+    const outDir = join(mkdtempSync(join(tmpdir(), 'hub-build-out-')), 'hub')
+    await expect(buildHub({
+      outDir,
+      base: '/__hub/',
+      cwd: mkdtempSync(join(tmpdir(), 'hub-build-cwd-')),
+      async configure(ctx) {
+        await ctx.install(makeFrame('gamma', { distDir: makeDist('<h1>gamma</h1>') }), { base: '/elsewhere/' })
+      },
+    })).rejects.toThrow(/escapes "\/__hub\/"/)
+  })
+})
diff --git a/packages/hub/src/node/assemble.ts b/packages/hub/src/node/assemble.ts
new file mode 100644
index 000000000..914a87a37
--- /dev/null
+++ b/packages/hub/src/node/assemble.ts
@@ -0,0 +1,138 @@
+import type { DevframeDefinition } from 'devframe/types'
+import type { ClientScriptEntry } from '../types/docks'
+import type { DevframeHubContext } from './context'
+import type { DevframesInput, DockRendererRegistration, HubDevframeEntry } from './initiate'
+import { existsSync } from 'node:fs'
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_MCP_ROUTE, DEVFRAME_WS_ROUTE } from 'devframe/constants'
+import { resolve } from 'pathe'
+import { joinURL, withTrailingSlash } from 'ufo'
+import { resolveClientModuleSpecifier } from '../client-modules'
+import { diagnostics } from './diagnostics'
+import { prepareDevframe, skippedInStaticBuild } from './install-devframe'
+
+/** Reserved filenames directly under the hub base; a frame id can't shadow them. */
+const RESERVED_HUB_PATHS = [
+  DEVFRAME_CONNECTION_META_FILENAME,
+  DEVFRAME_DOCK_IMPORTS_FILENAME,
+  DEVFRAME_WS_ROUTE,
+  DEVFRAME_MCP_ROUTE,
+  '__index.json',
+  '__renderers',
+  'embedded.js',
+] as const
+
+/** One resolved `devframes` slot: an entry, or nothing when it opted out. */
+type ResolvedDevframeEntry = DevframeDefinition | HubDevframeEntry | null | undefined
+
+function normalizeDevframeEntry(entry: DevframeDefinition | HubDevframeEntry): HubDevframeEntry {
+  return 'devframe' in entry ? entry : { devframe: entry }
+}
+
+/**
+ * Flatten the `devframes` input: await every thenable, call every factory,
+ * spread the arrays, and drop the empty slots, so a host can build the list
+ * conditionally (`isDev && loadInspect()`) without filtering it first.
+ */
+export function resolveDevframesInput(input: DevframesInput): Promise<HubDevframeEntry[]> {
+  return Promise.all(input.map(async (entry) => {
+    const resolved = await (typeof entry === 'function' ? entry() : entry)
+    const slots: readonly ResolvedDevframeEntry[] = Array.isArray(resolved)
+      ? resolved
+      : [resolved as ResolvedDevframeEntry]
+    return slots
+      .filter((slot): slot is DevframeDefinition | HubDevframeEntry => slot != null)
+      .map(normalizeDevframeEntry)
+  }))
+    .then(arrays => arrays.flat())
+}
+
+/**
+ * Validate the renderer-module registrations fail-fast: route-safe types
+ * (each becomes the `<base>__renderers/<type>.mjs` URL segment), one module
+ * per type, and an existing bundle file (renderer packages are prebuilt).
+ */
+export function resolveRendererRegistrations(
+  registrations: readonly DockRendererRegistration[],
+): DockRendererRegistration[] {
+  const seen = new Set<string>()
+  return registrations.map((registration) => {
+    if (!/^[\w.-]+$/.test(registration.type))
+      throw diagnostics.DF8110({ type: registration.type })
+    if (seen.has(registration.type))
+      throw diagnostics.DF8108({ type: registration.type })
+    seen.add(registration.type)
+    const file = resolve(registration.file)
+    if (!existsSync(file))
+      throw diagnostics.DF8109({ type: registration.type, file })
+    return { ...registration, file }
+  })
+}
+
+/**
+ * Render the dock client-script import map as an ES module: one dynamic
+ * import thunk per dock that carries a client script (`clientScript` on
+ * iframe docks, `action`, `renderer`). External viewers import this module
+ * from `<base>__client-imports.js` to load per-dock client code into the
+ * host page; `importFrom` values are URL paths the host serves, or bare npm
+ * specifiers resolved through the host's `clientModuleResolution` template.
+ */
+export function renderClientImportsModule(ctx: DevframeHubContext): string {
+  const template = ctx.staticConfig.dock?.clientModuleResolution
+  const entries: string[] = []
+  for (const [id, view] of ctx.docks.views) {
+    const scripts: ClientScriptEntry[] = []
+    const anyView = view as { clientScript?: ClientScriptEntry, action?: ClientScriptEntry, renderer?: ClientScriptEntry }
+    if (anyView.clientScript)
+      scripts.push(anyView.clientScript)
+    if (anyView.action)
+      scripts.push(anyView.action)
+    if (anyView.renderer)
+      scripts.push(anyView.renderer)
+    if (scripts.length === 0)
+      continue
+    const thunks = scripts.map(script =>
+      `() => import(${JSON.stringify(resolveClientModuleSpecifier(script.importFrom, { template }))})`)
+    entries.push(`  ${JSON.stringify(id)}: [${thunks.join(', ')}],`)
+  }
+  return `// Generated by @devframes/hub: dock client-script import map.\nexport const clientImports = {\n${entries.join('\n')}\n}\nexport default clientImports\n`
+}
+
+/**
+ * Pass 1: mount each devframe under `<base><id>/` (SPA, meta, iframe dock)
+ * and queue its declared services, guarding the id against reserved hub
+ * filenames and route-pattern characters. Returns the deferred setup thunks.
+ */
+export async function mountDevframes(
+  ctx: DevframeHubContext,
+  devframes: HubDevframeEntry[],
+  base: string,
+  frames: { id: string, base: string, title: string }[],
+  hubMcpEnabled: boolean,
+): Promise<(() => Promise<void>)[]> {
+  const setups: (() => Promise<void>)[] = []
+  for (const { devframe: def, dock } of devframes) {
+    if ((RESERVED_HUB_PATHS as readonly string[]).includes(def.id))
+      throw diagnostics.DF8000({ id: def.id })
+    // The id becomes a URL segment (`<base><id>/`) routed by h3, where `:` and
+    // `*` are route-pattern markers, and separators would escape the
+    // segment entirely.
+    if (!/^[\w.-]+$/.test(def.id))
+      throw diagnostics.DF8004({ id: def.id })
+    // A hub exposes one aggregate MCP route over every mounted devframe, so a
+    // devframe's own `mcp` request is only meaningful when the hub's own MCP
+    // can mount (an explicit setting or the `'auto'` default). Warn when the
+    // hub turned it off, rather than silently dropping the devframe's
+    // intended agent surface.
+    if (!hubMcpEnabled && def.cli?.mcp)
+      diagnostics.DF8005({ id: def.id })
+    const frameBase = withTrailingSlash(joinURL(base, def.id))
+    const run = await prepareDevframe(ctx, def, { base: frameBase, ...(dock ? { dock } : {}) })
+    if (run)
+      setups.push(run)
+    // A devframe skipped by the static build serves nothing, so it never
+    // joins the `__index.json` frame list either.
+    if (!skippedInStaticBuild(ctx, def))
+      frames.push({ id: def.id, base: frameBase, title: def.name })
+  }
+  return setups
+}
diff --git a/packages/hub/src/node/build.ts b/packages/hub/src/node/build.ts
new file mode 100644
index 000000000..b22305c36
--- /dev/null
+++ b/packages/hub/src/node/build.ts
@@ -0,0 +1,261 @@
+/* eslint-disable no-console */
+import type { ConnectionMeta, DevframeServiceInput, DevframeStorageScope } from 'devframe/types'
+import type { ClientScriptEntry } from '../types/docks'
+import type { CreateHubContextOptions, DevframeHubContext } from './context'
+import type { DevframeHubUi, DevframesInput, DockRendererRegistration } from './initiate'
+import { existsSync } from 'node:fs'
+import fs from 'node:fs/promises'
+import process from 'node:process'
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME } from 'devframe/constants'
+import { createH3DevframeHost } from 'devframe/internal'
+import { collectStaticRpcDump, writeStaticRpcDump } from 'devframe/rpc/dump'
+import { colors as c } from 'devframe/utils/colors'
+import { dirname, resolve } from 'pathe'
+import { joinURL } from 'ufo'
+import { DEVFRAMES_HUB_BASE, DOCK_RENDERERS_STATE_KEY, normalizeHubBase } from '../constants'
+import { mountDevframes, renderClientImportsModule, resolveDevframesInput, resolveRendererRegistrations } from './assemble'
+import { createHubContext } from './context'
+import { diagnostics } from './diagnostics'
+
+export interface BuildHubOptions {
+  /**
+   * Output directory the hub subtree is written into. It corresponds to the
+   * hub {@link BuildHubOptions.base} at serve time: building with
+   * `base: '/__devframes/'` into `dist/__devframes` makes the deployed app's
+   * `dist/` servable as-is by any static file server.
+   */
+  outDir: string
+  /**
+   * Mount base the deployed hub answers under (baked into every absolute URL
+   * the build emits: page-script rewrites, renderer modules, per-frame meta
+   * pointers). Default: `/__devframes/`.
+   */
+  base?: string
+  /** Devframes to bake as docks, same input as `initHub({ devframes })`. */
+  devframes?: DevframesInput
+  /** Host-level wire services, same contract as `initHub({ services })`. */
+  services?: DevframeServiceInput[]
+  /** Extra RPC declarations registered at context creation. */
+  rpcDeclarations?: CreateHubContextOptions['builtinRpcDeclarations']
+  /**
+   * Runs once the context exists and every `devframes` entry is mounted;
+   * register docks, commands, and messages surfaces here, exactly like
+   * `initHub({ configure })`. Everything it registers is baked into the
+   * static shared-state snapshot.
+   */
+  configure?: (ctx: DevframeHubContext) => void | Promise<void>
+  /**
+   * The hub's UI slot: the viewer SPA is copied to the hub base, the
+   * `embedded.js` bootstrap next to it, and `setup(ctx)` runs so its static
+   * config (branding, dock preferences) is baked into the connection meta.
+   */
+  ui?: DevframeHubUi
+  /** Prebuilt dock-renderer modules, copied to `<base>__renderers/<type>.mjs`. */
+  renderers?: readonly DockRendererRegistration[]
+  /** Name written into `<base>__index.json`. */
+  name?: string
+  /** Version written into `<base>__index.json`. */
+  version?: string
+  /** Working directory for the hub context. Default: `process.cwd()`. */
+  cwd?: string
+  /** Override where persisted devframe state lives during the build. */
+  getStorageDir?: (scope: DevframeStorageScope) => string
+  /** Pretty-print RPC dump JSON files. Default: `false` (minified shards). */
+  pretty?: boolean
+}
+
+/**
+ * Produce a self-contained static deploy of a whole hub, the multi-devframe
+ * counterpart of devframe's `createBuild`:
+ *
+ *   - Build a `mode: 'build'` hub context and mount every devframe: each
+ *     SPA is copied to `<outDir>/<id>/`, an absolute-path page script to
+ *     `<outDir>/<id>/__page-script/`, and its `setup(ctx)` runs.
+ *   - Copy the UI slot's viewer SPA, `embedded.js`, and the renderer
+ *     modules, and write the discovery documents (`__index.json`,
+ *     `__client-imports.js`).
+ *   - Write `__connection.json` (`{ backend: 'static' }`, carrying
+ *     `ctx.staticConfig` as `configs`) at the hub base and at every frame
+ *     base (each pointing back at the hub's own meta via `baseUrl`).
+ *   - Bake the shared RPC dump under `<outDir>/__rpc-dump/`: every
+ *     `static`/`snapshot` RPC plus a snapshot of each shared-state key
+ *     (docks, commands, renderer manifest), so `createDevframeClientRuntime`
+ *     and every frame SPA boot from the dump with no live server.
+ *
+ * Reads work from the baked dump; live writes (messages, terminals,
+ * commands execution) have no server and degrade to no-ops in the clients.
+ */
+export async function buildHub(options: BuildHubOptions): Promise<void> {
+  const base = normalizeHubBase(options.base ?? DEVFRAMES_HUB_BASE)
+  const cwd = options.cwd ?? process.cwd()
+  const outDir = resolve(cwd, options.outDir)
+  const rendererRegistrations = resolveRendererRegistrations(options.renderers ?? [])
+
+  if (existsSync(outDir))
+    await fs.rm(outDir, { recursive: true })
+  await fs.mkdir(outDir, { recursive: true })
+
+  /** Map a hub-base-relative URL base to its on-disk location under `outDir`. */
+  function resolveOutPath(urlBase: string): string {
+    if (!urlBase.startsWith(base))
+      throw diagnostics.DF8006({ urlBase, base })
+    return resolve(outDir, urlBase.slice(base.length))
+  }
+
+  // Every base a devframe's SPA was mounted at, so a per-frame
+  // `__connection.json` (pointing back at the hub's own meta) is written
+  // alongside each copied SPA.
+  const frameMetaBases: string[] = []
+
+  const h3Host = createH3DevframeHost({
+    origin: 'http://localhost',
+    appName: 'devframes',
+    workspaceRoot: cwd,
+    /**
+     * A static build "serves" by copying: a local dist verbatim, a remote
+     * assets source by materializing every listed file.
+     */
+    mount: async (mountBase, source) => {
+      const target = resolveOutPath(mountBase)
+      await fs.mkdir(dirname(target), { recursive: true })
+      if (typeof source === 'string')
+        await fs.cp(source, target, { recursive: true })
+      else
+        await source.materialize(target)
+    },
+  })
+  const host = {
+    ...h3Host,
+    ...(options.getStorageDir ? { getStorageDir: options.getStorageDir } : {}),
+    mountConnectionMeta: (frameBase: string) => {
+      // Validate eagerly (this hook is awaited before the SPA mount, which is
+      // fire-and-forget), so an out-of-base mount fails the build here rather
+      // than as an unhandled rejection inside the copy.
+      resolveOutPath(frameBase)
+      frameMetaBases.push(frameBase)
+    },
+  }
+
+  const ctx = await createHubContext({
+    cwd,
+    workspaceRoot: cwd,
+    mode: 'build',
+    host,
+    ...(options.rpcDeclarations ? { builtinRpcDeclarations: options.rpcDeclarations } : {}),
+  })
+
+  const devframes = await resolveDevframesInput(options.devframes ?? [])
+  for (const input of options.services ?? [])
+    void ctx.services.install(input)
+  const frames: { id: string, base: string, title: string }[] = []
+  const setups = await mountDevframes(ctx, devframes, base, frames, false)
+
+  await ctx.services.ready()
+  for (const run of setups)
+    await run()
+
+  await options.configure?.(ctx)
+  await options.ui?.setup?.(ctx)
+
+  await publishRendererManifest(ctx, rendererRegistrations, base, outDir)
+  await writeUiArtifacts(options.ui, outDir)
+
+  await fs.writeFile(resolve(outDir, DEVFRAME_DOCK_IMPORTS_FILENAME), renderClientImportsModule(ctx), 'utf-8')
+
+  await fs.writeFile(resolve(outDir, '__index.json'), `${JSON.stringify({
+    name: options.name,
+    version: options.version,
+    base,
+    frames,
+    endpoints: {
+      connection: DEVFRAME_CONNECTION_META_FILENAME,
+      clientImports: DEVFRAME_DOCK_IMPORTS_FILENAME,
+      index: '__index.json',
+      ...(options.ui?.embedded ? { embedded: 'embedded.js' } : {}),
+    },
+  }, null, 2)}\n`, 'utf-8')
+
+  await writeConnectionMetas(ctx, base, outDir, frameMetaBases.map(resolveOutPath))
+
+  console.log(c.cyan`[devframes-hub] writing RPC dump to ${resolve(outDir, '__rpc-dump')}`)
+  const dump = await collectStaticRpcDump(ctx.rpc.definitions.values(), ctx)
+  await writeStaticRpcDump(dump, outDir, { pretty: options.pretty })
+
+  console.log(c.green`[devframes-hub] built ${frames.length} devframe${frames.length === 1 ? '' : 's'} -> ${outDir}`)
+}
+
+/**
+ * Publish the renderer manifest exactly like `initHub` does, so it is baked
+ * into the shared-state snapshot, and copy each prebuilt module to the URL
+ * the manifest advertises.
+ */
+async function publishRendererManifest(
+  ctx: DevframeHubContext,
+  registrations: readonly DockRendererRegistration[],
+  base: string,
+  outDir: string,
+): Promise<void> {
+  const manifest: Record<string, ClientScriptEntry> = {}
+  for (const registration of registrations) {
+    manifest[registration.type] = {
+      importFrom: joinURL(base, '__renderers', `${registration.type}.mjs`),
+      ...(registration.importName ? { importName: registration.importName } : {}),
+    }
+    await fs.mkdir(resolve(outDir, '__renderers'), { recursive: true })
+    await fs.copyFile(registration.file, resolve(outDir, '__renderers', `${registration.type}.mjs`))
+  }
+  const manifestState = await ctx.rpc.sharedState.get<Record<string, ClientScriptEntry>>(
+    DOCK_RENDERERS_STATE_KEY,
+    { initialValue: {} },
+  )
+  manifestState.mutate(() => manifest)
+}
+
+/**
+ * Copy the UI slot's artifacts: the viewer SPA owns the hub base (copied
+ * before the discovery documents, so those win over same-named files it
+ * ships), `embedded.js` next to it, plus any produced assets.
+ */
+async function writeUiArtifacts(ui: DevframeHubUi | undefined, outDir: string): Promise<void> {
+  if (ui?.viewer)
+    await fs.cp(resolve(ui.viewer.distDir), outDir, { recursive: true })
+  if (ui?.embedded)
+    await fs.copyFile(resolve(ui.embedded.entry), resolve(outDir, 'embedded.js'))
+  for (const [key, produce] of Object.entries(ui?.assets ?? {})) {
+    const target = resolve(outDir, key)
+    await fs.mkdir(dirname(target), { recursive: true })
+    await fs.writeFile(target, produce())
+  }
+}
+
+/**
+ * Write the `backend: 'static'` connection meta at the hub base, and a copy
+ * at every frame base whose `baseUrl` points relative resolution (the RPC
+ * dump) back at the hub's own meta, so a frame SPA that fetched its
+ * per-frame copy (instead of inheriting the host page's connection) still
+ * finds the shared dump.
+ */
+async function writeConnectionMetas(
+  ctx: DevframeHubContext,
+  base: string,
+  outDir: string,
+  frameDirs: readonly string[],
+): Promise<void> {
+  const jsonSerializableMethods: string[] = []
+  for (const def of ctx.rpc.definitions.values()) {
+    if (def.jsonSerializable === true)
+      jsonSerializableMethods.push(def.name)
+  }
+  const meta: ConnectionMeta = {
+    backend: 'static',
+    jsonSerializableMethods,
+    ...(Object.keys(ctx.staticConfig).length > 0 ? { configs: ctx.staticConfig } : {}),
+  }
+  await fs.writeFile(resolve(outDir, DEVFRAME_CONNECTION_META_FILENAME), JSON.stringify(meta, null, 2), 'utf-8')
+  const frameMeta: ConnectionMeta = { ...meta, baseUrl: joinURL(base, DEVFRAME_CONNECTION_META_FILENAME) }
+  for (const frameDir of frameDirs) {
+    const target = resolve(frameDir, DEVFRAME_CONNECTION_META_FILENAME)
+    await fs.mkdir(dirname(target), { recursive: true })
+    await fs.writeFile(target, JSON.stringify(frameMeta, null, 2), 'utf-8')
+  }
+}
diff --git a/packages/hub/src/node/diagnostics.ts b/packages/hub/src/node/diagnostics.ts
index 98cee412f..b2e5ba7c3 100644
--- a/packages/hub/src/node/diagnostics.ts
+++ b/packages/hub/src/node/diagnostics.ts
@@ -34,6 +34,10 @@ export const diagnostics = defineDiagnostics({
       why: (p: { id: string }) => `Devframe "${p.id}" requests an MCP route, but the hub's aggregate MCP is off (\`mcp: false\`), so its tools are not exposed over MCP.`,
       fix: 'A hub exposes one aggregate MCP endpoint over every mounted devframe, so per-devframe `mcp` settings are ignored. Drop `mcp: false` from `initHub` (the `\'auto\'` default mounts the aggregate route once agent tools exist) to surface this devframe\'s tools, or drop `mcp` from the devframe to silence this warning.',
     },
+    DF8006: {
+      why: (p: { urlBase: string, base: string }) => `A static hub build can only write mounts under its own base: "${p.urlBase}" escapes "${p.base}".`,
+      fix: 'buildHub maps each mount base to a directory under its `outDir`, so every mount must live under the hub base. Drop the `basePath` override (or the `ctx.install` base) that points outside it, or move the hub `base` up so it contains the mount.',
+    },
     DF8100: {
       why: (p: { id: string }) => `Dock with id "${p.id}" is already registered`,
       fix: 'Use the `force` parameter to overwrite an existing registration.',
diff --git a/packages/hub/src/node/initiate.ts b/packages/hub/src/node/initiate.ts
index 2c9f071f6..f0dbbe05f 100644
--- a/packages/hub/src/node/initiate.ts
+++ b/packages/hub/src/node/initiate.ts
@@ -8,20 +8,18 @@ import type { Duplex } from 'node:stream'
 import type { ClientScriptEntry } from '../types/docks'
 import type { CreateHubContextOptions, DevframeHubContext } from './context'
 import type { InstallDevframeOptions } from './install-devframe'
-import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import process from 'node:process'
-import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_MCP_ROUTE, DEVFRAME_WS_ROUTE } from 'devframe/constants'
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_MCP_ROUTE } from 'devframe/constants'
 import { createH3DevframeHost, createInstanceShell, importRuntimeModule, loadAutoMcpAdapter, resolveInstanceRegister, resolveMcpConfig } from 'devframe/internal'
 import { mountStaticHandler } from 'devframe/utils/serve-static'
 import { H3 } from 'h3'
 import { resolve } from 'pathe'
-import { joinURL, withoutLeadingSlash, withTrailingSlash } from 'ufo'
-import { resolveClientModuleSpecifier } from '../client-modules'
+import { joinURL, withoutLeadingSlash } from 'ufo'
 import { DEVFRAMES_HUB_BASE, DOCK_RENDERERS_STATE_KEY, normalizeHubBase } from '../constants'
+import { mountDevframes, renderClientImportsModule, resolveDevframesInput, resolveRendererRegistrations } from './assemble'
 import { createHubContext } from './context'
 import { diagnostics } from './diagnostics'
-import { prepareDevframe } from './install-devframe'
 
 /** A `devframes` entry with per-mount dock customization. */
 export interface HubDevframeEntry {
@@ -33,10 +31,6 @@ export interface HubDevframeEntry {
 type Thenable<T> = T | Promise<T>
 type Arrayable<T> = T | readonly T[]
 
-function normalizeDevframeEntry(entry: DevframeDefinition | HubDevframeEntry): HubDevframeEntry {
-  return 'devframe' in entry ? entry : { devframe: entry }
-}
-
 /** Default mount base for a hub instance, re-exported from `../constants` (the client-safe home) for existing importers of this node entry. */
 export { DEVFRAMES_HUB_BASE }
 
@@ -55,17 +49,6 @@ function assetContentType(key: string): string {
   return 'application/octet-stream'
 }
 
-/** Reserved filenames directly under the hub base; a frame id can't shadow them. */
-const RESERVED_HUB_PATHS = [
-  DEVFRAME_CONNECTION_META_FILENAME,
-  DEVFRAME_DOCK_IMPORTS_FILENAME,
-  DEVFRAME_WS_ROUTE,
-  DEVFRAME_MCP_ROUTE,
-  '__index.json',
-  '__renderers',
-  'embedded.js',
-] as const
-
 /**
  * One dock-type → prebuilt renderer-module registration for
  * {@link InitHubOptions.renderers}. The hub serves the module at
@@ -342,78 +325,6 @@ export interface HubInstance {
   close: () => Promise<void>
 }
 
-/** One resolved `devframes` slot: an entry, or nothing when it opted out. */
-type ResolvedDevframeEntry = DevframeDefinition | HubDevframeEntry | null | undefined
-
-/**
- * Flatten the `devframes` input: await every thenable, call every factory,
- * spread the arrays, and drop the empty slots, so a host can build the list
- * conditionally (`isDev && loadInspect()`) without filtering it first.
- */
-function resolveDevframesInput(input: DevframesInput): Promise<HubDevframeEntry[]> {
-  return Promise.all(input.map(async (entry) => {
-    const resolved = await (typeof entry === 'function' ? entry() : entry)
-    const slots: readonly ResolvedDevframeEntry[] = Array.isArray(resolved)
-      ? resolved
-      : [resolved as ResolvedDevframeEntry]
-    return slots
-      .filter((slot): slot is DevframeDefinition | HubDevframeEntry => slot != null)
-      .map(normalizeDevframeEntry)
-  }))
-    .then(arrays => arrays.flat())
-}
-
-/**
- * Validate the renderer-module registrations fail-fast: route-safe types
- * (each becomes the `<base>__renderers/<type>.mjs` URL segment), one module
- * per type, and an existing bundle file (renderer packages are prebuilt).
- */
-function resolveRendererRegistrations(
-  registrations: readonly DockRendererRegistration[],
-): DockRendererRegistration[] {
-  const seen = new Set<string>()
-  return registrations.map((registration) => {
-    if (!/^[\w.-]+$/.test(registration.type))
-      throw diagnostics.DF8110({ type: registration.type })
-    if (seen.has(registration.type))
-      throw diagnostics.DF8108({ type: registration.type })
-    seen.add(registration.type)
-    const file = resolve(registration.file)
-    if (!existsSync(file))
-      throw diagnostics.DF8109({ type: registration.type, file })
-    return { ...registration, file }
-  })
-}
-
-/**
- * Render the dock client-script import map as an ES module: one dynamic
- * import thunk per dock that carries a client script (`clientScript` on
- * iframe docks, `action`, `renderer`). External viewers import this module
- * from `<base>__client-imports.js` to load per-dock client code into the
- * host page; `importFrom` values are URL paths the host serves, or bare npm
- * specifiers resolved through the host's `clientModuleResolution` template.
- */
-function renderClientImportsModule(ctx: DevframeHubContext): string {
-  const template = ctx.staticConfig.dock?.clientModuleResolution
-  const entries: string[] = []
-  for (const [id, view] of ctx.docks.views) {
-    const scripts: ClientScriptEntry[] = []
-    const anyView = view as { clientScript?: ClientScriptEntry, action?: ClientScriptEntry, renderer?: ClientScriptEntry }
-    if (anyView.clientScript)
-      scripts.push(anyView.clientScript)
-    if (anyView.action)
-      scripts.push(anyView.action)
-    if (anyView.renderer)
-      scripts.push(anyView.renderer)
-    if (scripts.length === 0)
-      continue
-    const thunks = scripts.map(script =>
-      `() => import(${JSON.stringify(resolveClientModuleSpecifier(script.importFrom, { template }))})`)
-    entries.push(`  ${JSON.stringify(id)}: [${thunks.join(', ')}],`)
-  }
-  return `// Generated by @devframes/hub: dock client-script import map.\nexport const clientImports = {\n${entries.join('\n')}\n}\nexport default clientImports\n`
-}
-
 /**
  * Resolve the shared hub context: reuse a caller-supplied one, or build an
  * h3-backed context that serves the hub's connection meta under every frame.
@@ -460,43 +371,6 @@ async function resolveHubContext(
   })
 }
 
-/**
- * Pass 1: mount each devframe under `<base><id>/` (SPA, meta, iframe dock)
- * and queue its declared services, guarding the id against reserved hub
- * filenames and route-pattern characters. Returns the deferred setup thunks.
- */
-async function mountDevframes(
-  ctx: DevframeHubContext,
-  devframes: HubDevframeEntry[],
-  base: string,
-  frames: { id: string, base: string, title: string }[],
-  hubMcpEnabled: boolean,
-): Promise<(() => Promise<void>)[]> {
-  const setups: (() => Promise<void>)[] = []
-  for (const { devframe: def, dock } of devframes) {
-    if ((RESERVED_HUB_PATHS as readonly string[]).includes(def.id))
-      throw diagnostics.DF8000({ id: def.id })
-    // The id becomes a URL segment (`<base><id>/`) routed by h3, where `:` and
-    // `*` are route-pattern markers, and separators would escape the
-    // segment entirely.
-    if (!/^[\w.-]+$/.test(def.id))
-      throw diagnostics.DF8004({ id: def.id })
-    // A hub exposes one aggregate MCP route over every mounted devframe, so a
-    // devframe's own `mcp` request is only meaningful when the hub's own MCP
-    // can mount (an explicit setting or the `'auto'` default). Warn when the
-    // hub turned it off, rather than silently dropping the devframe's
-    // intended agent surface.
-    if (!hubMcpEnabled && def.cli?.mcp)
-      diagnostics.DF8005({ id: def.id })
-    const frameBase = withTrailingSlash(joinURL(base, def.id))
-    const run = await prepareDevframe(ctx, def, { base: frameBase, ...(dock ? { dock } : {}) })
-    if (run)
-      setups.push(run)
-    frames.push({ id: def.id, base: frameBase, title: def.name })
-  }
-  return setups
-}
-
 /**
  * Initiate a hub instance: the whole multi-devframe devtools surface
  * behind one framework-agnostic, web-standard handler. Every mounted
diff --git a/packages/hub/src/node/install-devframe.ts b/packages/hub/src/node/install-devframe.ts
index 20080e50c..bdc59d71f 100644
--- a/packages/hub/src/node/install-devframe.ts
+++ b/packages/hub/src/node/install-devframe.ts
@@ -109,11 +109,23 @@ async function serveDevframeAssets(
   ctx.views.hostStatic(base, typeof clientAssets === 'string' ? resolve(clientAssets) : clientAssets, d.importMetaUrl)
 }
 
+/**
+ * Whether a devframe stays out of a static hub build: `capabilities.build:
+ * false` declares its value inherently live (a terminal, a process proxy),
+ * so `buildHub` never mounts it, registers its dock, or bakes its RPCs.
+ */
+export function skippedInStaticBuild(ctx: DevframeHubContext, d: DevframeDefinition): boolean {
+  return ctx.mode === 'build' && d.capabilities?.build === false
+}
+
 export async function prepareDevframe(
   ctx: DevframeHubContext,
   d: DevframeDefinition,
   options: InstallDevframeOptions = {},
 ): Promise<(() => Promise<void>) | null> {
+  if (skippedInStaticBuild(ctx, d))
+    return null
+
   const strategy = d.duplicationStrategy ?? 'warn'
   const isDuplicate = ctx.docks.views.has(d.id)
 
diff --git a/packages/hub/tsdown.config.ts b/packages/hub/tsdown.config.ts
index 09d1d8436..d4eb8c0dd 100644
--- a/packages/hub/tsdown.config.ts
+++ b/packages/hub/tsdown.config.ts
@@ -5,6 +5,7 @@ export default defineConfig({
     'index': 'src/index.ts',
     'constants': 'src/constants.ts',
     'client/index': 'src/client/index.ts',
+    'node/build': 'src/node/build.ts',
     'node/index': 'src/node/index.ts',
     'node/initiate': 'src/node/initiate.ts',
     'types/index': 'src/types/index.ts',
diff --git a/packages/vite/src/hub.ts b/packages/vite/src/hub.ts
index 0c15f78de..f1b24119b 100644
--- a/packages/vite/src/hub.ts
+++ b/packages/vite/src/hub.ts
@@ -7,6 +7,7 @@ import { Server as NodeHttpServer } from 'node:http'
 import process from 'node:process'
 import { DEVFRAMES_HUB_BASE, normalizeHubBase } from '@devframes/hub/constants'
 import { initHub } from '@devframes/hub/initiate'
+import { resolve } from 'pathe'
 
 export interface ViteDevframeHubOptions {
   /**
@@ -86,6 +87,17 @@ export interface ViteDevframeHubOptions {
    * @default false
    */
   quiet?: boolean
+  /**
+   * Also bake the hub into `vite build` output: `buildHub` writes the whole
+   * static hub subtree (each devframe's SPA, the RPC dump, `embedded.js`, …)
+   * into `<outDir><base>`, and the UI's `embedded.js` script tag is injected
+   * into the built HTML, so the deployed app ships working devtools against
+   * a `static` backend (baked reads, no live server). Off by default: a
+   * production bundle only carries devtools when the host opts in.
+   *
+   * @default false
+   */
+  build?: boolean
 }
 
 let recommendedViteDevtools = false
@@ -124,6 +136,9 @@ export function viteDevframeHub(options: ViteDevframeHubOptions = {}): Plugin {
   // Set once the hub is up if its UI ships an `embedded.js` bootstrap: the
   // host-page script tag `transformIndexHtml` injects.
   let embeddedSrc: string | undefined
+  // Resolved once for a static build, shared by `buildStart` (embedded.js
+  // injection) and `closeBundle` (the buildHub emit).
+  let buildUi: DevframeHubUi | undefined
 
   const teardown = async (): Promise<void> => {
     const previous = instance
@@ -131,9 +146,16 @@ export function viteDevframeHub(options: ViteDevframeHubOptions = {}): Plugin {
     await previous?.close().catch(() => {})
   }
 
+  const resolveUi = async (): Promise<DevframeHubUi | undefined> =>
+    options.ui === false ? undefined : options.ui ?? await loadDefaultUi()
+
   return {
     name: 'devframes:hub',
-    apply: 'serve',
+    /**
+     * Dev middleware by default; a production bundle only carries the hub
+     * when the host opts into the static build.
+     */
+    apply: (_, env) => env.command === 'serve' || options.build === true,
 
     configResolved(config) {
       viteConfig = config
@@ -152,9 +174,7 @@ export function viteDevframeHub(options: ViteDevframeHubOptions = {}): Plugin {
       // Resolve the UI slot: default to `@devframes/hub-ui`'s `createUi()`
       // (lazy import so `@devframes/hub-ui` stays an optional dependency),
       // honor an explicit object, or stay headless on `false`.
-      const ui = options.ui === false
-        ? undefined
-        : options.ui ?? await loadDefaultUi()
+      const ui = await resolveUi()
 
       // Attach each configured client script to its devframe's mount entry so
       // the hub client runtime imports it into the host page.
@@ -202,6 +222,16 @@ export function viteDevframeHub(options: ViteDevframeHubOptions = {}): Plugin {
       })
     },
 
+    async buildStart() {
+      // Static build: resolve the UI slot up front so `transformIndexHtml`
+      // (which runs before the bundle closes) knows whether to inject the
+      // `embedded.js` bootstrap into the built HTML.
+      if (viteConfig?.command !== 'build' || !options.build)
+        return
+      buildUi = await resolveUi()
+      embeddedSrc = buildUi?.embedded ? `${base}embedded.js` : undefined
+    },
+
     transformIndexHtml() {
       // Inject the floating-dock bootstrap when the resolved UI ships one.
       if (!embeddedSrc)
@@ -215,6 +245,22 @@ export function viteDevframeHub(options: ViteDevframeHubOptions = {}): Plugin {
 
     async closeBundle() {
       await teardown()
+
+      // Static build: bake the whole hub into the app's build output at
+      // `<outDir><base>`, so the deployed bundle serves working devtools
+      // (baked reads over the `static` backend) from any static file server.
+      if (viteConfig?.command !== 'build' || !options.build)
+        return
+      const cwd = options.cwd ?? viteConfig.root
+      const { buildHub } = await import('@devframes/hub/build')
+      await buildHub({
+        base,
+        cwd,
+        outDir: resolve(viteConfig.root, viteConfig.build.outDir, base.slice(1)),
+        devframes: attachClientScripts(options.devframes, options.clientScripts) ?? [],
+        ...(buildUi ? { ui: buildUi } : {}),
+        ...pickDefined(options, ['renderers', 'rpcDeclarations', 'getStorageDir', 'name', 'version', 'configure']),
+      })
     },
   }
 }
diff --git a/playwright.config.ts b/playwright.config.ts
index acea74e9a..5ff649fcb 100644
--- a/playwright.config.ts
+++ b/playwright.config.ts
@@ -82,6 +82,15 @@ export default defineConfig({
       stdout: 'pipe',
       stderr: 'pipe',
     },
+    {
+      command: `pnpm exec vite build && node ${JSON.stringify(serveStatic)} dist 9885`,
+      cwd: 'examples/a11y-messages-playground',
+      url: 'http://127.0.0.1:9885/',
+      timeout: 120_000,
+      reuseExistingServer: !process.env.CI,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    },
     {
       command: 'pnpm exec next dev src/client -p 9878',
       cwd: 'examples/hub-next',
diff --git a/plugins/a11y/src/node/index.ts b/plugins/a11y/src/node/index.ts
index 11ee04225..2bc451801 100644
--- a/plugins/a11y/src/node/index.ts
+++ b/plugins/a11y/src/node/index.ts
@@ -1,4 +1,5 @@
 import type { DevframeDefinition, RemoteAssets } from 'devframe'
+import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 import { defineDevframe } from 'devframe'
 import pkg from '../../package.json' with { type: 'json' }
@@ -27,8 +28,23 @@ const distDir: RemoteAssets = {
  * serves it with no host wiring. Exported for hosts that mount the module
  * themselves (e.g. via `/@fs/` under Vite). Requires the built bundle
  * (`pnpm -C plugins/a11y build`).
+ *
+ * Resolved through the package's own `./client-script` export, since a
+ * bundler may hoist this module into a shared chunk whose on-disk depth
+ * differs from the entry's, breaking an `import.meta.url`-relative path.
+ * The relative fallback covers an unbuilt bundle (resolution then fails),
+ * where downstream `existsSync` checks degrade gracefully.
  */
-export const a11yClientScriptBundlePath: string = fileURLToPath(new URL('../../dist/client-script/index.mjs', import.meta.url))
+export const a11yClientScriptBundlePath: string = resolveClientScriptBundle()
+
+function resolveClientScriptBundle(): string {
+  try {
+    return createRequire(import.meta.url).resolve(`${pkg.name}/client-script`)
+  }
+  catch {
+    return fileURLToPath(new URL('../../dist/client-script/index.mjs', import.meta.url))
+  }
+}
 
 /** @deprecated Renamed; use {@link a11yClientScriptBundlePath}. */
 export const a11yPageScriptBundlePath: string = a11yClientScriptBundlePath
diff --git a/plugins/code-server/src/node/index.ts b/plugins/code-server/src/node/index.ts
index 2295c3e60..c8ed93e15 100644
--- a/plugins/code-server/src/node/index.ts
+++ b/plugins/code-server/src/node/index.ts
@@ -49,6 +49,12 @@ export function createCodeServerDevframe(options: CodeServerOptions = {}): Devfr
     homepage: pkg.homepage,
     description: pkg.description,
     icon: 'ph:code-duotone',
+    /**
+     * The whole surface proxies a live `code-server` process, so a static
+     * build would only produce a dead shell of the tool: `createBuild`
+     * refuses and a hub static build skips this dock.
+     */
+    capabilities: { build: false },
     /**
      * Leave undefined so `resolveBasePath` picks `/` standalone and
      * `/__<id>/` when hosted. Authors override via `options.basePath`.
diff --git a/plugins/messages/app/client/App.vue b/plugins/messages/app/client/App.vue
index 2b5ffc23e..073482063 100644
--- a/plugins/messages/app/client/App.vue
+++ b/plugins/messages/app/client/App.vue
@@ -7,7 +7,7 @@ import type { DevframeConnectionStatus, DevframeRpcClient } from 'devframe/clien
 import DisplayBadge from '@antfu/design/components/Display/DisplayBadge.vue'
 import FormSearchField from '@antfu/design/components/Form/FormSearchField.vue'
 import LayoutToolbar from '@antfu/design/components/Layout/LayoutToolbar.vue'
-import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import { computed, onBeforeUnmount, onMounted, ref, toRaw } from 'vue'
 import {
   button,
   connectionBody,
@@ -83,6 +83,17 @@ onMounted(() => {
 async function onActivate(action: DevframeMessageAction): Promise<void> {
   const callOptional = props.rpc.callOptional as (name: string, ...args: unknown[]) => Promise<unknown>
   if (action.kind === 'activate') {
+    // A static backend has no server to relay the activation, so post it on
+    // the hub's same-origin BroadcastChannel (`HUB_EVENTS.broadcastChannel
+    // .docksActivate`; a local literal since this plugin keeps no runtime hub
+    // dependency) - the host page's client runtime switches the dock locally.
+    if (props.rpc.connectionMeta.backend === 'static' && typeof BroadcastChannel !== 'undefined') {
+      const channel = new BroadcastChannel('devframe:docks:activate')
+      // The raw object: a Vue reactive proxy is not structured-clonable.
+      channel.postMessage(toRaw(action.activate))
+      channel.close()
+      return
+    }
     await callOptional('hub:docks:activate', action.activate)
     return
   }
diff --git a/plugins/terminals/src/node/index.ts b/plugins/terminals/src/node/index.ts
index 84cd41cec..eb759698f 100644
--- a/plugins/terminals/src/node/index.ts
+++ b/plugins/terminals/src/node/index.ts
@@ -59,6 +59,12 @@ export function createTerminalsDevframe(options: TerminalsOptions = {}): Devfram
     homepage: pkg.homepage,
     description: pkg.description,
     icon: 'ph:terminal-window-duotone',
+    /**
+     * Terminals are inherently live (PTY sessions over the streaming
+     * channel), so a static build would only produce a dead shell of the
+     * tool: `createBuild` refuses and a hub static build skips this dock.
+     */
+    capabilities: { build: false },
     /**
      * Leave undefined so `resolveBasePath` picks `/` standalone and
      * `/__<id>/` when hosted. Authors override via `options.basePath`.
diff --git a/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.d.ts b/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.d.ts
new file mode 100644
index 000000000..32d8b991b
--- /dev/null
+++ b/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.d.ts
@@ -0,0 +1,24 @@
+/**
+ * Generated by tsnapi — public API snapshot of `@devframes/hub/build`
+ */
+// #region Interfaces
+export interface BuildHubOptions {
+  outDir: string;
+  base?: string;
+  devframes?: DevframesInput;
+  services?: DevframeServiceInput[];
+  rpcDeclarations?: CreateHubContextOptions['builtinRpcDeclarations'];
+  configure?: (_: DevframeHubContext) => void | Promise<void>;
+  ui?: DevframeHubUi;
+  renderers?: readonly DockRendererRegistration[];
+  name?: string;
+  version?: string;
+  cwd?: string;
+  getStorageDir?: (_: DevframeStorageScope) => string;
+  pretty?: boolean;
+}
+// #endregion
+
+// #region Functions
+export declare function buildHub(_: BuildHubOptions): Promise<void>;
+// #endregion
\ No newline at end of file
diff --git a/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.js b/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.js
new file mode 100644
index 000000000..963ba541b
--- /dev/null
+++ b/tests/__snapshots__/tsnapi/@devframes/hub/build.snapshot.js
@@ -0,0 +1,6 @@
+/**
+ * Generated by tsnapi — public API snapshot of `@devframes/hub/build`
+ */
+// #region Functions
+export async function buildHub(_) {}
+// #endregion
\ No newline at end of file
diff --git a/tests/__snapshots__/tsnapi/@devframes/hub/constants.snapshot.d.ts b/tests/__snapshots__/tsnapi/@devframes/hub/constants.snapshot.d.ts
index bddf45b00..659d3ac10 100644
--- a/tests/__snapshots__/tsnapi/@devframes/hub/constants.snapshot.d.ts
+++ b/tests/__snapshots__/tsnapi/@devframes/hub/constants.snapshot.d.ts
@@ -56,6 +56,9 @@ export declare const HUB_EVENTS: {
   readonly postMessage: {
     readonly frameNav: "devframe:frame-nav";
   };
+  readonly broadcastChannel: {
+    readonly docksActivate: "devframe:docks:activate";
+  };
 };
 // #endregion
 
diff --git a/tests/__snapshots__/tsnapi/@devframes/vite/hub.snapshot.d.ts b/tests/__snapshots__/tsnapi/@devframes/vite/hub.snapshot.d.ts
index ae5f1822f..9f68caf07 100644
--- a/tests/__snapshots__/tsnapi/@devframes/vite/hub.snapshot.d.ts
+++ b/tests/__snapshots__/tsnapi/@devframes/vite/hub.snapshot.d.ts
@@ -21,6 +21,7 @@ export interface ViteDevframeHubOptions {
   name?: string;
   version?: string;
   quiet?: boolean;
+  build?: boolean;
 }
 // #endregion
 
diff --git a/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.d.ts b/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.d.ts
index a1914a831..cf66afcf8 100644
--- a/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.d.ts
+++ b/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.d.ts
@@ -22,6 +22,9 @@ export interface StaticRpcDumpManifestStaticEntry {
   path: string;
   serialization?: StaticRpcDumpSerialization;
 }
+export interface WriteStaticRpcDumpOptions {
+  pretty?: boolean;
+}
 // #endregion
 
 // #region Types
@@ -37,4 +40,5 @@ export declare function dumpFunctions<T extends readonly RpcFunctionDefinitionAn
 export declare function getDefinitionsWithDumps<T extends readonly RpcFunctionDefinitionAny[]>(_: T): RpcFunctionDefinitionAny[];
 export declare function reviveDumpError(_: RpcDumpRecordError): Error;
 export declare function serializeDumpError(_: unknown): RpcDumpRecordError;
+export declare function writeStaticRpcDump(_: StaticRpcDumpCollection, _: string, _?: WriteStaticRpcDumpOptions): Promise<void>;
 // #endregion
\ No newline at end of file
diff --git a/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.js b/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.js
index 9bc5766fb..baf72d3b1 100644
--- a/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.js
+++ b/tests/__snapshots__/tsnapi/devframe/rpc/dump.snapshot.js
@@ -8,4 +8,5 @@ export { dumpFunctions }
 export { getDefinitionsWithDumps }
 export { reviveDumpError }
 export { serializeDumpError }
+export { writeStaticRpcDump }
 // #endregion
\ No newline at end of file
diff --git a/tests/e2e/a11y-messages-hub-static.spec.ts b/tests/e2e/a11y-messages-hub-static.spec.ts
new file mode 100644
index 000000000..9d17ede0c
--- /dev/null
+++ b/tests/e2e/a11y-messages-hub-static.spec.ts
@@ -0,0 +1,50 @@
+import { expect, test } from '@playwright/test'
+
+const BASE = 'http://127.0.0.1:9885/'
+
+/**
+ * The hub's static build (`buildHub` baked into `vite build` output, served
+ * by a plain static file server): the client runtime boots against the
+ * `static` backend, imports the a11y page script into the production page,
+ * and the panels work from the baked RPC dump plus the in-page channel.
+ */
+test.describe('a11y-messages playground (static hub build)', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(BASE)
+    await expect(page.locator('#conn')).toContainText('backend=static')
+  })
+
+  test('renders the dock rail from the baked shared state', async ({ page }) => {
+    await expect(page.locator('button[data-dock-id="devframes_plugin_a11y"]')).toBeVisible()
+    await expect(page.locator('button[data-dock-id="devframes_plugin_messages"]')).toBeVisible()
+  })
+
+  test('a11y page script scans the production page; the panel highlights over the in-page channel', async ({ page }) => {
+    const panel = page.frameLocator('iframe[title="A11y Inspector"]')
+
+    // The panel connects statically and receives the page script's scan of
+    // the app under test (seeded with violations) over the in-page channel.
+    await expect(panel.getByText('static', { exact: true })).toBeVisible()
+    const imageAlt = panel.getByRole('checkbox', { name: /image-alt/ })
+    await expect(imageAlt).toBeVisible()
+
+    // Pinning a violation rings the offending element in the host page: the
+    // page script draws its overlay into the production DOM.
+    await imageAlt.check()
+    await expect(page.locator('[data-df-a11y-overlay]')).toContainText('image-alt')
+  })
+
+  test('messages panel renders the baked feed; its activate action switches docks over the BroadcastChannel', async ({ page }) => {
+    await page.click('button[data-dock-id="devframes_plugin_messages"]')
+    const panel = page.frameLocator('iframe[title="Messages"]')
+
+    // The entry baked by the playground's `buildHub({ configure })`.
+    await panel.getByText('Static hub build').click()
+
+    // Its activate action rides the same-origin BroadcastChannel (no live
+    // server on a static backend) and the host page switches the dock.
+    await panel.getByRole('button', { name: 'Open a11y inspector' }).click()
+    await expect(page.locator('iframe[title="A11y Inspector"]')).toBeVisible()
+    await expect(page.locator('iframe[title="Messages"]')).toBeHidden()
+  })
+})
diff --git a/tsconfig.base.json b/tsconfig.base.json
index f825816ee..538ebd50e 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -127,6 +127,9 @@
       "devframe/adapters/mcp": [
         "./packages/devframe/src/adapters/mcp/index.ts"
       ],
+      "@devframes/hub/build": [
+        "./packages/hub/src/node/build.ts"
+      ],
       "@devframes/hub/client": [
         "./packages/hub/src/client/index.ts"
       ],