From 43de5996d8758af38e419dd4a9b0a6db0dabe3bb Mon Sep 17 00:00:00 2001
From: Bret Comnes <bret@comnes.org>
Date: Sun, 5 Jul 2026 20:32:59 -0700
Subject: [PATCH] Add unstable static client cache preview

Adds the unstable Domstack manifest preview, service-worker build support, documentation, migration notes, tests, and workspace-aware example infrastructure without the PWA example implementations.

Address manifest review feedback

Keep service worker build single file

Revert "Keep service worker build single file"

This reverts commit 3c6beffe25ac6c584cf9c580460b2072646b365e.

Working static PWA cache example

PWA
---
 .github/dependabot.yml                        | 141 +--
 .gitignore                                    |   2 +
 .npmignore                                    |   8 -
 README.md                                     | 481 ++++++++-
 agents.md                                     |   2 +
 bin.js                                        |  60 +-
 docs/v12-migration.md                         | 228 +++-
 eslint.config.js                              |   1 +
 examples/basic/package.json                   |  13 +-
 .../src/js-page/loose-assets/shared-lib.ts    |   2 +-
 examples/blog/package.json                    |  11 +-
 examples/blog/src/layouts/post.layout.ts      |  18 +-
 examples/css-modules/package.json             |  13 +-
 examples/default-layout/package.json          |   7 +-
 examples/esbuild-settings/package.json        |   7 +-
 examples/markdown-settings/package.json       |   5 +-
 .../src/markdown-it.settings.js               |   6 +-
 examples/nested-dest/package.json             |   9 +-
 examples/preact-isomorphic/package.json       |  17 +-
 .../src/isomorphic/client.ts                  |  74 +-
 .../preact-isomorphic/src/isomorphic/page.ts  |   8 +-
 .../src/layouts/root.layout.ts                |  12 +-
 examples/react/package.json                   |  11 +-
 .../react/src/globals/esbuild.settings.ts     |   2 +-
 examples/react/src/globals/global.client.ts   |  45 +-
 examples/react/src/layouts/root.layout.ts     |   2 +-
 examples/react/src/react-page/client.tsx      | 242 ++---
 examples/static-mpa-offline/DESIGN.md         | 132 +++
 examples/static-mpa-offline/README.md         | 175 ++++
 examples/static-mpa-offline/package.json      |  30 +
 .../rescue-service-worker.js                  |  31 +
 .../static-mpa-offline/src/about/client.ts    |   3 +
 examples/static-mpa-offline/src/about/page.md |   6 +
 .../static-mpa-offline/src/about/style.css    |   5 +
 .../static-mpa-offline/src/admin/client.ts    |   3 +
 examples/static-mpa-offline/src/admin/page.md |  23 +
 .../static-mpa-offline/src/admin/page.vars.ts |   5 +
 .../static-mpa-offline/src/admin/style.css    |   5 +
 .../src/cache-inspector/client.ts             |  58 +
 .../src/cache-inspector/page.html             |   7 +
 .../src/cache-inspector/page.vars.ts          |   5 +
 .../src/cache-inspector/style.css             |   5 +
 examples/static-mpa-offline/src/client.ts     |   3 +
 .../domstack-manifest.settings.ts             |  21 +
 .../globals/domstack-manifest/policy-build.ts |  33 +
 .../global-client/connection-status.ts        | 172 +++
 .../globals/global-client/global.client.ts    |  74 ++
 .../global-client/service-worker-events.ts    |  43 +
 .../service-worker-registration.ts            | 102 ++
 .../global-client/service-worker-reset.ts     |  71 ++
 .../globals/global-client/status-banner.ts    |  73 ++
 .../static-mpa-offline/src/globals/global.css | 102 ++
 .../src/globals/global.vars.ts                |   5 +
 .../service-worker/background-events.ts       | 111 ++
 .../service-worker/cache-inspection.ts        |  93 ++
 .../src/globals/service-worker/clients.ts     |  31 +
 .../globals/service-worker/fetch-handlers.ts  | 166 +++
 .../src/globals/service-worker/lifecycle.ts   |  47 +
 .../src/globals/service-worker/precache.ts    | 206 ++++
 .../globals/service-worker/runtime-cache.ts   |  86 ++
 .../service-worker/service-worker-settings.ts |  53 +
 .../globals/service-worker/service-worker.ts  | 105 ++
 .../src/layouts/admin.layout.ts               |  33 +
 .../src/layouts/progressive-cache.layout.ts   |  33 +
 .../src/layouts/render-policy-layout.ts       |  51 +
 .../src/layouts/root.layout.ts                |  33 +
 .../static-mpa-offline/src/offline/client.ts  |   3 +
 .../static-mpa-offline/src/offline/page.md    |   4 +
 .../static-mpa-offline/src/offline/style.css  |   5 +
 .../static-mpa-offline/src/page-client.ts     |  12 +
 .../static-mpa-offline/src/page-style.css     |   8 +
 examples/static-mpa-offline/src/page.md       |  85 ++
 .../src/progressive-cache/alpha/client.ts     |   3 +
 .../src/progressive-cache/alpha/page.md       |  15 +
 .../src/progressive-cache/alpha/style.css     |   5 +
 .../src/progressive-cache/assets/client.ts    |   3 +
 .../assets/details/client.ts                  |   3 +
 .../assets/details/details-badge.svg          |   9 +
 .../progressive-cache/assets/details/page.md  |  10 +
 .../assets/details/page.vars.ts               |   5 +
 .../assets/details/style.css                  |   5 +
 .../src/progressive-cache/assets/page.md      |  10 +
 .../src/progressive-cache/assets/page.vars.ts |   5 +
 .../assets/runtime-badge.svg                  |   9 +
 .../src/progressive-cache/assets/style.css    |   5 +
 .../src/progressive-cache/beta/client.ts      |   3 +
 .../src/progressive-cache/beta/page.md        |  10 +
 .../src/progressive-cache/beta/style.css      |   5 +
 .../src/progressive-cache/override/client.ts  |   3 +
 .../src/progressive-cache/override/page.md    |  16 +
 .../progressive-cache/override/page.vars.ts   |   5 +
 .../src/progressive-cache/override/style.css  |   5 +
 examples/static-mpa-offline/src/style.css     |   5 +
 examples/static-mpa-offline/tsconfig.json     |  22 +
 examples/static-mpa-workbox-offline/DESIGN.md | 112 ++
 examples/static-mpa-workbox-offline/README.md | 108 ++
 .../static-mpa-workbox-offline/package.json   |  38 +
 .../rescue-service-worker.js                  |  31 +
 .../src/about/client.ts                       |   3 +
 .../src/about/page.md                         |   6 +
 .../src/about/style.css                       |   5 +
 .../src/admin/client.ts                       |   3 +
 .../src/admin/page.md                         |  23 +
 .../src/admin/page.vars.ts                    |   5 +
 .../src/admin/style.css                       |   5 +
 .../src/cache-inspector/client.ts             |  62 ++
 .../src/cache-inspector/page.html             |   7 +
 .../src/cache-inspector/page.vars.ts          |   5 +
 .../src/cache-inspector/style.css             |   5 +
 .../static-mpa-workbox-offline/src/client.ts  |   3 +
 .../domstack-manifest.settings.ts             |  21 +
 .../globals/domstack-manifest/policy-build.ts | 121 +++
 .../global-client/connection-status.ts        | 172 +++
 .../globals/global-client/global.client.ts    |  72 ++
 .../global-client/service-worker-events.ts    |  43 +
 .../service-worker-registration.ts            | 116 ++
 .../global-client/service-worker-reset.ts     |  71 ++
 .../globals/global-client/status-banner.ts    |  73 ++
 .../src/globals/global.css                    | 110 ++
 .../src/globals/global.vars.ts                |   5 +
 .../service-worker/background-events.ts       | 108 ++
 .../service-worker/cache-inspection.ts        |  93 ++
 .../service-worker/service-worker-settings.ts |  42 +
 .../globals/service-worker/service-worker.ts  | 128 +++
 .../src/layouts/admin.layout.ts               |  33 +
 .../src/layouts/progressive-cache.layout.ts   |  33 +
 .../src/layouts/render-policy-layout.ts       |  51 +
 .../src/layouts/root.layout.ts                |  33 +
 .../src/offline/client.ts                     |   3 +
 .../src/offline/page.md                       |   4 +
 .../src/offline/style.css                     |   5 +
 .../src/page-client.ts                        |  12 +
 .../src/page-style.css                        |   8 +
 .../static-mpa-workbox-offline/src/page.md    |  86 ++
 .../src/progressive-cache/alpha/client.ts     |   3 +
 .../src/progressive-cache/alpha/page.md       |  15 +
 .../src/progressive-cache/alpha/style.css     |   5 +
 .../src/progressive-cache/assets/client.ts    |   3 +
 .../assets/details/client.ts                  |   3 +
 .../assets/details/details-badge.svg          |   9 +
 .../progressive-cache/assets/details/page.md  |  10 +
 .../assets/details/page.vars.ts               |   5 +
 .../assets/details/style.css                  |   5 +
 .../src/progressive-cache/assets/page.md      |  10 +
 .../src/progressive-cache/assets/page.vars.ts |   5 +
 .../assets/runtime-badge.svg                  |   9 +
 .../src/progressive-cache/assets/style.css    |   5 +
 .../src/progressive-cache/beta/client.ts      |   3 +
 .../src/progressive-cache/beta/page.md        |  10 +
 .../src/progressive-cache/beta/style.css      |   5 +
 .../src/progressive-cache/override/client.ts  |   3 +
 .../src/progressive-cache/override/page.md    |  16 +
 .../progressive-cache/override/page.vars.ts   |   5 +
 .../src/progressive-cache/override/style.css  |   5 +
 .../static-mpa-workbox-offline/src/style.css  |   5 +
 .../static-mpa-workbox-offline/tsconfig.json  |  22 +
 examples/string-layouts/package.json          |   5 +-
 examples/tailwind/package.json                |  11 +-
 .../tailwind/src/globals/esbuild.settings.js  |   6 +-
 examples/tailwind/src/layouts/root.layout.js  |   8 +-
 examples/type-stripping/package.json          |  17 +-
 .../type-stripping/src/isomorphic/client.ts   | 151 ++-
 .../type-stripping/src/tsx-page/client.tsx    |  24 +-
 examples/uhtml-isomorphic/package.json        |   9 +-
 .../src/layouts/root.layout.js                |   6 +-
 examples/worker-example/package.json          |  13 +-
 index.js                                      | 109 +-
 lib/build-copy/index.js                       |  23 +-
 lib/build-esbuild/index.js                    | 506 +++++++--
 lib/build-pages/index.js                      |  25 +-
 lib/build-pages/page-builders/page-writer.js  |  56 +-
 .../page-builders/template-builder.js         | 120 ++-
 lib/build-pages/page-data.js                  |  94 +-
 lib/build-pages/page-data.test.js             |  85 +-
 lib/build-pages/resolve-vars.js               |  59 +-
 lib/build-static/index.js                     |  13 +-
 lib/builder.js                                |  80 +-
 lib/domstack-manifest/index.js                | 990 ++++++++++++++++++
 lib/domstack-manifest/schema.json             | 172 +++
 lib/helpers/cpx2-report.js                    |  68 ++
 lib/helpers/domstack-error.js                 |  29 +-
 lib/helpers/domstack-warning.js               |   1 +
 lib/helpers/generate-tree-data.js             | 156 +--
 lib/helpers/path.js                           |  26 +
 lib/helpers/stable-json-stringify.js          |  38 +
 lib/helpers/type-guards.js                    |  23 +
 lib/identify-pages.js                         |  59 +-
 lib/identify-pages.test.js                    |  76 +-
 package.json                                  |  61 +-
 plans/domstack-manifest.md                    | 205 ++++
 plans/global-data.md                          | 189 ----
 plans/progressive-rebuild.md                  | 323 ------
 plans/standard-static-mpa-service-worker.md   | 199 ++++
 plans/workbox-workflow-integration.md         | 227 ++++
 scripts/domstack-manifest-schema.js           |  13 +
 test-cases/general-features/index.test.js     | 516 ++++++++-
 .../blog/2025/a-blog-post-from-2025/page.ts   |   6 +-
 .../src/domstack-manifest.settings.js         |   1 +
 .../src/globals/service-worker.mts            |  67 ++
 .../general-features/src/js-page/page.vars.js |   2 +
 .../src/libs/service-worker-helper.js         |  13 +
 .../template-output-escape/index.test.js      |  28 +
 .../template-output-escape/src/README.md      |   1 +
 .../src/escape.template.js                    |   6 +
 test-cases/type-exports/index.test.ts         | 187 +++-
 test-cases/watch/index.test.js                |  48 +-
 types.ts                                      |  20 +-
 types/@11ty__dependency-tree-typescript.d.ts  |   6 +-
 208 files changed, 9740 insertions(+), 1406 deletions(-)
 delete mode 100644 .npmignore
 create mode 100644 examples/static-mpa-offline/DESIGN.md
 create mode 100644 examples/static-mpa-offline/README.md
 create mode 100644 examples/static-mpa-offline/package.json
 create mode 100644 examples/static-mpa-offline/rescue-service-worker.js
 create mode 100644 examples/static-mpa-offline/src/about/client.ts
 create mode 100644 examples/static-mpa-offline/src/about/page.md
 create mode 100644 examples/static-mpa-offline/src/about/style.css
 create mode 100644 examples/static-mpa-offline/src/admin/client.ts
 create mode 100644 examples/static-mpa-offline/src/admin/page.md
 create mode 100644 examples/static-mpa-offline/src/admin/page.vars.ts
 create mode 100644 examples/static-mpa-offline/src/admin/style.css
 create mode 100644 examples/static-mpa-offline/src/cache-inspector/client.ts
 create mode 100644 examples/static-mpa-offline/src/cache-inspector/page.html
 create mode 100644 examples/static-mpa-offline/src/cache-inspector/page.vars.ts
 create mode 100644 examples/static-mpa-offline/src/cache-inspector/style.css
 create mode 100644 examples/static-mpa-offline/src/client.ts
 create mode 100644 examples/static-mpa-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
 create mode 100644 examples/static-mpa-offline/src/globals/domstack-manifest/policy-build.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/connection-status.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/global.client.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/service-worker-events.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/service-worker-registration.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/service-worker-reset.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global-client/status-banner.ts
 create mode 100644 examples/static-mpa-offline/src/globals/global.css
 create mode 100644 examples/static-mpa-offline/src/globals/global.vars.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/background-events.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/cache-inspection.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/clients.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/fetch-handlers.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/lifecycle.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/precache.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/runtime-cache.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/service-worker-settings.ts
 create mode 100644 examples/static-mpa-offline/src/globals/service-worker/service-worker.ts
 create mode 100644 examples/static-mpa-offline/src/layouts/admin.layout.ts
 create mode 100644 examples/static-mpa-offline/src/layouts/progressive-cache.layout.ts
 create mode 100644 examples/static-mpa-offline/src/layouts/render-policy-layout.ts
 create mode 100644 examples/static-mpa-offline/src/layouts/root.layout.ts
 create mode 100644 examples/static-mpa-offline/src/offline/client.ts
 create mode 100644 examples/static-mpa-offline/src/offline/page.md
 create mode 100644 examples/static-mpa-offline/src/offline/style.css
 create mode 100644 examples/static-mpa-offline/src/page-client.ts
 create mode 100644 examples/static-mpa-offline/src/page-style.css
 create mode 100644 examples/static-mpa-offline/src/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/alpha/client.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/alpha/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/alpha/style.css
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/client.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/details/client.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/details/details-badge.svg
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/details/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/details/page.vars.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/details/style.css
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/page.vars.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/runtime-badge.svg
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/assets/style.css
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/beta/client.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/beta/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/beta/style.css
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/override/client.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/override/page.md
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/override/page.vars.ts
 create mode 100644 examples/static-mpa-offline/src/progressive-cache/override/style.css
 create mode 100644 examples/static-mpa-offline/src/style.css
 create mode 100644 examples/static-mpa-offline/tsconfig.json
 create mode 100644 examples/static-mpa-workbox-offline/DESIGN.md
 create mode 100644 examples/static-mpa-workbox-offline/README.md
 create mode 100644 examples/static-mpa-workbox-offline/package.json
 create mode 100644 examples/static-mpa-workbox-offline/rescue-service-worker.js
 create mode 100644 examples/static-mpa-workbox-offline/src/about/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/about/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/about/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/admin/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/admin/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/admin/page.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/admin/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/cache-inspector/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/cache-inspector/page.html
 create mode 100644 examples/static-mpa-workbox-offline/src/cache-inspector/page.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/cache-inspector/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/domstack-manifest/policy-build.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/connection-status.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/global.client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-events.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-registration.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-reset.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global-client/status-banner.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global.css
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/global.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/service-worker/background-events.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/service-worker/cache-inspection.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker-settings.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/layouts/admin.layout.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/layouts/progressive-cache.layout.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/layouts/render-policy-layout.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/layouts/root.layout.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/offline/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/offline/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/offline/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/page-client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/page-style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/alpha/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/alpha/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/alpha/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/details-badge.svg
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/runtime-badge.svg
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/assets/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/beta/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/beta/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/beta/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/override/client.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/override/page.md
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/override/page.vars.ts
 create mode 100644 examples/static-mpa-workbox-offline/src/progressive-cache/override/style.css
 create mode 100644 examples/static-mpa-workbox-offline/src/style.css
 create mode 100644 examples/static-mpa-workbox-offline/tsconfig.json
 create mode 100644 lib/domstack-manifest/index.js
 create mode 100644 lib/domstack-manifest/schema.json
 create mode 100644 lib/helpers/cpx2-report.js
 create mode 100644 lib/helpers/path.js
 create mode 100644 lib/helpers/stable-json-stringify.js
 create mode 100644 lib/helpers/type-guards.js
 create mode 100644 plans/domstack-manifest.md
 delete mode 100644 plans/global-data.md
 delete mode 100644 plans/progressive-rebuild.md
 create mode 100644 plans/standard-static-mpa-service-worker.md
 create mode 100644 plans/workbox-workflow-integration.md
 create mode 100644 scripts/domstack-manifest-schema.js
 create mode 100644 test-cases/general-features/src/domstack-manifest.settings.js
 create mode 100644 test-cases/general-features/src/globals/service-worker.mts
 create mode 100644 test-cases/general-features/src/libs/service-worker-helper.js
 create mode 100644 test-cases/template-output-escape/index.test.js
 create mode 100644 test-cases/template-output-escape/src/README.md
 create mode 100644 test-cases/template-output-escape/src/escape.template.js

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 152df60e..123842dd 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,10 +1,7 @@
-# Basic dependabot.yml file with
-# minimum configuration for two package managers
-
 version: 2
 updates:
-  # Enable version updates for npm
   - package-ecosystem: "npm"
+    directory: "/"
     groups:
       typescript:
         patterns:
@@ -13,150 +10,20 @@ updates:
           - "typescript"
       preact:
         patterns:
+          - "@preact/signals"
           - "preact"
           - "preact-render-to-string"
           - "htm"
-    directory: "/"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/basic"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/css-modules/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/default-layout/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/esbuild-settings"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/markdown-settings/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/nested-dest/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/preact-isomorphic/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/react/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
       react:
         patterns:
           - "react"
           - "react-dom"
           - "@types/react"
           - "@types/react-dom"
+
     schedule:
       interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/string-layouts/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/tailwind/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/type-stripping/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/uhtml-isomorphic/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "npm"
-    directory: "/examples/worker-examples/"
-    groups:
-      typescript:
-        patterns:
-          - "@voxpelli/tsconfig"
-          - "@types/node"
-          - "typescript"
-    schedule:
-      interval: "daily"
-  # Enable version updates for pnpm
-  # Enable updates to github actions
+
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
diff --git a/.gitignore b/.gitignore
index 02a8f93e..2a021aba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,8 @@ node_modules
 sandbox.js
 .nyc_output
 package-lock.json
+pnpm-lock.yaml
+pnpm-workspace.yaml
 public
 coverage
 lcov.info
diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index ad663373..00000000
--- a/.npmignore
+++ /dev/null
@@ -1,8 +0,0 @@
-node_modules
-sandbox.js
-.nyc_output
-package-lock.json
-public
-coverage
-.tap
-.nova
diff --git a/README.md b/README.md
index 1b04d23d..400af485 100644
--- a/README.md
+++ b/README.md
@@ -41,9 +41,13 @@ Usage: domstack [options]
     --dest, -d            path to build destination directory (default: "public")
     --ignore, -i          comma separated gitignore style ignore string
     --drafts              Build draft pages with the `.draft.{md,js,ts,html}` page suffix.
+    --noEsbuildMeta       skip writing the esbuild metafile to disk
+    --domstackManifest    write the domstack manifest to disk
     --eject, -e           eject the DOMStack default layout, style and client into the src flag directory
     --watch, -w           build, watch and serve the site build
     --watch-only          watch and build the src folder without serving
+    --serve               build once and serve the destination directory without watching
+    --port                port for --serve (default: 3000)
     --copy                path to directories to copy into dist; can be used multiple times
     --help, -h            show help
     --version, -v         show version information
@@ -55,6 +59,7 @@ domstack (v12.0.0)
 
 - Running `domstack` will result in a `build` by default.
 - Running `domstack --watch` or `domstack -w` will build the site and start an auto-reloading development web-server that watches for changes (provided by [`@domstack/sync`][domstack-sync]).
+- Running `domstack --serve` will run a normal one-shot build and then serve the destination directory without watching or injecting live-reload snippets. This is useful for PWA testing because service-worker hooks and manifest versions run against stable build bytes. Add `--domstackManifest` if you also need to serve `domstack-manifest.json`. Use `domstack --serve --port 3001` to choose a different local port.
 - Running `domstack --eject` or `domstack -e` will extract the default layout, global styles, and client-side JavaScript into your source directory and add the necessary dependencies to your package.json.
 
 `domstack` is primarily a unix `bin` written for the [Node.js](https://nodejs.org) runtime that is intended to be installed from `npm` as a `devDependency` inside a `package.json` committed to a `git` repository.
@@ -133,7 +138,9 @@ src % tree
 │        ├── global.vars.ts # site wide variables get defined in global.vars.ts
 │        ├── global.data.ts # optional file to derive and aggregate data from all pages before rendering
 │        ├── markdown-it.settings.ts # You can customize the markdown-it instance used to render markdown
-│        └── esbuild.settings.ts # You can even customize the build settings passed to esbuild
+│        ├── domstack-manifest.settings.ts # You can customize the domstack manifest
+│        ├── esbuild.settings.ts # You can even customize the build settings passed to esbuild
+│        └── service-worker.ts # a site service worker builds to /service-worker.js.
 ├── page.md # The top level page can also be a page.md (or README.md) file.
 ├── client.ts # the top level page can define a page scoped js client.
 ├── style.css # the top level page can define a page scoped css style.
@@ -153,15 +160,14 @@ To run examples:
 ```bash
 $ git clone git@github.com:bcomnes/domstack.git
 $ cd domstack
-# install the top level deps
+# install the root package and all example workspaces
 $ npm i
-$ cd example:{example-name}
-# install the example deps
-$ npm i
-# start the example
-$ npm start
+# build one example workspace
+$ npm --workspace @domstack/basic-example run build
 ```
 
+Each example is an npm workspace under `examples/*`, so a root `npm install` links the local `@domstack/static` package into example builds. Example packages keep `@domstack/static` declared as `file:../../.` so the local dependency target remains explicit.
+
 ### Additional examples
 
 Here are some additional external examples of larger domstack projects.
@@ -533,13 +539,30 @@ Thanks for reading my article
 
 A page referencing a layout name that doesn't have a matching layout file will result in a build error.
 
+Layouts may also export optional default variables for pages using that layout. Like page/global vars, layout vars may be an object, a sync function, or an async function:
+
+```ts
+export const vars = {
+  showSidebar: true,
+  pageType: 'article',
+}
+```
+
+Layout vars are merged into the same resolved page variable cascade that pages, layouts, templates, and domstack manifest settings receive. Precedence is:
+
+```txt
+page/frontmatter vars > page.vars.* > layout vars > global.data/global.vars > domstack defaults
+```
+
+This makes layout vars useful for section-wide defaults while still letting individual pages override them.
+
 ### The default `root.layout.js`
 
 A layout is a `ts`/`js` file that `export default`'s an async or sync function that implements an outer-wrapper html template that will house the inner content from the page (`children`) being rendered. Think of the frame around a picture. That's a layout. 🖼️
 
 It is always passed a single object argument with the following entries:
 
-- `vars`: An object of global, page folder, and page variables merged together. Pages can customize layouts by providing or overriding global defaults.
+- `vars`: The resolved page variable cascade, including domstack defaults, global vars/data, layout vars, page vars, and page builder vars/frontmatter. Pages can customize layouts by overriding global or layout defaults.
 - `scripts`: array of paths that should be included onto the page in a script tag src with type `module`.
 - `styles`: array of paths that should be included onto the page in a `link rel="stylesheet"` tag with the `href` pointing to the paths in the array.
 - `children`: A string of the inner content of the page, or whatever type your js page functions returns. `md` and `html` page types always return strings.
@@ -562,6 +585,10 @@ type RootLayoutVars = {
   basePath?: string
 }
 
+export const vars = {
+  defaultStyle: true,
+}
+
 const defaultRootLayout: LayoutFunction<RootLayoutVars, string | HtmlResult, string> = ({
   vars: {
     title,
@@ -1069,6 +1096,366 @@ await pMap(allPosts, async (page) => {
 const html = renderCache.get(page.pageInfo.path) ?? ''
 ```
 
+## Domstack Manifest
+
+> [!WARNING]
+> The domstack manifest, `domstack-manifest.settings.*`, first-class `service-worker.*` builds, manifest hooks, and related browser `process.env.DOMSTACK_*` defines are an unstable preview feature.
+> Their names, option shapes, manifest schema, generated output, and runtime semantics may change outside of a major version while the API is validated with real PWA use cases.
+> Avoid depending on this preview contract for long-lived integrations without pinning `@domstack/static` to an exact version.
+
+Programmatic one-shot builds return a `domstackManifest` object when a manifest consumer exists.
+A consumer is either a `domstack-manifest.settings.*` file or explicit `domstackManifest` configuration.
+`hooks.manifestBuilt` receives that manifest before the final service-worker bundle is emitted.
+The CLI does not write `domstack-manifest.json` by default; writing the JSON file is opt-in for deployment metadata or integrations that need a runtime/public manifest artifact.
+
+The manifest is a normalized list of files that domstack emitted:
+
+```js
+/**
+ * @import { FromSchema } from 'json-schema-to-ts'
+ */
+import { DOMSTACK_MANIFEST_SCHEMA_ID, domstackManifestSchema } from '@domstack/static'
+
+/**
+ * @typedef {FromSchema<typeof domstackManifestSchema>} DomstackManifest
+ */
+```
+
+Equivalent shape:
+
+```ts
+type DomstackManifest<Policy = Record<string, unknown>, ManifestVars = Record<string, unknown>> = {
+  $schema: typeof DOMSTACK_MANIFEST_SCHEMA_ID
+  version: string
+  generatedAt: string
+  entries: DomstackManifestEntry<ManifestVars>[]
+  policy?: Policy
+}
+
+type DomstackManifestEntry<ManifestVars = Record<string, unknown>> = {
+  url: string
+  outputRelname: string
+  kind: 'page' | 'template' | 'script' | 'style' | 'chunk' |
+    'service-worker' | 'worker' | 'worker-manifest' | 'static' |
+    'copy' | 'sourcemap' | 'metadata'
+  revision: string | null
+  bytes: number | null
+  contentType?: string
+  integrity?: string
+  manifestVars?: ManifestVars
+  urlRevisioned?: boolean
+  static?: boolean
+  role?: string
+  sourceRelname?: string
+  entryPoint?: string
+  pagePath?: string
+  pageUrl?: string
+  templatePath?: string
+  page?: {
+    path: string
+    url: string
+    vars?: {
+      precache?: unknown
+      offline?: unknown
+    }
+  }
+}
+```
+
+domstack exports `DOMSTACK_MANIFEST_SCHEMA_ID`, `DOMSTACK_MANIFEST_SCHEMA_PATH`,
+`getDomstackManifestSchemaId(version)`, `domstackManifestSchema`, `domstackManifestEntrySchema`,
+`domstackManifestEntryPageMetaSchema`, and `domstackManifestKindSchema` for tools that want the JSON Schema
+contract directly. The public `DomstackManifest`, `DomstackManifestEntry`, `DomstackManifestEntryPageMeta`,
+`DomstackManifestKind`, `DomstackManifestOptions`, `DomstackManifestTransformContext`,
+`DomstackManifestTransform`, `DomstackManifestPolicyTransformContext`, and
+`DomstackManifestPolicyTransform` types are derived from or aligned with those schemas.
+
+`version` is a sha256 hash of each sorted entry's cache-relevant fields: `url`, `revision`, `kind`,
+`contentType`, `integrity`, `manifestVars`, `urlRevisioned`, `static`, `role`, page-level
+`precache` / `offline` vars, and root `policy`. It intentionally does not depend on `generatedAt`, source
+metadata such as `sourceRelname`, or the final `/service-worker.js` build output, so identical cache
+inputs keep the same version and that version can be safely embedded into the service worker.
+
+Write the standard public manifest from the CLI with `--domstackManifest`:
+
+```console
+domstack --domstackManifest
+```
+
+Use the object form when you also need programmatic manifest options:
+
+```js
+const site = new DomStack('src', 'public', {
+  domstackManifest: {
+    write: true,
+    exclude: ['blog/**', '**/*.map'],
+    manifestVars: ['offline', 'precache'],
+    policy: {
+      offlineFallbackUrl: '/offline/',
+    },
+  },
+})
+
+const results = await site.build()
+```
+
+Use `domstackManifest: true` when you only want to write the standard `domstack-manifest.json` file.
+Use the object form when you need programmatic `exclude`, `manifestVars`, `policy`, or `hooks` settings.
+Add `write: true` to the object form only when you also want Domstack to write `domstack-manifest.json`.
+Leaving `domstackManifest` unset skips the manifest pipeline unless a `domstack-manifest.settings.*` file exists.
+A settings file enables the pipeline, returns `results.domstackManifest`, and runs manifest hooks, but it does not write a public JSON file unless writing is explicitly enabled.
+The manifest file itself is never included in its own `entries`.
+Site service workers are also omitted from manifest entries so `manifest.version` can be embedded into `/service-worker.js` without a circular hash dependency.
+
+You can also add a `domstack-manifest.settings.js` file anywhere under `src`:
+
+```js
+export default {
+  exclude: ['admin/**'],
+  manifestVars: ['offline', 'precache'],
+  policy: {
+    offlineFallbackUrl: '/offline/',
+  },
+  includeEntry (entry) {
+    if (entry.kind === 'sourcemap') return false
+    if (entry.kind === 'metadata') return false
+    if (entry.manifestVars?.offline === false) return false
+    if (entry.manifestVars?.precache === false) return false
+    return true
+  },
+}
+```
+
+`domstack-manifest.settings.*` supports `.js`, `.mjs`, `.cjs`, `.ts`, `.mts`, and `.cts` when Node's
+TypeScript support is available. It can default export an object or a sync/async function that
+returns an object:
+
+```js
+export default async function domstackManifestSettings () {
+  return {
+    exclude: process.env.INCLUDE_BLOG_OFFLINE === '1'
+      ? ['**/*.map']
+      : ['blog/**', '**/*.map'],
+  }
+}
+```
+
+`domstackManifest.exclude` from programmatic options and `domstack-manifest.settings.*` `exclude` values are combined.
+Exclude patterns are ignore-style patterns checked against both `entry.url` and `entry.outputRelname`.
+Excludes run before `includeEntry(entry)`.
+The `includeEntry(entry)` hook receives the public manifest entry shape, not local filesystem paths.
+Custom public manifest-like files should be written from a `manifestBuilt` hook with `context.writeFile()`.
+
+Each entry also includes best-known service-worker/deployment metadata when domstack can derive it:
+
+- `contentType`: best-known build-time MIME type. This is not a guarantee that every deployment will serve the exact same HTTP `Content-Type` header.
+- `integrity`: SRI-formatted SHA-256 digest derived from the same file hash as `revision`.
+- `urlRevisioned`: whether the public URL already contains a content hash or equivalent revision token.
+- `static`: whether the entry is domstack static browser-loadable output. In domstack/static this includes pages as well as subresources.
+- `role`: normalized runtime purpose such as `navigation`, `subresource`, `worker`, or `metadata`.
+
+For page entries, an explicit string `manifestRole` page var overrides the domstack-derived `role`:
+
+```js
+export default {
+  manifestRole: 'offline-fallback',
+}
+```
+
+For custom manifest data, use `manifestVars` to explicitly expose selected page/app vars on entries for tools that need to inspect them, and use root `policy` for normalized service-worker or integration decisions. `DomstackManifestOptions<Policy, ManifestVars, SourceVars>` lets TypeScript users coordinate the emitted policy shape, emitted entry var shape, and source variable-cascade shape:
+
+```js
+export default {
+  manifestVars: ['offline', 'precache'],
+  policy: {
+    offlineFallbackUrl: '/offline/',
+  },
+}
+```
+
+`manifestVars` can also be a per-entry transform, and `policy` can be a whole-manifest transform that receives final entries:
+
+```js
+export default {
+  manifestVars ({ vars }) {
+    return typeof vars.analyticsLabel === 'string'
+      ? { analyticsLabel: vars.analyticsLabel }
+      : undefined
+  },
+  policy ({ entries }) {
+    return {
+      offlineUrls: entries
+        .filter(entry => entry.manifestVars?.offline === true)
+        .map(entry => entry.url),
+    }
+  },
+}
+```
+
+Only values selected by `manifestVars` are copied into public manifest entries. Root `policy` is emitted once on the manifest. This avoids leaking arbitrary page vars while still letting service workers, Workbox hooks, and deployment tools consume a stable manifest-level policy shape.
+
+### Manifest built hooks
+
+`hooks.manifestBuilt` runs after domstack has finalized `manifest.entries`, `manifest.policy`, and
+`manifest.version`, but before `/service-worker.js` is bundled and before the manifest file is written.
+Hooks can write additional generated output files, or define constants that are available only to the
+final service-worker bundle:
+
+```js
+export default {
+  hooks: {
+    manifestBuilt: [context => {
+      const urls = context.manifest.entries
+        .filter(entry => entry.role === 'navigation')
+        .map(entry => entry.url)
+
+      context.defineServiceWorkerConstant('__APP_NAVIGATION_URLS__', urls)
+    }],
+  },
+}
+```
+
+Then the service worker can declare and use the injected constant:
+
+```js
+/** @type {string[]} */
+const navigationUrls = __APP_NAVIGATION_URLS__
+```
+
+Hook context shape:
+
+```ts
+type DomstackManifestBuiltHookContext<Policy, ManifestVars> = {
+  dest: string
+  manifest: DomstackManifest<Policy, ManifestVars>
+  defineServiceWorkerConstant: (identifier: string, value: unknown) => void
+  writeFile: (outputRelname: string, contents: string | Uint8Array) => Promise<void>
+}
+```
+
+`defineServiceWorkerConstant()` serializes `value` with `JSON.stringify()` and passes it to esbuild's
+`define` option for the final service-worker build. Use it for precomputed service-worker policy, such
+as a vanilla precache list or Workbox-shaped `precacheManifest`, when you do not want a runtime fetch or generated global script.
+
+### Service workers
+
+Put one site service worker source file anywhere under `src` and domstack will build it to a stable
+root `/service-worker.js` output:
+
+```txt
+src/
+  globals/
+    service-worker.js
+```
+
+When Node's TypeScript support is available, the same convention also supports
+`service-worker.ts`, `service-worker.mts`, and `service-worker.cts`. JavaScript projects can use
+`service-worker.js`, `service-worker.mjs`, or `service-worker.cjs`.
+
+Only one site service worker source is allowed. If multiple `service-worker.*` sources are present,
+domstack fails with `DOM_STACK_ERROR_DUPLICATE_SERVICE_WORKER`. Service workers are bundled by
+esbuild, so imports work the same way they do for client bundles and page-scoped web workers. The
+entry filename is intentionally not content-hashed because browser service-worker update checks need
+a stable URL.
+
+Domstack provides build facts to browser-side bundles through esbuild `define` values. The service
+worker is built after the manifest is finalized, so it additionally receives the finalized manifest
+version:
+
+| Define | Value |
+| --- | --- |
+| `process.env.DOMSTACK_MANIFEST_URL` | Standard public URL for the built-in domstack manifest, `/domstack-manifest.json` |
+| `process.env.DOMSTACK_MANIFEST_VERSION` | Finalized manifest version in `/service-worker.js`; `""` in other bundles |
+| `process.env.DOMSTACK_MANIFEST_ENABLED` | `"true"` for one-shot builds with an enabled manifest pipeline, `"false"` when disabled or in watch mode |
+| `process.env.DOMSTACK_SERVICE_WORKER_URL` | Public URL of the site service worker, usually `/service-worker.js`, or `""` when no service worker is present |
+| `process.env.DOMSTACK_SERVICE_WORKER_SCOPE` | Registration scope for the site service worker, usually `/`, or `""` when no service worker is present |
+
+Prefer injecting finalized service-worker policy from `hooks.manifestBuilt` instead of fetching the public manifest at runtime:
+
+```js
+// domstack-manifest.settings.js
+export default {
+  manifestVars: ['offline', 'precache'],
+  hooks: {
+    manifestBuilt: [context => {
+      context.defineServiceWorkerConstant('__APP_CACHE_POLICY__', {
+        version: context.manifest.version,
+        precacheEntries: context.manifest.entries
+          .filter(entry => entry.static === true)
+          .filter(entry => entry.revision)
+          .map(entry => ({
+            url: entry.url,
+            revision: entry.urlRevisioned ? null : entry.revision,
+            integrity: entry.integrity,
+          })),
+      })
+    }],
+  },
+}
+```
+
+Then consume that policy from the service worker:
+
+```js
+// service-worker.js
+const CACHE_PREFIX = 'domstack-precache-'
+const manifestEnabled = process.env.DOMSTACK_MANIFEST_ENABLED === 'true'
+
+self.addEventListener('install', event => {
+  if (!manifestEnabled) return
+  event.waitUntil(precache())
+})
+
+self.addEventListener('fetch', event => {
+  if (event.request.method !== 'GET') return
+  event.respondWith(cacheFirst(event.request))
+})
+
+async function precache () {
+  const policy = __APP_CACHE_POLICY__
+  const cache = await caches.open(CACHE_PREFIX + policy.version)
+  await cache.addAll(policy.precacheEntries.map(entry => new Request(entry.url, {
+    cache: 'reload',
+    credentials: 'same-origin',
+    ...(entry.integrity ? { integrity: entry.integrity } : {}),
+  })))
+}
+
+async function cacheFirst (request) {
+  const cached = await caches.match(request)
+  return cached || fetch(request)
+}
+```
+
+Use `context.writeFile()` from a manifest hook only when you intentionally need a public runtime artifact.
+
+Register the built service worker from your site client code, usually `global.client.js`:
+
+```js
+const serviceWorkerUrl = process.env.DOMSTACK_SERVICE_WORKER_URL
+const serviceWorkerScope = process.env.DOMSTACK_SERVICE_WORKER_SCOPE
+
+if (serviceWorkerUrl && serviceWorkerScope && 'serviceWorker' in navigator) {
+  navigator.serviceWorker.register(serviceWorkerUrl, { scope: serviceWorkerScope })
+}
+```
+
+domstack does not inject this into the default layout. Registration timing, update prompts,
+development opt-outs, and recovery behavior are application policy, so keep that logic in your
+global client or an imported client module.
+
+This keeps domstack's build pipeline to one page/template pass and one manifest reconciliation. Use
+`domstack-manifest.settings.*` `exclude` or `includeEntry(entry)` to keep entries such as source maps, admin
+routes, or blog pages out of the written manifest before the service worker sees it.
+
+Watch mode builds and rebundles site service-worker entries, but it does not write
+`domstack-manifest.json` or return `results.domstackManifest`. Use one-shot builds when testing
+service-worker and PWA cache behavior.
+
+Domstack does not clean the destination directory before a build. During this preview, run clean
+builds for service-worker lifecycle testing and deployments so removed or renamed preview outputs
+(such as `/service-worker.js` or a custom manifest filename) cannot remain as stale files.
+
 ## Global Assets
 
 There are a few important (and optional) global assets that live anywhere in the `src` directory. If duplicate named files that match the global asset file name pattern are found, a build error will occur until the duplicate file error is resolved.
@@ -1097,6 +1484,9 @@ export const browser = {
 ```
 
 The exported object is passed to esbuild's [`define`](https://esbuild.github.io/api/#define) options and is available to every js bundle.
+Domstack also reserves `process.env.DOMSTACK_MANIFEST_URL`,
+`process.env.DOMSTACK_MANIFEST_VERSION`, `process.env.DOMSTACK_MANIFEST_ENABLED`,
+`process.env.DOMSTACK_SERVICE_WORKER_URL`, and `process.env.DOMSTACK_SERVICE_WORKER_SCOPE` for generated build facts.
 
 > [!WARNING]
 > Setting `define` in [`esbuild.settings.ts`](#esbuild-settingsts) while also using the `browser` export will throw an error. Use one or the other.
@@ -1180,6 +1570,43 @@ Use `GlobalDataFunction<T>` or `AsyncGlobalDataFunction<T>` to type the function
 
 **`renderInnerPage()` is available.** `global.data.js` runs after page initialization has been attempted, and receives `PageData` instances (some may be uninitialized if they failed to initialize), so you can call `renderInnerPage()` here with the same care described above for `page.vars` and other page-dependent access. For examples and performance guidance, see [Accessing rendered page content](#accessing-rendered-page-content).
 
+### `domstack-manifest.settings.ts`
+
+This is an optional file you can create anywhere.
+It should export a default object or a default sync/async function that returns an object.
+Use this to filter the domstack manifest before hooks receive it, before domstack optionally writes
+`domstack-manifest.json`, and before `results.domstackManifest` is returned.
+
+```js
+/**
+ * @import { DomstackManifestEntry } from '@domstack/static'
+ */
+
+export default {
+  exclude: [
+    'admin/**',
+    '**/*.map',
+  ],
+  includeEntry,
+}
+
+/**
+ * @param {DomstackManifestEntry} entry
+ */
+function includeEntry (entry) {
+  return entry.kind !== 'metadata'
+}
+```
+
+The supported settings are:
+
+- `exclude` - ignore-style patterns matched against `entry.url` and `entry.outputRelname`.
+- `includeEntry(entry)` - a sync or async function that receives a public `DomstackManifestEntry` and returns `true` to keep it.
+
+The `domstackManifest.exclude` option and `domstack-manifest.settings.*` `exclude` values are combined.
+Excludes run before `includeEntry(entry)`.
+Watch mode builds and rebundles service workers, but it does not write or return the domstack manifest, so `domstack-manifest.settings.*` is only applied during one-shot builds.
+
 ### `esbuild.settings.ts`
 
 This is an optional file you can create anywhere.
@@ -1643,7 +2070,7 @@ The following diagram illustrates the DomStack build process:
 │                 │ │                 │ │                 │
 │ • Bundle JS/CSS │ │ • Copy static   │ │ • Copy extra    │
 │ • Generate      │ │   files         │ │   directories   │
-│   metafile      │ │ (if enabled)    │ │   from opts     │
+│   records       │ │ • Record files  │ │ • Record files  │
 └────────┬────────┘ └────────┬────────┘ └────────┬────────┘
          │                   │                   │
          └───────────────────┼───────────────────┘
@@ -1656,6 +2083,13 @@ The following diagram illustrates the DomStack build process:
                     │ • Process MD     │
                     │ • Process JS     │
                     │ • Apply layouts  │
+                    │ • Record outputs │
+                    └────────┬─────────┘
+                             │
+                             ▼
+                    ┌──────────────────┐
+                    │ Reconcile        │
+                    │ Output Manifest  │
                     └────────┬─────────┘
                              │
                              ▼
@@ -1667,6 +2101,7 @@ The following diagram illustrates the DomStack build process:
                     │ • staticResults  │
                     │ • copyResults    │
                     │ • pageResults    │
+                    │ • domstackManifest │
                     │ • warnings       │
                     └──────────────────┘
 ```
@@ -1675,11 +2110,13 @@ The build process follows these key steps:
 
 1. **Page identification** - Scans the source directory to identify all pages, layouts, templates, and global assets
 2. **Destination preparation** - Ensures the destination directory is ready for the build output
-3. **Parallel asset processing** - Three operations run concurrently:
+3. **Parallel asset processing** - Three operations run concurrently and record their outputs:
    - JavaScript and CSS bundling via esbuild
    - Static file copying (when enabled)
    - Additional directory copying (from `--copy` options)
-4. **Page building** - Processes all pages, applying layouts and generating final HTML
+4. **Page building** - Processes pages and normal templates, applying layouts and recording outputs
+5. **Manifest reconciliation** - Normalizes recorded outputs, hashes file contents, filters entries, and computes a stable manifest version
+6. **Return results** - Writes the manifest when enabled and returns all build results
 
 This architecture allows for efficient parallel processing of independent tasks while maintaining the correct build order dependencies.
 
@@ -1741,14 +2178,15 @@ The `buildPages()` step processes pages in parallel with a concurrency limit:
                 └───────────────────────────────┘
 ```
 
-Variable Resolution Layers:
-- **Global vars** - Site-wide variables from `global.vars.js` (resolved once)
-- **Layout vars** - Layout-specific variables from layout functions (resolved once)
+Variable Resolution Layers, from lowest to highest precedence:
+- **Domstack defaults** - Internal defaults such as the default `layout: 'root'`.
+- **Global vars** - Site-wide variables from `global.vars.js` (resolved once).
+- **Global data** - Derived variables from `global.data.js`, stamped onto every page after all pages initialize.
+- **Layout vars** - Optional `export const vars` from the selected layout module.
 - **Page-specific vars** vary by type:
-  - **MD pages**: page.vars.js + builder vars (from frontmatter)
-  - **HTML pages**: page.vars.js
-  - **JS pages**: exported vars → page.vars.js
-- **Global data** - Derived variables from `global.data.js`, stamped onto every page after all pages initialize (resolved once, after page init)
+  - **MD pages**: `page.vars.js` plus builder vars from frontmatter.
+  - **HTML pages**: `page.vars.js`.
+  - **JS pages**: exported `vars` plus `page.vars.js`.
 
 ### Watch Mode
 
@@ -1758,6 +2196,10 @@ When you run `domstack --watch` (or `domstack -w`), domstack performs an initial
 
 **chokidar watch** — Page files, layouts, templates, and config files are watched by chokidar. When a file changes, domstack determines the minimal set of pages to rebuild using dependency tracking maps built at startup.
 
+Domstack manifests are build-only artifacts. Watch mode builds and rebundles site service-worker
+entries, but it does not write `domstack-manifest.json` or return `results.domstackManifest`.
+Use `domstack --serve` when testing PWA cache lifecycle behavior locally: it runs a normal manifest-enabled build and serves the result without watch-mode filenames or live-reload HTML injection, so service-worker policy matches emitted build bytes. Add `--domstackManifest` if the worker or test needs the public JSON manifest file.
+
 #### What triggers what
 
 | Change | Rebuild scope |
@@ -1771,7 +2213,8 @@ When you run `domstack --watch` (or `domstack -w`), domstack performs an initial
 | `markdown-it.settings.*` | All `.md` pages |
 | `global.data.*` | All pages and templates |
 | `global.vars.*` or `esbuild.settings.*` | Full rebuild (esbuild restart + all pages) |
-| `client.js`, `style.css`, `*.layout.css`, `*.layout.client.*`, `global.client.*`, `global.css`, `*.worker.*` | esbuild handles it — no page rebuild |
+| `domstack-manifest.settings.*` | No rebuild in watch mode; domstack manifests are only generated in one-shot builds |
+| `client.js`, `style.css`, `*.layout.css`, `*.layout.client.*`, `global.client.*`, `global.css`, `*.worker.*`, `service-worker.*` | esbuild handles it — no page rebuild |
 | Adding or removing an esbuild entry point (e.g. creating a new `client.js`) | esbuild restart + only the affected page(s) |
 | Adding or removing any other file | Full rebuild |
 
diff --git a/agents.md b/agents.md
index 9e03d4f4..e4c499d5 100644
--- a/agents.md
+++ b/agents.md
@@ -3,8 +3,10 @@
 - Write Markdown prose with one sentence per line so git diffs stay focused and readable.
 - Never use inline type imports.
 - Always favor `@import` syntax at the top of JavaScript files for JSDoc types.
+- Add explicit TypeScript lib reference headers when a standalone example file relies on browser or service-worker globals, such as `/// <reference lib="dom" />` for client files or `/// <reference lib="webworker" />` for service-worker files.
 - This repo does not require TypeScript declaration builds during normal development.
 - Type builds are only needed during publish time or when debugging types.
 - After running a type build, clean up the generated build files and do not leave them sitting around.
 - Use the cleanup scripts in `package.json` for generated type build files.
+- For formatting-only ESLint failures, use `npx eslint <path> --fix` for a quick targeted fix before rerunning lint.
 - When handling PR review comments, validate that each comment is correct before making changes; maintainer comments are almost always valid, but review bot comments may be wrong, and after addressing a comment, always reply with what was done.
diff --git a/bin.js b/bin.js
index e5cdbcfa..7fd8d680 100755
--- a/bin.js
+++ b/bin.js
@@ -4,10 +4,11 @@
  * @import { BuildStepWarnings, DomStackOpts as DomStackOpts } from './lib/builder.js'
  * @import { ArgscloptsParseArgsOptionsConfig } from 'argsclopts'
  * @import { Logger as PinoLogger } from 'pino'
+ * @import { BsInstance } from '@domstack/sync'
  */
 
 import { readFile } from 'node:fs/promises'
-import { resolve, join, relative } from 'node:path'
+import { basename, resolve, join, relative } from 'node:path'
 import { parseArgs } from 'node:util'
 import { printHelpText } from 'argsclopts'
 import readline from 'node:readline'
@@ -15,6 +16,7 @@ import process from 'process'
 // @ts-expect-error
 import tree from 'pretty-tree'
 import { inspect } from 'util'
+import { createServer } from '@domstack/sync'
 import { packageDirectory } from 'package-directory'
 import { readPackage } from 'read-pkg'
 import { addPackageDependencies } from 'write-package'
@@ -58,15 +60,15 @@ const options = {
     help: 'Build draft pages with the `.draft.{md,js,html}` page suffix.',
     default: false
   },
-  target: {
-    type: 'string',
-    short: 't',
-    help: 'comma separated target strings for esbuild',
-  },
   noEsbuildMeta: {
     type: 'boolean',
     help: 'skip writing the esbuild metafile to disk',
   },
+  domstackManifest: {
+    type: 'boolean',
+    help: 'write the domstack manifest to disk',
+  },
+
   eject: {
     type: 'boolean',
     short: 'e',
@@ -81,6 +83,14 @@ const options = {
     type: 'boolean',
     help: 'watch and build the src folder without serving',
   },
+  serve: {
+    type: 'boolean',
+    help: 'build once and serve the destination directory without watching',
+  },
+  port: {
+    type: 'string',
+    help: 'port for --serve (default: 3000)',
+  },
   copy: {
     type: 'string',
     help: 'path to directories to copy into dist; can be used multiple times',
@@ -205,8 +215,8 @@ domstack eject actions:
   const opts = {}
 
   if (argv['ignore']) opts.ignore = String(argv['ignore']).split(',')
-  if (argv['target']) opts.target = String(argv['target']).split(',')
   if (argv['noEsbuildMeta']) opts.metafile = false
+  if (argv['domstackManifest']) opts.domstackManifest = true
   if (argv['drafts']) opts.buildDrafts = true
   if (argv['copy']) {
     const copyPaths = Array.isArray(argv['copy']) ? argv['copy'] : [argv['copy']]
@@ -217,6 +227,16 @@ domstack eject actions:
   const logger = createDomStackLogger()
   opts.logger = logger
   const domStack = new DomStack(src, dest, opts)
+  /** @type {BsInstance | null} */
+  let buildServer = null
+
+  if (argv['serve'] && (argv['watch'] || argv['watch-only'])) {
+    throw new Error('--serve cannot be combined with --watch or --watch-only')
+  }
+  if (argv['port'] && !argv['serve']) {
+    throw new Error('--port can only be combined with --serve')
+  }
+  const servePort = argv['port'] ? parsePort(String(argv['port'])) : undefined
 
   process.once('SIGINT', quit)
   process.once('SIGTERM', quit)
@@ -226,6 +246,11 @@ domstack eject actions:
       await domStack.stopWatching()
       logger.info('Watching stopped')
     }
+    if (buildServer) {
+      await buildServer.exit()
+      buildServer = null
+      logger.info('Server stopped')
+    }
     logger.info('Quitting cleanly')
     process.exit(0)
   }
@@ -236,6 +261,16 @@ domstack eject actions:
       logger.info(tree(generateTreeData(cwd, src, dest, results)))
       logWarnings(logger, results?.warnings)
       logger.info('\nBuild Success!\n\n')
+      if (argv['serve']) {
+        buildServer = await createServer({
+          server: dest,
+          files: basename(dest),
+          logger: logger.child({ component: 'sync', logPrefix: '[domstack-sync]' }),
+          ...(servePort ? { port: servePort } : {}),
+          snippet: false,
+        })
+        logger.info(`Serving ${relative(cwd, dest)} without watching. Press Ctrl-C to stop.`)
+      }
     } catch (err) {
       if (!(err instanceof Error || err instanceof AggregateError)) throw new Error('Non-error thrown', { cause: err })
       if (err instanceof DomStackAggregateError) {
@@ -259,6 +294,17 @@ domstack eject actions:
   }
 }
 
+/**
+ * @param {string} value
+ */
+function parsePort (value) {
+  const port = Number(value)
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error('--port must be an integer between 1 and 65535')
+  }
+  return port
+}
+
 /**
  * @param {PinoLogger} logger
  * @param {BuildStepWarnings | undefined} warnings
diff --git a/docs/v12-migration.md b/docs/v12-migration.md
index 89f1f6aa..664c91c2 100644
--- a/docs/v12-migration.md
+++ b/docs/v12-migration.md
@@ -10,9 +10,12 @@ Then apply the v12 changes below.
 1. [Type exports moved to `@domstack/static/types.js`](#1-type-exports-moved-to-domstackstatictypesjs)
 2. [Development Server Uses @domstack/sync](#2-development-server-uses-domstacksync)
 3. [Default Layout Uses fragtml](#3-default-layout-uses-fragtml)
-4. [Keep Layout Dependencies Explicit](#4-keep-layout-dependencies-explicit)
-5. [JSX Runtime Is Opt-In](#5-jsx-runtime-is-opt-in)
-6. [Migration Checklist](#6-migration-checklist)
+4. [Layout Modules Can Export Vars](#4-layout-modules-can-export-vars)
+5. [Keep Layout Dependencies Explicit](#5-keep-layout-dependencies-explicit)
+6. [JSX Runtime Is Opt-In](#6-jsx-runtime-is-opt-in)
+7. [CLI `--target` moved to `esbuild.settings.*`](#7-cli---target-moved-to-esbuildsettings)
+8. [Static Cache Manifest and Service Worker Preview](#8-static-cache-manifest-and-service-worker-preview)
+9. [Migration Checklist](#9-migration-checklist)
 
 ---
 
@@ -72,7 +75,29 @@ Markdown output passed to a layout as `children` is one example.
 
 ---
 
-## 4. Keep Layout Dependencies Explicit
+## 4. Layout Modules Can Export Vars
+
+Layouts can now export optional `vars` that are merged into the resolved page variable cascade for pages using that layout. Like page/global vars, layout vars may be an object, a sync function, or an async function.
+
+```ts
+// src/layouts/article.layout.ts
+export const vars = {
+  showSidebar: true,
+  pageType: 'article',
+}
+```
+
+Precedence is:
+
+```txt
+page/frontmatter vars > page.vars.* > layout vars > global.data/global.vars > domstack defaults
+```
+
+This is additive for most sites. If a layout module already exported a named `vars` value for another purpose, that value will now participate in page variable resolution. Rename that export if it was not intended as layout defaults.
+
+---
+
+## 5. Keep Layout Dependencies Explicit
 
 DOMStack only installs dependencies for its bundled defaults.
 Your project is responsible for any packages imported by pages, layouts, globals, or browser clients.
@@ -82,7 +107,7 @@ If you migrate those server-side templates to `fragtml`, replace those dependenc
 
 ---
 
-## 5. JSX Runtime Is Opt-In
+## 6. JSX Runtime Is Opt-In
 
 Client `.jsx` and `.tsx` bundles are still supported through esbuild.
 Domstack no longer configures Preact as the default JSX runtime.
@@ -123,13 +148,204 @@ export default async function esbuildSettingsOverride (esbuildSettings) {
 
 ---
 
-## 6. Migration Checklist
+## 7. CLI `--target` moved to `esbuild.settings.*`
+
+The `domstack --target` / `domstack -t` CLI flag has been removed in v12. Configure esbuild targets in
+`esbuild.settings.*` instead.
+
+```js
+// src/esbuild.settings.js
+export default function esbuildSettings (opts) {
+  return {
+    ...opts,
+    target: ['es2022', 'chrome120', 'firefox121', 'safari17'],
+  }
+}
+```
+
+Domstack does not set a rolling “modern browser” target by default. If your project needs specific
+syntax lowering, set explicit esbuild targets in this settings file. See
+[esbuild's target docs](https://esbuild.github.io/api/#target) for accepted values.
+
+---
+
+## 8. Static Cache Manifest and Service Worker Preview
+
+v12 adds an unstable-preview manifest pipeline for static caching and first-class site service-worker builds.
+
+These APIs are preview APIs.
+Their names, option shapes, manifest schema, generated output, and runtime semantics may change outside of a major version while they are validated with real PWA use cases.
+Pin `@domstack/static` to an exact version if you rely on this contract.
+
+### Public manifest writing is opt-in
+
+The manifest pipeline can run without writing a public `domstack-manifest.json` file.
+This is useful when your app only needs the finalized manifest in a build hook to inject service-worker policy.
+
+Write the standard public manifest from the CLI with:
+
+```sh
+domstack --domstackManifest
+```
+
+Or write it from programmatic builds with:
+
+```js
+const site = new DomStack('src', 'public', {
+  domstackManifest: true,
+})
+```
+
+Use the object form when you also need filters, manifest vars, root policy, or hooks:
+
+```js
+const site = new DomStack('src', 'public', {
+  domstackManifest: {
+    write: true,
+    exclude: ['blog/**', '**/*.map'],
+    manifestVars: ['offline', 'precache'],
+    policy: {
+      offlineFallbackUrl: '/offline/',
+    },
+  },
+})
+```
+
+If `domstackManifest` is unset, Domstack skips the manifest pipeline unless a `domstack-manifest.settings.*` file exists.
+A settings file enables the pipeline, returns `results.domstackManifest`, and runs manifest hooks, but does not write a public JSON file unless writing is explicitly enabled.
+
+### Add manifest settings when you need cache policy
+
+Apps can add one `domstack-manifest.settings.*` file anywhere under `src`:
+
+```txt
+domstack-manifest.settings.js
+domstack-manifest.settings.mjs
+domstack-manifest.settings.cjs
+domstack-manifest.settings.ts
+domstack-manifest.settings.mts
+domstack-manifest.settings.cts
+```
+
+Use `manifestVars` to explicitly expose selected page, layout, global, or default vars on manifest entries.
+Use `policy` for root-level application policy.
+Use `includeEntry(entry)` and `exclude` to filter final public output entries.
+
+```ts
+import type { DomstackManifestOptions } from '@domstack/static/types.js'
+
+const settings = {
+  manifestVars: ['offline', 'precache'],
+  policy: {
+    offlineFallbackUrl: '/offline/',
+  },
+  exclude: ['admin/**', 'blog/**', '**/*.map'],
+  includeEntry (entry) {
+    if (entry.kind === 'metadata') return false
+    if (entry.kind === 'sourcemap') return false
+    if (entry.manifestVars?.offline === false) return false
+    if (entry.manifestVars?.precache === false) return false
+    return true
+  },
+} satisfies DomstackManifestOptions
+
+export default settings
+```
+
+### Prefer manifest hooks over runtime manifest fetches
+
+The primary service-worker integration point is `hooks.manifestBuilt`.
+This hook receives the finalized manifest before the final `/service-worker.js` bundle is emitted.
+Use `context.defineServiceWorkerConstant()` to inject JSON-serializable policy directly into the service-worker bundle.
+
+```ts
+import type {
+  DomstackManifestBuiltHookContext,
+} from '@domstack/static/types.js'
+
+export async function injectServiceWorkerPolicy (
+  context: DomstackManifestBuiltHookContext
+): Promise<void> {
+  context.defineServiceWorkerConstant('__APP_CACHE_POLICY__', {
+    version: context.manifest.version,
+    precacheEntries: context.manifest.entries.map(entry => ({
+      url: entry.url,
+      revision: entry.urlRevisioned ? null : entry.revision,
+    })),
+  })
+}
+```
+
+This avoids shipping a runtime manifest file just so a service worker can discover the build output list.
+If you intentionally need a public custom artifact, write it from the hook with `context.writeFile()`.
+
+### Add one site service worker when needed
+
+Domstack reserves one site service-worker source filename:
+
+```txt
+service-worker.js
+service-worker.mjs
+service-worker.cjs
+service-worker.ts
+service-worker.mts
+service-worker.cts
+```
+
+The source may live anywhere under `src`, but only one is allowed.
+Domstack bundles it to a stable root output path:
+
+```txt
+/service-worker.js
+```
+
+Domstack does not register the service worker for you.
+Your app owns registration timing, update prompts, local-development opt-outs, reset/recovery behavior, route filtering, offline fallback behavior, and runtime cache policy.
+
+The service worker can read Domstack's build-time browser defines:
+
+| Define | Value |
+| --- | --- |
+| `process.env.DOMSTACK_MANIFEST_URL` | Standard public URL for the built-in manifest, `/domstack-manifest.json` |
+| `process.env.DOMSTACK_MANIFEST_VERSION` | Finalized manifest version in `/service-worker.js`; `""` in other bundles |
+| `process.env.DOMSTACK_MANIFEST_ENABLED` | `"true"` for one-shot builds with an enabled manifest pipeline, `"false"` when disabled or in watch mode |
+| `process.env.DOMSTACK_SERVICE_WORKER_URL` | Public URL of the site service worker, usually `/service-worker.js`, or `""` when no service worker is present |
+| `process.env.DOMSTACK_SERVICE_WORKER_SCOPE` | Registration scope for the site service worker, usually `/`, or `""` when no service worker is present |
+
+### Use `--serve` for PWA testing
+
+Watch mode intentionally does not write or return the domstack manifest.
+It still rebuilds the site service worker, but watch-mode output is not representative of production cache invalidation.
+
+Use `--serve` when testing PWA install/update/offline lifecycle behavior:
+
+```sh
+domstack --serve
+```
+
+Add `--domstackManifest` only if you also want to serve the public `domstack-manifest.json` file while debugging:
+
+```sh
+domstack --serve --domstackManifest
+```
+
+### Avoid circular manifest dependencies
+
+The built-in manifest file is never included in its own `entries`.
+Site service workers are also omitted from manifest entries.
+This lets Domstack inject the finalized `manifest.version` into `/service-worker.js` without making the manifest hash depend on the service-worker hash.
+
+---
+
+## 9. Migration Checklist
 
 - [ ] If you import public types from `@domstack/static`, update those imports to `@domstack/static/types.js`.
 - [ ] If you rely on BrowserSync-specific dev-server behavior, test watch mode with `@domstack/sync`.
 - [ ] If you rely on the bundled default layout, make sure pages and child layouts return HTML strings or `fragtml` template results, not Preact or HTM VNodes.
+- [ ] If any layout module already exports a named `vars` value, confirm it should now act as layout defaults.
 - [ ] If you want to keep the v11 Preact default layout, eject on v11 before upgrading to v12.
 - [ ] If your ejected layout or server-side pages still import `htm/preact`, `preact`, or `preact-render-to-string`, keep those dependencies in your own `package.json`.
 - [ ] If you want your ejected server-side layout to match the v12 default, migrate its templates to `fragtml` and install `fragtml`.
 - [ ] If you use `.jsx` or `.tsx` browser clients, add an `esbuild.settings` file that configures your JSX runtime.
+- [ ] If you use `domstack --target` or `domstack -t`, move that target list to `esbuild.settings.*`.
 - [ ] If you use Preact browser clients, keep `preact` in your project dependencies.
diff --git a/eslint.config.js b/eslint.config.js
index caf35f01..cd55418b 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -2,6 +2,7 @@ import neostandard, { resolveIgnoresFromGitignore } from 'neostandard'
 
 export default neostandard({
   env: ['browser'],
+  ts: true,
   ignores: [
     ...resolveIgnoresFromGitignore(),
     'test-cases/build-errors/src/**/*.js',
diff --git a/examples/basic/package.json b/examples/basic/package.json
index 0c33dec8..c6e3ca68 100644
--- a/examples/basic/package.json
+++ b/examples/basic/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "basic",
+  "name": "@domstack/basic-example",
   "version": "0.0.0",
   "description": "",
   "type": "module",
@@ -14,14 +14,17 @@
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
   "license": "MIT",
   "devDependencies": {
-    "npm-run-all2": "^6.0.0",
-    "typescript": "~5.8.2",
-    "@voxpelli/tsconfig": "^15.0.0"
+    "npm-run-all2": "^9.0.2",
+    "typescript": "~6.0.3",
+    "@voxpelli/tsconfig": "^16.2.1"
   },
   "dependencies": {
     "@domstack/static": "file:../../.",
     "fragtml": "^0.0.9",
-    "mine.css": "^9.0.1",
+    "mine.css": "^10.0.3",
     "highlight.js": "^11.9.0"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/basic/src/js-page/loose-assets/shared-lib.ts b/examples/basic/src/js-page/loose-assets/shared-lib.ts
index f8cf09d1..571df0c5 100644
--- a/examples/basic/src/js-page/loose-assets/shared-lib.ts
+++ b/examples/basic/src/js-page/loose-assets/shared-lib.ts
@@ -9,4 +9,4 @@ const sharedLib: SharedData = {
   shared: 'data',
 }
 
-export default sharedLib;
+export default sharedLib
diff --git a/examples/blog/package.json b/examples/blog/package.json
index 468ec337..a9017d14 100644
--- a/examples/blog/package.json
+++ b/examples/blog/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "blog",
+  "name": "@domstack/blog-example",
   "version": "0.0.0",
   "description": "A blog example for domstack demonstrating global.data.ts, nested layouts, and feeds.",
   "type": "module",
@@ -14,12 +14,15 @@
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
   "license": "MIT",
   "devDependencies": {
-    "@voxpelli/tsconfig": "^16.0.0",
-    "typescript": "~5.9.2"
+    "@voxpelli/tsconfig": "^16.2.1",
+    "typescript": "~6.0.3"
   },
   "dependencies": {
     "@domstack/static": "file:../../.",
     "fragtml": "^0.0.9",
-    "mine.css": "^10.0.0"
+    "mine.css": "^10.0.3"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/blog/src/layouts/post.layout.ts b/examples/blog/src/layouts/post.layout.ts
index cd1924c7..703f573b 100644
--- a/examples/blog/src/layouts/post.layout.ts
+++ b/examples/blog/src/layouts/post.layout.ts
@@ -43,29 +43,35 @@ const postLayout: LayoutFunction<PostVars, string | HtmlResult, string> = (args)
           </address>
 
           ${/* Publish date */''}
-          ${publishDate ? html`
+          ${publishDate
+? html`
             <time class="dt-published post-date" itemprop="datePublished"
               datetime="${publishDate.toISOString()}">
               ${publishDate.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' })}
             </time>
-          ` : null}
+          `
+: null}
 
           ${/* Updated date */''}
-          ${updatedDate ? html`
+          ${updatedDate
+? html`
             <time class="dt-updated post-updated" itemprop="dateModified"
               datetime="${updatedDate.toISOString()}">
               Updated ${updatedDate.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' })}
             </time>
-          ` : null}
+          `
+: null}
 
           ${/* Tags */''}
-          ${vars.tags && vars.tags.length > 0 ? html`
+          ${vars.tags && vars.tags.length > 0
+? html`
             <ul class="post-tags">
               ${vars.tags.map(tag => html`
                 <li><span class="p-category post-tag">${tag}</span></li>
               `)}
             </ul>
-          ` : null}
+          `
+: null}
 
         </div>
       </header>
diff --git a/examples/css-modules/package.json b/examples/css-modules/package.json
index 7a9b8ebb..e5291965 100644
--- a/examples/css-modules/package.json
+++ b/examples/css-modules/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@domstack/preact-example",
+  "name": "@domstack/css-modules-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -11,15 +11,18 @@
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
   "license": "MIT",
   "dependencies": {
-    "@preact/signals": "^2.0.0",
+    "@preact/signals": "^2.9.3",
     "highlight.js": "^11.9.0",
     "htm": "^3.1.1",
-    "mine.css": "^9.0.1",
-    "preact": "^10.24.0",
+    "mine.css": "^10.0.3",
+    "preact": "^10.29.6",
     "preact-render-to-string": "^6.5.11",
     "@domstack/static": "file:../../."
   },
   "devDependencies": {
-    "npm-run-all2": "^6.0.0"
+    "npm-run-all2": "^9.0.2"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/default-layout/package.json b/examples/default-layout/package.json
index 8933b848..920ac3c5 100644
--- a/examples/default-layout/package.json
+++ b/examples/default-layout/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "default-layout",
+  "name": "@domstack/default-layout-example",
   "version": "0.0.0",
   "description": "",
   "main": "index.js",
@@ -14,5 +14,8 @@
   },
   "keywords": [],
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
-  "license": "MIT"
+  "license": "MIT",
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
+  }
 }
diff --git a/examples/esbuild-settings/package.json b/examples/esbuild-settings/package.json
index eb9ec3cc..0a03aa0b 100644
--- a/examples/esbuild-settings/package.json
+++ b/examples/esbuild-settings/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@domstack/preact-example",
+  "name": "@domstack/esbuild-settings-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -15,6 +15,9 @@
   },
   "devDependencies": {
     "esbuild-plugin-polyfill-node": "^0.3.0",
-    "npm-run-all2": "^6.0.0"
+    "npm-run-all2": "^9.0.2"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/markdown-settings/package.json b/examples/markdown-settings/package.json
index 563782ab..1e0192ba 100644
--- a/examples/markdown-settings/package.json
+++ b/examples/markdown-settings/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "markdown-settings-example",
+  "name": "@domstack/markdown-settings-example",
   "version": "1.0.0",
   "description": "Example demonstrating markdown-it.settings.js usage",
   "type": "module",
@@ -14,5 +14,8 @@
     "markdown-it-container": "^4.0.0",
     "markdown-it-admonition": "1.0.4",
     "highlight.js": "^11.9.0"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/markdown-settings/src/markdown-it.settings.js b/examples/markdown-settings/src/markdown-it.settings.js
index 542f4df1..15855c85 100644
--- a/examples/markdown-settings/src/markdown-it.settings.js
+++ b/examples/markdown-settings/src/markdown-it.settings.js
@@ -1,4 +1,6 @@
 /**
+ * @import MarkdownIt from 'markdown-it'
+ *
  * Custom Markdown-it Configuration
  *
  * This file demonstrates how to extend DOMStack's markdown rendering
@@ -44,8 +46,8 @@ function createContainer (name, defaultTitle, cssClass) {
 /**
  * Customize the markdown-it instance with additional plugins and renderers
  *
- * @param {import('markdown-it')} md - The markdown-it instance
- * @returns {import('markdown-it')} - The modified markdown-it instance
+ * @param {MarkdownIt} md - The markdown-it instance
+ * @returns {Promise<MarkdownIt>} - The modified markdown-it instance
  */
 export default async function markdownItSettingsOverride (md) {
   // =====================================================
diff --git a/examples/nested-dest/package.json b/examples/nested-dest/package.json
index 5b42a6ae..de6f0781 100644
--- a/examples/nested-dest/package.json
+++ b/examples/nested-dest/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "nested-dest",
+  "name": "@domstack/nested-dest-example",
   "version": "0.0.0",
   "description": "",
   "type": "module",
@@ -15,9 +15,12 @@
   "license": "MIT",
   "dependencies": {
     "@domstack/static": "file:../../.",
-    "mine.css": "^9.0.1"
+    "mine.css": "^10.0.3"
   },
   "devDependencies": {
-    "npm-run-all2": "^6.0.0"
+    "npm-run-all2": "^9.0.2"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/preact-isomorphic/package.json b/examples/preact-isomorphic/package.json
index f5ce3582..3a93adcd 100644
--- a/examples/preact-isomorphic/package.json
+++ b/examples/preact-isomorphic/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@domstack/preact-example",
+  "name": "@domstack/preact-isomorphic-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -11,17 +11,20 @@
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
   "license": "MIT",
   "dependencies": {
-    "@preact/signals": "^2.0.0",
+    "@preact/signals": "^2.9.3",
     "highlight.js": "^11.9.0",
     "htm": "^3.1.1",
-    "mine.css": "^9.0.1",
-    "preact": "^10.24.0",
+    "mine.css": "^10.0.3",
+    "preact": "^10.29.6",
     "preact-render-to-string": "^6.5.11",
     "@domstack/static": "file:../../."
   },
   "devDependencies": {
-    "@voxpelli/tsconfig": "^15.0.0",
-    "npm-run-all2": "^6.0.0",
-    "typescript": "~5.8.2"
+    "@voxpelli/tsconfig": "^16.2.1",
+    "npm-run-all2": "^9.0.2",
+    "typescript": "~6.0.3"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/preact-isomorphic/src/isomorphic/client.ts b/examples/preact-isomorphic/src/isomorphic/client.ts
index 026ab90d..2f9f0961 100644
--- a/examples/preact-isomorphic/src/isomorphic/client.ts
+++ b/examples/preact-isomorphic/src/isomorphic/client.ts
@@ -7,11 +7,11 @@
  *
  * It uses the same component code for both environments.
  */
-import { html, Component } from 'htm/preact';
-import { render } from 'preact';
-import { useCallback } from 'preact/hooks';
-import { useSignal, useComputed } from '@preact/signals';
-import type { ComponentChildren, JSX } from 'preact';
+import { html, Component } from 'htm/preact'
+import { render } from 'preact'
+import { useCallback } from 'preact/hooks'
+import { useSignal, useComputed } from '@preact/signals'
+import type { JSX } from 'preact'
 
 /**
  * Header component props
@@ -30,7 +30,7 @@ const Header = ({ name, subtitle }: HeaderProps): JSX.Element => html`
     <h1>${name}</h1>
     ${subtitle && html`<p class="subtitle">${subtitle}</p>`}
   </header>
-`;
+`
 
 /**
  * Todo item props
@@ -58,7 +58,7 @@ const TodoItem = ({ text, completed, onToggle, onDelete }: TodoItemProps): JSX.E
     </label>
     <button class="delete-btn" onClick=${onDelete}>Delete</button>
   </li>
-`;
+`
 
 /**
  * Counter Component using Signals
@@ -66,16 +66,16 @@ const TodoItem = ({ text, completed, onToggle, onDelete }: TodoItemProps): JSX.E
  */
 const Counter = (): JSX.Element => {
   // Create a signal for the count value
-  const count = useSignal(0);
+  const count = useSignal(0)
 
   // Derived state that automatically updates when count changes
-  const doubled = useComputed(() => count.value * 2);
-  const isEven = useComputed(() => count.value % 2 === 0);
+  const doubled = useComputed(() => count.value * 2)
+  const isEven = useComputed(() => count.value % 2 === 0)
 
   // Event handlers
-  const increment = useCallback(() => { count.value++; }, []);
-  const decrement = useCallback(() => { count.value > 0 && count.value--; }, []);
-  const reset = useCallback(() => { count.value = 0; }, []);
+  const increment = useCallback(() => { count.value++ }, [])
+  const decrement = useCallback(() => { count.value > 0 && count.value-- }, [])
+  const reset = useCallback(() => { count.value = 0 }, [])
 
   return html`
     <div class="counter-widget">
@@ -90,8 +90,8 @@ const Counter = (): JSX.Element => {
         <button onClick=${increment}>+</button>
       </div>
     </div>
-  `;
-};
+  `
+}
 
 /**
  * Todo item structure
@@ -122,8 +122,8 @@ interface TodoAppState {
  * Manages a list of todos with add/toggle/delete functionality
  */
 class TodoApp extends Component<TodoAppProps, TodoAppState> {
-  constructor(props: TodoAppProps) {
-    super(props);
+  constructor (props: TodoAppProps) {
+    super(props)
     // Initialize with example todos
     this.state = {
       todos: [
@@ -132,18 +132,18 @@ class TodoApp extends Component<TodoAppProps, TodoAppState> {
         { id: 3, text: 'Deploy to production', completed: false }
       ],
       newTodo: ''
-    };
+    }
   }
 
   // Update the new todo input value
   updateNewTodo = (e: JSX.TargetedEvent<HTMLInputElement>): void => {
-    this.setState({ newTodo: e.currentTarget.value });
-  };
+    this.setState({ newTodo: e.currentTarget.value })
+  }
 
   // Add a new todo item
   addTodo = (e: JSX.TargetedEvent<HTMLFormElement>): void => {
-    e.preventDefault();
-    const { todos, newTodo } = this.state;
+    e.preventDefault()
+    const { todos, newTodo } = this.state
 
     if (newTodo.trim()) {
       this.setState({
@@ -156,32 +156,32 @@ class TodoApp extends Component<TodoAppProps, TodoAppState> {
           }
         ],
         newTodo: ''
-      });
+      })
     }
-  };
+  }
 
   // Toggle a todo's completion status
   toggleTodo = (id: number): void => {
-    const { todos } = this.state;
+    const { todos } = this.state
     this.setState({
       todos: todos.map(todo =>
         todo.id === id
           ? { ...todo, completed: !todo.completed }
           : todo
       )
-    });
-  };
+    })
+  }
 
   // Delete a todo item
   deleteTodo = (id: number): void => {
-    const { todos } = this.state;
+    const { todos } = this.state
     this.setState({
       todos: todos.filter(todo => todo.id !== id)
-    });
-  };
+    })
+  }
 
-  render({ title }: TodoAppProps, { todos, newTodo }: TodoAppState): JSX.Element {
-    const remaining = todos.filter(todo => !todo.completed).length;
+  render ({ title }: TodoAppProps, { todos, newTodo }: TodoAppState): JSX.Element {
+    const remaining = todos.filter(todo => !todo.completed).length
 
     return html`
       <div class="todo-app">
@@ -218,7 +218,7 @@ class TodoApp extends Component<TodoAppProps, TodoAppState> {
 
         <${Counter} />
       </div>
-    `;
+    `
   }
 }
 
@@ -242,7 +242,7 @@ export const page = (): JSX.Element => html`
       </p>
     </div>
   </div>
-`;
+`
 
 /**
  * Client-side only code
@@ -250,11 +250,11 @@ export const page = (): JSX.Element => html`
  */
 if (typeof window !== 'undefined') {
   // Find the container that was server-rendered
-  const renderTarget = document.querySelector('.app-main');
+  const renderTarget = document.querySelector('.app-main')
 
   // Hydrate the existing HTML with interactive components
   if (renderTarget) {
-    render(page(), renderTarget);
-    console.log('✅ Preact isomorphic app successfully hydrated');
+    render(page(), renderTarget)
+    console.log('✅ Preact isomorphic app successfully hydrated')
   }
 }
diff --git a/examples/preact-isomorphic/src/isomorphic/page.ts b/examples/preact-isomorphic/src/isomorphic/page.ts
index 6ce07734..210c52d7 100644
--- a/examples/preact-isomorphic/src/isomorphic/page.ts
+++ b/examples/preact-isomorphic/src/isomorphic/page.ts
@@ -1,6 +1,6 @@
-import { page } from './client.ts';
-import type { JSX } from 'preact';
+import { page } from './client.ts'
+import type { JSX } from 'preact'
 
-export default function(): JSX.Element {
-  return page();
+export default function (): JSX.Element {
+  return page()
 }
diff --git a/examples/preact-isomorphic/src/layouts/root.layout.ts b/examples/preact-isomorphic/src/layouts/root.layout.ts
index e4a03d6a..3aaf3829 100644
--- a/examples/preact-isomorphic/src/layouts/root.layout.ts
+++ b/examples/preact-isomorphic/src/layouts/root.layout.ts
@@ -1,6 +1,6 @@
-import { html } from 'htm/preact';
-import { render } from 'preact-render-to-string';
-import type { VNode } from 'preact';
+import { html } from 'htm/preact'
+import { render } from 'preact-render-to-string'
+import type { VNode } from 'preact'
 
 /**
  * Page variables that can be passed to the layout
@@ -27,12 +27,12 @@ export interface LayoutProps<T> {
 /**
  * Type definition for layout functions
  */
-export type LayoutFunction<T> = (props: LayoutProps<T>) => string;
+export type LayoutFunction<T> = (props: LayoutProps<T>) => string
 
 /**
  * Build all of the bundles using esbuild.
  */
-export default function defaultRootLayout({
+export default function defaultRootLayout ({
   vars: {
     title,
     siteName = 'Domstack',
@@ -70,5 +70,5 @@ export default function defaultRootLayout({
         </body>
       `)}
     </html>
-  `;
+  `
 }
diff --git a/examples/react/package.json b/examples/react/package.json
index a4d06664..2abed9cf 100644
--- a/examples/react/package.json
+++ b/examples/react/package.json
@@ -14,16 +14,19 @@
   "dependencies": {
     "@domstack/static": "file:../../.",
     "htm": "^3.1.1",
-    "mine.css": "^9.0.1",
+    "mine.css": "^10.0.3",
     "react": "^19.1.1"
   },
   "devDependencies": {
     "@types/react": "^19.1.10",
     "@types/react-dom": "^19.1.7",
-    "@voxpelli/tsconfig": "^15.0.0",
-    "npm-run-all2": "^6.0.0",
+    "@voxpelli/tsconfig": "^16.2.1",
+    "npm-run-all2": "^9.0.2",
     "react-dom": "^19.1.1",
-    "typescript": "~5.8.2",
+    "typescript": "~6.0.3",
     "highlight.js": "^11.9.0"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/react/src/globals/esbuild.settings.ts b/examples/react/src/globals/esbuild.settings.ts
index d164d593..e7fddfce 100644
--- a/examples/react/src/globals/esbuild.settings.ts
+++ b/examples/react/src/globals/esbuild.settings.ts
@@ -11,7 +11,7 @@ import type { BuildOptions } from 'esbuild'
  * @param esbuildSettings - The default ESBuild configuration
  * @returns The modified ESBuild configuration
  */
-export default async function esbuildSettingsOverride(esbuildSettings: BuildOptions): Promise<BuildOptions> {
+export default async function esbuildSettingsOverride (esbuildSettings: BuildOptions): Promise<BuildOptions> {
   // Use React's automatic JSX runtime.
   esbuildSettings.jsx = 'automatic'
   esbuildSettings.jsxImportSource = 'react'
diff --git a/examples/react/src/globals/global.client.ts b/examples/react/src/globals/global.client.ts
index 782a44d7..5380f593 100644
--- a/examples/react/src/globals/global.client.ts
+++ b/examples/react/src/globals/global.client.ts
@@ -1,6 +1,8 @@
+/// <reference lib="dom" />
+
 /**
  * Global client-side TypeScript for React example
- * 
+ *
  * This file is loaded on all pages before any page-specific TypeScript.
  * It's a good place to add global event listeners, polyfills, or
  * other initialization code that should run on every page.
@@ -12,18 +14,17 @@ interface DomstackUtils {
   getRandomItem<T>(array: T[]): T;
 }
 
-// Extend the Window interface to include our global utilities
-interface Window {
-  domstackUtils: DomstackUtils;
+const globalWindow = window as Window & {
+  domstackUtils?: DomstackUtils
 }
 
-console.log('React example global client TypeScript loaded');
+console.log('React example global client TypeScript loaded')
 
 // Add a class to indicate JavaScript is enabled
-document.documentElement.classList.add('js-enabled');
+document.documentElement.classList.add('js-enabled')
 
 // Basic example of a global utility function
-window.domstackUtils = {
+globalWindow.domstackUtils = {
   /**
    * Format a date in a human-readable format
    * @param date - The date to format
@@ -35,9 +36,9 @@ window.domstackUtils = {
       year: 'numeric',
       month: 'long',
       day: 'numeric'
-    }).format(date);
+    }).format(date)
   },
-  
+
   /**
    * Get a random item from an array
    * @param array - The array to get a random item from
@@ -45,32 +46,32 @@ window.domstackUtils = {
    */
   getRandomItem: <T>(array: T[]): T => {
     if (array.length === 0) {
-      throw new Error("Cannot get random item from empty array");
+      throw new Error('Cannot get random item from empty array')
     }
-    const index = Math.floor(Math.random() * array.length);
+    const index = Math.floor(Math.random() * array.length)
     // This assertion is safe because we've checked that array is not empty
-    return array[index] as T;
+    return array[index] as T
   }
-};
+}
 
 // Add dark mode detection
-const prefersDarkMode: MediaQueryList = window.matchMedia('(prefers-color-scheme: dark)');
+const prefersDarkMode: MediaQueryList = window.matchMedia('(prefers-color-scheme: dark)')
 if (prefersDarkMode.matches) {
-  document.body.classList.add('dark-mode-preferred');
+  document.body.classList.add('dark-mode-preferred')
 }
 
 // Listen for dark mode changes
 prefersDarkMode.addEventListener('change', (e: MediaQueryListEvent): void => {
   if (e.matches) {
-    document.body.classList.add('dark-mode-preferred');
+    document.body.classList.add('dark-mode-preferred')
   } else {
-    document.body.classList.remove('dark-mode-preferred');
+    document.body.classList.remove('dark-mode-preferred')
   }
-});
+})
 
 // Example of measuring and logging performance
-const pageLoadTime: number = performance.now();
+const pageLoadTime: number = performance.now()
 window.addEventListener('load', (): void => {
-  const totalLoadTime: number = performance.now() - pageLoadTime;
-  console.log(`Page fully loaded in ${totalLoadTime.toFixed(2)}ms`);
-});
\ No newline at end of file
+  const totalLoadTime: number = performance.now() - pageLoadTime
+  console.log(`Page fully loaded in ${totalLoadTime.toFixed(2)}ms`)
+})
diff --git a/examples/react/src/layouts/root.layout.ts b/examples/react/src/layouts/root.layout.ts
index a06208eb..f2611a17 100644
--- a/examples/react/src/layouts/root.layout.ts
+++ b/examples/react/src/layouts/root.layout.ts
@@ -22,7 +22,7 @@ interface LayoutProps {
  * React components will be mounted client-side after the page loads.
  * Uses React DOM Server for server-side rendering.
  */
-export default function rootLayout({
+export default function rootLayout ({
   vars: {
     title,
     siteName = 'React TypeScript Example',
diff --git a/examples/react/src/react-page/client.tsx b/examples/react/src/react-page/client.tsx
index 03ffada9..2fed2fc3 100644
--- a/examples/react/src/react-page/client.tsx
+++ b/examples/react/src/react-page/client.tsx
@@ -1,5 +1,5 @@
-import React, { useState, useEffect } from 'react';
-import { createRoot } from 'react-dom/client';
+import React, { useState, useEffect } from 'react'
+import { createRoot } from 'react-dom/client'
 
 // Type definitions
 interface CounterProps {
@@ -8,25 +8,25 @@ interface CounterProps {
 }
 
 // Simple counter component with React hooks
-const Counter: React.FC<CounterProps> = ({ initialValue = 0, label = "Counter Component" }) => {
-  const [count, setCount] = useState<number>(initialValue);
-  
-  const increment = (): void => setCount(count + 1);
-  const decrement = (): void => { if (count > 0) setCount(count - 1); };
-  const reset = (): void => setCount(0);
-  
+const Counter: React.FC<CounterProps> = ({ initialValue = 0, label = 'Counter Component' }) => {
+  const [count, setCount] = useState<number>(initialValue)
+
+  const increment = (): void => setCount(count + 1)
+  const decrement = (): void => { if (count > 0) setCount(count - 1) }
+  const reset = (): void => setCount(0)
+
   return (
-    <div className="card">
+    <div className='card'>
       <h3>{label}</h3>
       <p>Current count: <strong>{count}</strong></p>
-      <div className="button-group">
-        <button className="button" onClick={decrement}>-</button>
-        <button className="button" onClick={reset}>Reset</button>
-        <button className="button" onClick={increment}>+</button>
+      <div className='button-group'>
+        <button className='button' onClick={decrement}>-</button>
+        <button className='button' onClick={reset}>Reset</button>
+        <button className='button' onClick={increment}>+</button>
       </div>
     </div>
-  );
-};
+  )
+}
 
 interface ThemeToggleProps {
   defaultDark?: boolean;
@@ -34,29 +34,29 @@ interface ThemeToggleProps {
 
 // Color theme toggle component
 const ThemeToggle: React.FC<ThemeToggleProps> = ({ defaultDark = false }) => {
-  const [isDark, setIsDark] = useState<boolean>(defaultDark);
-  
+  const [isDark, setIsDark] = useState<boolean>(defaultDark)
+
   useEffect((): void => {
     if (isDark) {
-      document.body.classList.add('dark-theme');
+      document.body.classList.add('dark-theme')
     } else {
-      document.body.classList.remove('dark-theme');
+      document.body.classList.remove('dark-theme')
     }
-  }, [isDark]);
-  
+  }, [isDark])
+
   return (
-    <div className="card">
+    <div className='card'>
       <h3>Theme Toggle</h3>
       <p>Current theme: <strong>{isDark ? 'Dark' : 'Light'}</strong></p>
-      <button 
-        className="button"
+      <button
+        className='button'
         onClick={(): void => setIsDark(!isDark)}
       >
         Switch to {isDark ? 'Light' : 'Dark'} Theme
       </button>
     </div>
-  );
-};
+  )
+}
 
 interface FormData {
   name: string;
@@ -70,125 +70,127 @@ const SimpleForm: React.FC = () => {
     name: '',
     email: '',
     feedback: ''
-  });
-  const [isSubmitted, setIsSubmitted] = useState<boolean>(false);
-  
+  })
+  const [isSubmitted, setIsSubmitted] = useState<boolean>(false)
+
   const handleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
-    const { name, value } = e.target;
+    const { name, value } = e.target
     setFormData(prev => ({
       ...prev,
       [name]: value
-    }));
-  };
-  
+    }))
+  }
+
   const handleSubmit = (e: React.FormEvent<HTMLFormElement>): void => {
-    e.preventDefault();
-    console.log('Form submitted:', formData);
-    setIsSubmitted(true);
-    
+    e.preventDefault()
+    console.log('Form submitted:', formData)
+    setIsSubmitted(true)
+
     // Reset form after 3 seconds
     setTimeout((): void => {
-      setIsSubmitted(false);
+      setIsSubmitted(false)
       setFormData({
         name: '',
         email: '',
         feedback: ''
-      });
-    }, 3000);
-  };
-  
+      })
+    }, 3000)
+  }
+
   return (
-    <div className="card">
+    <div className='card'>
       <h3>Simple Form</h3>
-      
-      {isSubmitted ? (
-        <div className="success-message">
-          <p>Thanks for your feedback, {formData.name}!</p>
-          <p>We'll be in touch at {formData.email}</p>
-        </div>
-      ) : (
-        <form onSubmit={handleSubmit}>
-          <div>
-            <label htmlFor="name">Name</label>
-            <input
-              type="text"
-              id="name"
-              name="name"
-              value={formData.name}
-              onChange={handleChange}
-              required
-            />
-          </div>
-          
-          <div>
-            <label htmlFor="email">Email</label>
-            <input
-              type="email"
-              id="email"
-              name="email"
-              value={formData.email}
-              onChange={handleChange}
-              required
-            />
-          </div>
-          
-          <div>
-            <label htmlFor="feedback">Feedback</label>
-            <textarea
-              id="feedback"
-              name="feedback"
-              value={formData.feedback}
-              onChange={handleChange}
-              rows={3}
-              required
-            />
+
+      {isSubmitted
+        ? (
+          <div className='success-message'>
+            <p>Thanks for your feedback, {formData.name}!</p>
+            <p>We'll be in touch at {formData.email}</p>
           </div>
-          
-          <button type="submit" className="button">Submit Feedback</button>
-        </form>
-      )}
+          )
+        : (
+          <form onSubmit={handleSubmit}>
+            <div>
+              <label htmlFor='name'>Name</label>
+              <input
+                type='text'
+                id='name'
+                name='name'
+                value={formData.name}
+                onChange={handleChange}
+                required
+              />
+            </div>
+
+            <div>
+              <label htmlFor='email'>Email</label>
+              <input
+                type='email'
+                id='email'
+                name='email'
+                value={formData.email}
+                onChange={handleChange}
+                required
+              />
+            </div>
+
+            <div>
+              <label htmlFor='feedback'>Feedback</label>
+              <textarea
+                id='feedback'
+                name='feedback'
+                value={formData.feedback}
+                onChange={handleChange}
+                rows={3}
+                required
+              />
+            </div>
+
+            <button type='submit' className='button'>Submit Feedback</button>
+          </form>
+          )}
     </div>
-  );
-};
+  )
+}
 
 interface AppProps {
   title?: string;
 }
 
 // Main App component
-const App: React.FC<AppProps> = ({ title = "React Client-Side Rendering" }) => {
-  const [time, setTime] = useState<Date>(new Date());
-  
+const App: React.FC<AppProps> = ({ title = 'React Client-Side Rendering' }) => {
+  const [time, setTime] = useState<Date>(new Date())
+
   // Update time every second
   useEffect((): (() => void) => {
     const timer = setInterval((): void => {
-      setTime(new Date());
-    }, 1000);
-    
-    return (): void => clearInterval(timer);
-  }, []);
-  
+      setTime(new Date())
+    }, 1000)
+
+    return (): void => clearInterval(timer)
+  }, [])
+
   return (
-    <div className="react-demo">
-      <div className="react-header">
-        <img 
-          src="https://reactjs.org/logo-og.png" 
-          alt="React logo" 
-          className="react-logo"
-          width="40"
-          height="40"
+    <div className='react-demo'>
+      <div className='react-header'>
+        <img
+          src='https://reactjs.org/logo-og.png'
+          alt='React logo'
+          className='react-logo'
+          width='40'
+          height='40'
         />
         <h2>{title}</h2>
       </div>
-      
+
       <p>This component is rendered exclusively on the client-side using React with TypeScript.</p>
       <p>Current time: {time.toLocaleTimeString()}</p>
-      
-      <Counter initialValue={5} label="TypeScript Counter" />
+
+      <Counter initialValue={5} label='TypeScript Counter' />
       <ThemeToggle defaultDark={false} />
       <SimpleForm />
-      
-      <div className="info-panel">
+
+      <div className='info-panel'>
         <h3>About This Example</h3>
         <p>
           This example demonstrates how to use React with TypeScript in DOMStack by configuring
@@ -199,14 +201,14 @@ const App: React.FC<AppProps> = ({ title = "React Client-Side Rendering" }) => {
         </p>
       </div>
     </div>
-  );
-};
+  )
+}
 
 // Mount the React app when the DOM is ready
 document.addEventListener('DOMContentLoaded', (): void => {
-  const container: HTMLElement | null = document.getElementById('react-root');
+  const container: HTMLElement | null = document.getElementById('react-root')
   if (container) {
-    const root = createRoot(container);
-    root.render(<App title="React + TypeScript Client-Side Rendering" />);
+    const root = createRoot(container)
+    root.render(<App title='React + TypeScript Client-Side Rendering' />)
   }
-});
\ No newline at end of file
+})
diff --git a/examples/static-mpa-offline/DESIGN.md b/examples/static-mpa-offline/DESIGN.md
new file mode 100644
index 00000000..b529849c
--- /dev/null
+++ b/examples/static-mpa-offline/DESIGN.md
@@ -0,0 +1,132 @@
+# Static MPA Offline Service Worker Design Notes
+
+## Status
+
+These notes describe the current vanilla offline service-worker example in `examples/static-mpa-offline`.
+
+The example is intentionally small and does not use Workbox at runtime.
+It still borrows Workbox's useful mental model: build a manifest from emitted files, precache revisioned assets during `install`, clean old cache entries during `activate`, and use a deliberate update UX.
+
+## Current architecture
+
+Domstack builds a stable root service worker at `/service-worker.js`.
+The service worker is omitted from the Domstack manifest so its own output does not create a manifest/hash cycle.
+After the final manifest is built, `hooks.manifestBuilt` injects the manifest-derived policy into the final service-worker bundle with `defineServiceWorkerConstant()`.
+
+The service worker does not fetch `/domstack-manifest.json` at runtime.
+The example also does not emit a separate service-worker policy JSON file.
+
+The injected policy keeps the Domstack manifest entry shape:
+
+```ts
+type StaticMpaOfflineServiceWorkerPolicy = {
+  version: string
+  entries: DomstackManifestEntry<StaticMpaOfflineManifestVars>[]
+  offlineFallbackUrl: string
+}
+```
+
+That lets the worker derive cache behavior from the same fields the manifest already owns:
+
+- `entry.url`
+- `entry.revision`
+- `entry.urlRevisioned`
+- `entry.integrity`
+- `entry.bytes`
+- `entry.kind`
+- `entry.role`
+- `entry.static`
+- `entry.manifestVars`
+
+## Manifest vars and policy
+
+The app exposes two page/layout vars to the manifest:
+
+```ts
+manifestVars: ['offline', 'precache']
+```
+
+The variable cascade is page → layout → global → default.
+Layout modules use this to define route-section defaults.
+Page vars or frontmatter can override those defaults for a single page.
+
+The root app policy carries the single offline fallback route:
+
+```ts
+policy: {
+  offlineFallbackUrl: '/offline/',
+}
+```
+
+The worker uses that route for failed offline navigations.
+It does not need per-route fallback target metadata.
+
+## Cache model
+
+The worker uses a stable precache cache name and revisioned cache keys.
+Unhashed URLs get a `?__DOMSTACK_REVISION__=<revision>` cache key.
+Hashed URLs can use their URL as the cache key because the URL already changes when contents change.
+
+The worker uses a separate runtime cache for progressive-cache pages.
+Pages with `offline: true` and `precache: false` are not install-cached.
+They become available offline after their first successful online visit.
+
+Chunks are precached in production builds so dynamic imports used by cached pages stay available offline.
+Watch builds disable splitting so the watch-mode service worker remains self-contained.
+
+## Watch mode
+
+Watch mode is for editing, not offline testing.
+A watch build does not inject the production policy constant.
+When the watch worker sees that no policy was injected, it skips caching, unregisters itself, and clears this example's caches.
+The browser client also unregisters existing workers and clears owned caches when running in watch mode.
+
+Use `npm --workspace @domstack/static-mpa-offline-example run serve` for offline-cache testing.
+
+## Update lifecycle
+
+The service worker does not unconditionally call `skipWaiting()` in the production path.
+The browser client detects waiting updates and shows an update prompt.
+If the user accepts, the client sends `{ type: 'SKIP_WAITING' }` to the waiting worker.
+The page reloads once after `controllerchange` so the page and service worker move to the same version together.
+
+This avoids mixed-version pages where old HTML or JavaScript is controlled by a new cache manifest.
+
+## Fetch behavior
+
+The worker handles same-origin `GET` requests only.
+Navigations first try the precache, then the runtime cache, then the network, then the offline fallback.
+Static subresources first try the precache.
+Progressive-cache subresources can be stored in the runtime cache after the requesting page is visited online.
+
+Navigation preload may be enabled during activation, but cache wins are allowed to settle the preload promise with `event.waitUntil()` so browsers do not report abandoned preload work.
+
+## Recovery paths
+
+The example includes two recovery tiers.
+
+For recoverable mistakes where page JavaScript still runs, `?reset-sw` unregisters service workers, deletes this example's caches, removes the query parameter, and reloads.
+For severe mistakes, deploy `rescue-service-worker.js` at `/service-worker.js` to replace the broken worker with a no-op worker at the same registration URL.
+
+Do not change the service-worker URL during recovery.
+A no-op worker at a different URL leaves the broken registration active at the old URL.
+
+## Deployment headers
+
+Recommended production headers:
+
+```txt
+/service-worker.js
+  Cache-Control: no-cache
+
+/**/*.html
+  Cache-Control: no-cache
+
+/assets/content-hashed-files...
+  Cache-Control: public, max-age=31536000, immutable
+```
+
+`no-cache` allows browser/storage revalidation.
+It does not mean "never store".
+Do not serve `/service-worker.js` with long-lived immutable caching.
+Content-hashed CSS, JavaScript, and chunks can be immutable because their URL changes when contents change.
diff --git a/examples/static-mpa-offline/README.md b/examples/static-mpa-offline/README.md
new file mode 100644
index 00000000..84764baa
--- /dev/null
+++ b/examples/static-mpa-offline/README.md
@@ -0,0 +1,175 @@
+# Static MPA Offline Example
+
+This example shows a small static multi-page app that can load selected static assets offline with a production-oriented service-worker lifecycle.
+
+- Domstack emits a stable root `/service-worker.js`.
+- `src/globals/domstack-manifest/domstack-manifest.settings.ts` uses `hooks.manifestBuilt` to inject finalized manifest data into `/service-worker.js`.
+- The service worker consumes the injected Domstack manifest entries directly.
+- Selected pages, scripts, styles, chunks, and small static assets are precached.
+- Layout vars define section-wide offline policy, and page vars or frontmatter can override that policy through domstack's normal variable cascade.
+- The client prompts before activating an update discovered during an active session.
+- Watch mode unregisters service workers and clears this example's caches to avoid half-cached development state.
+- `?reset-sw` and `rescue-service-worker.js` are included as recovery paths.
+
+## Running
+
+```sh
+npm --workspace @domstack/static-mpa-offline-example run serve
+```
+
+Then open the served localhost URL, wait for the offline cache to be ready, and use DevTools to test offline reloads.
+
+Use watch mode only for editing:
+
+```sh
+npm --workspace @domstack/static-mpa-offline-example run watch
+```
+
+Watch mode does not inject production manifest policy into the service worker, so the watch worker unregisters itself and clears owned caches.
+Use `serve` for offline-cache testing.
+
+## Pages in the sample app
+
+- `/` — home page and test instructions.
+- `/about/` — normal precached offline page.
+- `/offline/` — offline fallback page.
+- `/admin/` — admin page excluded from precache; offline reload should show `/offline/`.
+- `/progressive-cache/assets/` — page excluded from install-time precache but cached after the first online visit.
+- `/progressive-cache/assets/details/` — second progressive-cache page with its own image subresource.
+- `/progressive-cache/override/` — progressive-cache layout section page that opts back into precache.
+- `/cache-inspector/` — diagnostic page that asks the service worker for cache contents.
+
+## Layout and page policy
+
+This example uses two user-facing manifest vars:
+
+```ts
+manifestVars: ['offline', 'precache']
+```
+
+The root layout defaults to `offline: true` and `precache: true`.
+The progressive-cache layout defaults to `offline: true` and `precache: false`.
+The admin layout defaults to `offline: false` and `precache: false`.
+
+The cascade is page → layout → global → default.
+That means a layout can set a policy for a route section, and an individual page can still override that policy with `page.vars.ts` or frontmatter.
+
+The manifest settings also define one app-level fallback route:
+
+```ts
+policy: {
+  offlineFallbackUrl: '/offline/',
+}
+```
+
+The service worker uses that fallback for failed offline navigations instead of carrying route-specific fallback rules.
+
+## Progressive caching after first visit
+
+The `/progressive-cache/assets/` pages use the `progressive-cache` layout vars.
+Those pages are available offline only after a successful online visit.
+
+To test it:
+
+1. Load `/progressive-cache/assets/` and `/progressive-cache/assets/details/` while online.
+2. Switch DevTools to offline.
+3. Reload those pages.
+4. Their HTML and SVG image subresources should be served from the runtime cache.
+
+The `/progressive-cache/override/` page opts back into install-time precache from inside the progressive-cache section.
+
+## Client and service-worker structure
+
+The browser client and service worker are split by concern:
+
+```txt
+src/
+  globals/
+    global.css
+    global.vars.ts
+    global-client/
+      global.client.ts                 # bootstrap, config, and dependency wiring
+      connection-status.ts             # online/offline detection
+      service-worker-events.ts         # push/sync/periodic sync messages
+      service-worker-registration.ts   # registration, updates, reload flow
+      service-worker-reset.ts          # reset query param and watch cleanup
+      status-banner.ts                 # in-page status/indicator rendering
+    domstack-manifest/
+      domstack-manifest.settings.ts    # manifest vars, policy, include filter, and hook registration
+      policy-build.ts                  # injects finalized manifest data into /service-worker.js
+    service-worker/
+      service-worker.ts                # event wiring entrypoint
+      service-worker-settings.ts       # shared app settings and app-defined types
+      background-events.ts             # push/sync/periodic sync demo handlers
+      cache-inspection.ts              # cache-inspector message handling
+      clients.ts                       # window client messaging helpers
+      fetch-handlers.ts                # navigation and subresource fetch handling
+      lifecycle.ts                     # install/activate/reset/watch cleanup
+      precache.ts                      # manifest-entry-derived precache keys and cleanup
+      runtime-cache.ts                 # first-visit runtime caching
+```
+
+`global-client/global.client.ts` owns the example-specific browser wiring and creates the status banner.
+The service-worker modules receive the config and policy they need as arguments.
+This keeps lifecycle, connectivity state, recovery, fetch handling, and UI rendering separate enough to reuse or replace independently.
+
+## Push, sync, and periodic sync hooks
+
+`src/globals/service-worker/service-worker.ts` includes conservative handlers for:
+
+- `push`
+- one-off Background Sync: `sync`
+- Periodic Background Sync: `periodicsync`
+
+These handlers are extension points only.
+They do not request notification permission, subscribe users to push, register sync jobs, or cache app data.
+When triggered from DevTools, they post messages to open windows so the example can display/log that the service-worker event fired.
+Push events show a notification only if the user has already granted notification permission.
+
+Full push/sync support is app-specific and usually also requires server-side push subscription storage, permission UX, retry policy, and privacy/security review.
+
+## Recovery paths
+
+For recoverable mistakes where pages still load, visit:
+
+```txt
+/?reset-sw
+```
+
+The client unregisters service workers, deletes this example's offline caches, removes the query parameter, and reloads.
+
+For a truly bad service worker that breaks page loads, deploy `rescue-service-worker.js` at the exact production service-worker URL:
+
+```txt
+/service-worker.js
+```
+
+This mirrors Workbox's recommended no-op recovery worker: same URL, immediate `skipWaiting()`, no `fetch` handler, and cache cleanup.
+
+## Research references
+
+If you are revisiting this example in a fresh context window, these are the docs and source files that informed the implementation.
+
+### Core docs
+
+- <https://web.dev/learn/pwa/workbox>
+- <https://developer.chrome.com/docs/workbox/>
+- <https://developer.chrome.com/docs/workbox/service-worker-lifecycle>
+- <https://developer.chrome.com/docs/workbox/service-worker-deployment>
+- <https://developer.chrome.com/docs/workbox/handling-service-worker-updates>
+- <https://developer.chrome.com/docs/workbox/precaching-dos-and-donts>
+- <https://developer.chrome.com/docs/workbox/remove-buggy-service-workers>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-precaching>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-strategies>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-window>
+- <https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API>
+- <https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers>
+
+### Local context
+
+- `README.md` at the repo root — domstack manifest and first-class service-worker docs.
+- `examples/static-mpa-offline/DESIGN.md` — design notes and rationale for this example.
+- `examples/static-mpa-workbox-offline/README.md` — the same app structure implemented with Workbox caching APIs.
+- `plans/domstack-manifest.md` — manifest hook and service-worker integration plan.
+- `plans/standard-static-mpa-service-worker.md` — standard static MPA service-worker plan.
+- `plans/workbox-workflow-integration.md` — implemented Workbox policy injection workflow.
diff --git a/examples/static-mpa-offline/package.json b/examples/static-mpa-offline/package.json
new file mode 100644
index 00000000..2d4f8510
--- /dev/null
+++ b/examples/static-mpa-offline/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "@domstack/static-mpa-offline-example",
+  "version": "0.0.0",
+  "description": "Static MPA offline service worker example for domstack",
+  "type": "module",
+  "imports": {
+    "#service-worker-settings": "./src/globals/service-worker/service-worker-settings.ts"
+  },
+  "scripts": {
+    "start": "npm run serve",
+    "build": "npm run clean && domstack",
+    "clean": "rm -rf public && mkdir -p public",
+    "serve": "npm run clean && domstack --serve",
+    "watch": "npm run clean && domstack --watch"
+  },
+  "keywords": [
+    "domstack",
+    "service-worker",
+    "offline",
+    "pwa"
+  ],
+  "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
+  "license": "MIT",
+  "dependencies": {
+    "@domstack/static": "file:../../."
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
+  }
+}
diff --git a/examples/static-mpa-offline/rescue-service-worker.js b/examples/static-mpa-offline/rescue-service-worker.js
new file mode 100644
index 00000000..2510906b
--- /dev/null
+++ b/examples/static-mpa-offline/rescue-service-worker.js
@@ -0,0 +1,31 @@
+// Emergency replacement for a bad production service worker.
+//
+// To use: deploy this file's contents at the SAME URL as the broken worker:
+// /service-worker.js. Keeping the exact URL is critical; otherwise the broken
+// registration will continue controlling its old scope.
+//
+// This follows Workbox's documented recovery approach: install and activate
+// immediately, avoid a fetch handler entirely so requests pass through to the
+// browser/network, and reload controlled windows once the no-op worker is active.
+
+const CACHE_PREFIXES = ['domstack-static-mpa-precache', 'domstack-static-mpa-runtime']
+
+self.addEventListener('install', () => {
+  self.skipWaiting()
+})
+
+self.addEventListener('activate', event => {
+  event.waitUntil((async () => {
+    const cacheNames = await caches.keys()
+    await Promise.all(
+      cacheNames
+        .filter(name => CACHE_PREFIXES.some(prefix => name.startsWith(prefix)))
+        .map(name => caches.delete(name))
+    )
+
+    const windowClients = await self.clients.matchAll({ type: 'window' })
+    await Promise.all(
+      windowClients.map(windowClient => windowClient.navigate(windowClient.url))
+    )
+  })())
+})
diff --git a/examples/static-mpa-offline/src/about/client.ts b/examples/static-mpa-offline/src/about/client.ts
new file mode 100644
index 00000000..501ab0cb
--- /dev/null
+++ b/examples/static-mpa-offline/src/about/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('about')
diff --git a/examples/static-mpa-offline/src/about/page.md b/examples/static-mpa-offline/src/about/page.md
new file mode 100644
index 00000000..941a71ba
--- /dev/null
+++ b/examples/static-mpa-offline/src/about/page.md
@@ -0,0 +1,6 @@
+# About the offline cache
+
+This page is a second static MPA route. It should be available after the service worker installs successfully.
+
+The worker intentionally avoids caching data/API requests. It focuses on the static application surface: HTML, CSS, JavaScript, chunks, workers, and selected static files.
+
diff --git a/examples/static-mpa-offline/src/about/style.css b/examples/static-mpa-offline/src/about/style.css
new file mode 100644
index 00000000..6d94a4ae
--- /dev/null
+++ b/examples/static-mpa-offline/src/about/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: seagreen;
+}
diff --git a/examples/static-mpa-offline/src/admin/client.ts b/examples/static-mpa-offline/src/admin/client.ts
new file mode 100644
index 00000000..a5861929
--- /dev/null
+++ b/examples/static-mpa-offline/src/admin/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('admin')
diff --git a/examples/static-mpa-offline/src/admin/page.md b/examples/static-mpa-offline/src/admin/page.md
new file mode 100644
index 00000000..70345265
--- /dev/null
+++ b/examples/static-mpa-offline/src/admin/page.md
@@ -0,0 +1,23 @@
+---
+title: Admin / network-only page
+---
+
+# Admin / network-only page
+
+This route demonstrates opting a section out of offline availability.
+
+Its sibling `page.vars.ts` selects the `admin` layout:
+
+```ts
+export default {
+  layout: 'admin',
+}
+```
+
+`src/layouts/admin.layout.ts` exports these layout vars:
+
+- `offline: false`
+- `precache: false`
+
+So `/admin/` should load while online, but an offline reload should show the offline fallback page instead of this page.
+
diff --git a/examples/static-mpa-offline/src/admin/page.vars.ts b/examples/static-mpa-offline/src/admin/page.vars.ts
new file mode 100644
index 00000000..da04b674
--- /dev/null
+++ b/examples/static-mpa-offline/src/admin/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'admin',
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/admin/style.css b/examples/static-mpa-offline/src/admin/style.css
new file mode 100644
index 00000000..02dfb14b
--- /dev/null
+++ b/examples/static-mpa-offline/src/admin/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: crimson;
+}
diff --git a/examples/static-mpa-offline/src/cache-inspector/client.ts b/examples/static-mpa-offline/src/cache-inspector/client.ts
new file mode 100644
index 00000000..f2e9ab0a
--- /dev/null
+++ b/examples/static-mpa-offline/src/cache-inspector/client.ts
@@ -0,0 +1,58 @@
+/// <reference lib="dom" />
+
+const offlineCacheInspectorButton = document.querySelector<HTMLButtonElement>('#inspect-caches')
+const offlineCacheInspectorOutput = document.querySelector<HTMLPreElement>('#cache-inspection-output')
+
+offlineCacheInspectorButton?.addEventListener('click', async () => {
+  writeOutput('Requesting cache details from the service worker…')
+
+  try {
+    writeOutput(JSON.stringify(await inspectOfflineExampleCaches(), null, 2))
+  } catch (error) {
+    writeOutput(error instanceof Error ? error.message : String(error))
+  }
+})
+
+function writeOutput (message: string): void {
+  if (!offlineCacheInspectorOutput) return
+  offlineCacheInspectorOutput.textContent = message
+}
+
+async function inspectOfflineExampleCaches (): Promise<unknown> {
+  if (!('serviceWorker' in navigator)) throw new Error('Service workers are not supported in this browser.')
+  if (!navigator.serviceWorker.controller) throw new Error('This page is not controlled by a service worker yet. Reload after the worker is ready.')
+
+  const id = crypto.randomUUID()
+
+  return await new Promise((resolve, reject) => {
+    const timeout = window.setTimeout(() => {
+      navigator.serviceWorker.removeEventListener('message', onMessage)
+      reject(new Error('Timed out waiting for service-worker cache details.'))
+    }, 5000)
+
+    function onMessage (event: MessageEvent): void {
+      const message = event.data
+      if (!isOfflineCacheInspectionResult(message, id)) return
+
+      window.clearTimeout(timeout)
+      navigator.serviceWorker.removeEventListener('message', onMessage)
+      resolve(message.payload)
+    }
+
+    navigator.serviceWorker.addEventListener('message', onMessage)
+    navigator.serviceWorker.controller?.postMessage({
+      id,
+      type: 'DOMSTACK_INSPECT_CACHES',
+    })
+  })
+}
+
+function isOfflineCacheInspectionResult (
+  message: unknown,
+  id: string
+): message is { payload: unknown } {
+  if (!message || typeof message !== 'object') return false
+  return 'type' in message && message.type === 'DOMSTACK_CACHE_INSPECTION_RESULT' &&
+    'id' in message && message.id === id &&
+    'payload' in message
+}
diff --git a/examples/static-mpa-offline/src/cache-inspector/page.html b/examples/static-mpa-offline/src/cache-inspector/page.html
new file mode 100644
index 00000000..8b102a56
--- /dev/null
+++ b/examples/static-mpa-offline/src/cache-inspector/page.html
@@ -0,0 +1,7 @@
+<h1>Cache inspector</h1>
+
+<p>This page asks the active service worker for a diagnostic list of caches owned by this example.</p>
+
+<button type="button" id="inspect-caches">Inspect service-worker caches</button>
+
+<pre id="cache-inspection-output">Press the button to inspect cached files.</pre>
diff --git a/examples/static-mpa-offline/src/cache-inspector/page.vars.ts b/examples/static-mpa-offline/src/cache-inspector/page.vars.ts
new file mode 100644
index 00000000..f2bfdf53
--- /dev/null
+++ b/examples/static-mpa-offline/src/cache-inspector/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  title: 'Cache inspector',
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/cache-inspector/style.css b/examples/static-mpa-offline/src/cache-inspector/style.css
new file mode 100644
index 00000000..023710a9
--- /dev/null
+++ b/examples/static-mpa-offline/src/cache-inspector/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: rebeccapurple;
+}
diff --git a/examples/static-mpa-offline/src/client.ts b/examples/static-mpa-offline/src/client.ts
new file mode 100644
index 00000000..968078da
--- /dev/null
+++ b/examples/static-mpa-offline/src/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from './page-client.ts'
+
+markPageClientLoaded('home')
diff --git a/examples/static-mpa-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts b/examples/static-mpa-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
new file mode 100644
index 00000000..fb331850
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
@@ -0,0 +1,21 @@
+import type { DomstackManifestOptions } from '@domstack/static/types.ts'
+import type {
+  StaticMpaOfflineManifestVars,
+  StaticMpaOfflinePageVars,
+  StaticMpaOfflinePolicy,
+} from '#service-worker-settings'
+import { offlineFallbackUrl } from '#service-worker-settings'
+import { emitServiceWorkerPolicy } from './policy-build.ts'
+
+const settings = {
+  manifestVars: ['offline', 'precache'],
+  policy: {
+    offlineFallbackUrl,
+  },
+  hooks: {
+    manifestBuilt: [emitServiceWorkerPolicy],
+  },
+  includeEntry: entry => entry.kind !== 'metadata' && entry.kind !== 'sourcemap',
+} satisfies DomstackManifestOptions<StaticMpaOfflinePolicy, StaticMpaOfflineManifestVars, StaticMpaOfflinePageVars>
+
+export default settings
diff --git a/examples/static-mpa-offline/src/globals/domstack-manifest/policy-build.ts b/examples/static-mpa-offline/src/globals/domstack-manifest/policy-build.ts
new file mode 100644
index 00000000..f18a86ac
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/domstack-manifest/policy-build.ts
@@ -0,0 +1,33 @@
+import type {
+  DomstackManifest,
+  DomstackManifestBuiltHookContext,
+} from '@domstack/static/types.ts'
+import type {
+  StaticMpaOfflineManifestVars,
+  StaticMpaOfflinePolicy,
+  StaticMpaOfflineServiceWorkerPolicy,
+} from '#service-worker-settings'
+import {
+  offlineFallbackUrl,
+  serviceWorkerPolicyDefineName,
+} from '#service-worker-settings'
+
+/** Inject the final manifest data consumed by `/service-worker.js`. */
+export async function emitServiceWorkerPolicy (
+  context: DomstackManifestBuiltHookContext<StaticMpaOfflinePolicy, StaticMpaOfflineManifestVars>
+): Promise<void> {
+  context.defineServiceWorkerConstant(
+    serviceWorkerPolicyDefineName,
+    toServiceWorkerPolicy(context.manifest)
+  )
+}
+
+function toServiceWorkerPolicy (
+  manifest: DomstackManifest<StaticMpaOfflinePolicy, StaticMpaOfflineManifestVars>
+): StaticMpaOfflineServiceWorkerPolicy {
+  return {
+    version: manifest.version,
+    entries: manifest.entries,
+    offlineFallbackUrl: manifest.policy?.offlineFallbackUrl ?? offlineFallbackUrl,
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/connection-status.ts b/examples/static-mpa-offline/src/globals/global-client/connection-status.ts
new file mode 100644
index 00000000..f9379c31
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/connection-status.ts
@@ -0,0 +1,172 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Online/offline indicator state for cached navigations.
+ *
+ * This module mostly trusts `navigator.onLine`, but remembers when the current
+ * tab observed offline so cached page-to-page navigations do not incorrectly
+ * reset the indicator to online. While offline, it periodically probes the
+ * origin to detect recovery when browser `online` events are unreliable.
+ */
+
+export type ConnectionStatusOptions = {
+  offlineRecheckIntervalMs: number
+  offlineStorageKey: string
+  onlineCheckTimeoutMs: number
+}
+
+let connectionStatusCheck = 0
+let connectionStatusOnline = navigator.onLine
+let offlineRecheckTimer: number | undefined
+let onlineCheckPromise: Promise<boolean> | undefined
+
+/** Register browser lifecycle listeners and render the initial connection state. */
+export function initializeConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  window.addEventListener('online', () => updateConnectionStatus(status, options))
+  window.addEventListener('offline', () => updateConnectionStatus(status, options))
+  window.addEventListener('focus', () => updateConnectionStatus(status, options))
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+      updateConnectionStatus(status, options)
+    } else {
+      stopOfflineRecheck()
+    }
+  })
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => updateConnectionStatus(status, options), { once: true })
+  } else {
+    updateConnectionStatus(status, options)
+  }
+}
+
+/** Update the indicator from browser state, probing only after this tab observed offline. */
+function updateConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  if (!navigator.onLine) {
+    setConnectionStatus(status, options, false)
+    return
+  }
+
+  if (wasOfflineInThisTab(options)) {
+    setConnectionStatus(status, options, false)
+    verifyOfflineRecovery(status, options)
+    return
+  }
+
+  setConnectionStatus(status, options, true)
+}
+
+/** Persist and render the current connection state, starting/stopping recovery checks. */
+function setConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions,
+  online: boolean
+): void {
+  connectionStatusOnline = online
+  rememberConnectionStatus(options, online)
+  status.showConnectionStatus(online)
+
+  if (online) {
+    stopOfflineRecheck()
+  } else {
+    startOfflineRecheck(status, options)
+  }
+}
+
+/** Start a low-frequency recovery probe while the tab is visible and marked offline. */
+function startOfflineRecheck (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  if (offlineRecheckTimer !== undefined) return
+  if (document.visibilityState === 'hidden') return
+
+  offlineRecheckTimer = window.setInterval(() => {
+    if (!connectionStatusOnline) verifyOfflineRecovery(status, options)
+  }, options.offlineRecheckIntervalMs)
+}
+
+/** Stop the offline recovery probe. */
+function stopOfflineRecheck (): void {
+  if (offlineRecheckTimer === undefined) return
+
+  window.clearInterval(offlineRecheckTimer)
+  offlineRecheckTimer = undefined
+}
+
+/** Probe the origin once and flip online only if the network check succeeds. */
+function verifyOfflineRecovery (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  const check = ++connectionStatusCheck
+
+  verifyOnlineStatus(options).then(online => {
+    if (check !== connectionStatusCheck) return
+    if (online) setConnectionStatus(status, options, true)
+  }).catch(() => {
+    if (check !== connectionStatusCheck) return
+    setConnectionStatus(status, options, false)
+  })
+}
+
+/** Coalesce concurrent origin reachability checks into one in-flight request. */
+async function verifyOnlineStatus (options: ConnectionStatusOptions): Promise<boolean> {
+  if (onlineCheckPromise) return onlineCheckPromise
+
+  onlineCheckPromise = fetchOnlineStatus(options)
+  try {
+    return await onlineCheckPromise
+  } finally {
+    onlineCheckPromise = undefined
+  }
+}
+
+/** Return whether this tab previously observed offline state across cached navigations. */
+function wasOfflineInThisTab (options: ConnectionStatusOptions): boolean {
+  try {
+    return window.sessionStorage.getItem(options.offlineStorageKey) === 'true'
+  } catch {
+    return !connectionStatusOnline
+  }
+}
+
+/** Store offline state in sessionStorage so cached navigations preserve the indicator. */
+function rememberConnectionStatus (options: ConnectionStatusOptions, online: boolean): void {
+  try {
+    if (online) {
+      window.sessionStorage.removeItem(options.offlineStorageKey)
+    } else {
+      window.sessionStorage.setItem(options.offlineStorageKey, 'true')
+    }
+  } catch {
+    // Storage can be unavailable in private browsing or restrictive contexts.
+  }
+}
+
+/** Fetch the origin with cache bypass to confirm network reachability after offline state. */
+async function fetchOnlineStatus (options: ConnectionStatusOptions): Promise<boolean> {
+  const controller = new AbortController()
+  const timeout = window.setTimeout(() => controller.abort(), options.onlineCheckTimeoutMs)
+
+  try {
+    const url = new URL(window.location.origin)
+    url.searchParams.set('__domstack_online_check', String(Date.now()))
+
+    const response = await fetch(url.href, {
+      cache: 'no-store',
+      credentials: 'same-origin',
+      signal: controller.signal,
+    })
+
+    return response.ok
+  } finally {
+    window.clearTimeout(timeout)
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/global.client.ts b/examples/static-mpa-offline/src/globals/global-client/global.client.ts
new file mode 100644
index 00000000..7382b359
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/global.client.ts
@@ -0,0 +1,74 @@
+import { initializeConnectionStatus } from './connection-status.ts'
+import { initializeServiceWorkerEventMessages } from './service-worker-events.ts'
+import { registerServiceWorker } from './service-worker-registration.ts'
+import {
+  disableServiceWorkerForWatchMode,
+  resetServiceWorkerFromWindow,
+  shouldResetServiceWorker,
+} from './service-worker-reset.ts'
+import { createStatusBanner } from './status-banner.ts'
+import {
+  cachePrefixes,
+  offlineRecheckIntervalMs,
+  offlineStorageKey,
+  onlineCheckTimeoutMs,
+} from '#service-worker-settings'
+
+/**
+ * Browser entrypoint for the offline static MPA example.
+ *
+ * This file owns example-specific config and wires independent modules together:
+ * connection status, service-worker registration, reset/watch cleanup, and the
+ * in-page status UI. The modules receive only the config/UI capabilities they need.
+ */
+
+const connectionStatusOptions = {
+  offlineRecheckIntervalMs,
+  offlineStorageKey,
+  onlineCheckTimeoutMs,
+}
+
+const serviceWorkerResetOptions = {
+  cachePrefixes: [...cachePrefixes],
+}
+
+const manifestEnabled = process.env.DOMSTACK_MANIFEST_ENABLED === 'true'
+const serviceWorkerScope = process.env.DOMSTACK_SERVICE_WORKER_SCOPE
+const serviceWorkerUrl = process.env.DOMSTACK_SERVICE_WORKER_URL
+
+const status = createStatusBanner()
+
+initializeConnectionStatus(status, connectionStatusOptions)
+initializeServiceWorkerEventMessages(status)
+
+if (serviceWorkerUrl && serviceWorkerScope && 'serviceWorker' in navigator) {
+  if (shouldResetServiceWorker()) {
+    try {
+      await resetServiceWorkerFromWindow(status, serviceWorkerResetOptions)
+    } catch (error) {
+      console.error('Service worker reset failed', error)
+    }
+  } else if (!manifestEnabled) {
+    try {
+      await disableServiceWorkerForWatchMode(status, serviceWorkerResetOptions)
+    } catch (error) {
+      console.error('Service worker watch-mode cleanup failed', error)
+    }
+  } else {
+    try {
+      await windowLoaded()
+      await registerServiceWorker(status, serviceWorkerUrl, serviceWorkerScope)
+    } catch (error) {
+      console.error('Service worker registration failed', error)
+    }
+  }
+}
+
+/** Resolve after the load event so service-worker registration avoids competing with first paint. */
+async function windowLoaded (): Promise<void> {
+  if (document.readyState === 'complete') return
+
+  await new Promise<void>(resolve => {
+    window.addEventListener('load', () => resolve(), { once: true })
+  })
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/service-worker-events.ts b/examples/static-mpa-offline/src/globals/global-client/service-worker-events.ts
new file mode 100644
index 00000000..ea5c94f0
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/service-worker-events.ts
@@ -0,0 +1,43 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Display optional service-worker background events in the example UI.
+ *
+ * The service worker can receive push, one-off sync, and periodic sync events.
+ * This module keeps those example-only messages separate from registration and
+ * update lifecycle code.
+ */
+
+/** Listen for background-event messages from the service worker and render/log them. */
+export function initializeServiceWorkerEventMessages (status: Pick<StatusBanner, 'showStatus'>): void {
+  if (!('serviceWorker' in navigator)) return
+
+  navigator.serviceWorker.addEventListener('message', event => {
+    const message = event.data
+    if (!isServiceWorkerEventMessage(message)) return
+
+    if (message.type === 'DOMSTACK_PUSH_RECEIVED') {
+      console.info('Service worker push event received', message.payload)
+      status.showStatus('Push event received by the service worker.', 'info')
+    }
+
+    if (message.type === 'DOMSTACK_SYNC_RECEIVED') {
+      console.info('Service worker sync event received', message.tag)
+      status.showStatus(`Sync event received: ${String(message.tag ?? 'untagged')}`, 'info')
+    }
+
+    if (message.type === 'DOMSTACK_PERIODIC_SYNC_RECEIVED') {
+      console.info('Service worker periodic sync event received', message.tag)
+      status.showStatus(`Periodic sync event received: ${String(message.tag ?? 'untagged')}`, 'info')
+    }
+  })
+}
+
+/** Narrow structured-clone messages to the simple event shape this example understands. */
+function isServiceWorkerEventMessage (value: unknown): value is {
+  payload?: unknown
+  tag?: unknown
+  type: string
+} {
+  return Boolean(value) && typeof value === 'object' && typeof (value as { type?: unknown }).type === 'string'
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/service-worker-registration.ts b/examples/static-mpa-offline/src/globals/global-client/service-worker-registration.ts
new file mode 100644
index 00000000..574e443b
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/service-worker-registration.ts
@@ -0,0 +1,102 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Service-worker registration and update UX for the static MPA example.
+ *
+ * This module owns browser registration, waiting-worker prompts, and the
+ * one-time reload after a user-approved update takes control. It receives a UI
+ * interface from the entrypoint instead of importing a banner implementation.
+ */
+
+/** Register the service worker after page load and wire update lifecycle events. */
+export async function registerServiceWorker (
+  status: Pick<StatusBanner, 'showStatus'>,
+  url: string,
+  scope: string
+): Promise<void> {
+  const registration = await navigator.serviceWorker.register(url, {
+    scope,
+    type: 'module',
+    updateViaCache: 'none',
+  })
+
+  status.showStatus('Installing offline cache…')
+
+  if (registration.installing) {
+    trackInstallingWorker(status, registration.installing, registration)
+  } else if (registration.waiting && navigator.serviceWorker.controller) {
+    applyWaitingUpdate(status, registration, 'Applying offline update from previous visit…')
+  } else if (registration.active) {
+    status.showStatus('Offline cache is ready.', 'ready')
+  }
+
+  registration.addEventListener('updatefound', () => {
+    const worker = registration.installing
+    if (worker) trackInstallingWorker(status, worker, registration)
+  })
+
+  let refreshing = false
+  navigator.serviceWorker.addEventListener('controllerchange', () => {
+    if (refreshing) return
+    refreshing = true
+    window.location.reload()
+  })
+}
+
+/** Track an installing worker until it is ready, failed, or waiting for user action. */
+function trackInstallingWorker (
+  status: Pick<StatusBanner, 'showStatus'>,
+  worker: ServiceWorker,
+  registration: ServiceWorkerRegistration
+): void {
+  worker.addEventListener('statechange', () => {
+    if (worker.state === 'installed') {
+      if (navigator.serviceWorker.controller) {
+        promptForUpdate(status, registration)
+      } else {
+        status.showStatus('Offline cache is ready.', 'ready')
+      }
+      return
+    }
+
+    if (worker.state === 'redundant') {
+      console.info('Service worker became redundant during registration.', worker)
+    }
+  })
+}
+
+/** Show the in-page update prompt for a newly installed waiting worker. */
+function promptForUpdate (
+  status: Pick<StatusBanner, 'showStatus'>,
+  registration: ServiceWorkerRegistration
+): void {
+  const reload = document.createElement('button')
+  reload.type = 'button'
+  reload.textContent = 'Reload now'
+  reload.addEventListener('click', () => {
+    reload.disabled = true
+    applyWaitingUpdate(status, registration, 'Updating offline cache…')
+  })
+
+  const later = document.createElement('button')
+  later.type = 'button'
+  later.textContent = 'Later'
+  later.addEventListener('click', () => {
+    status.showStatus('Update will be applied after all tabs are closed.', 'info')
+  })
+
+  status.showStatus('A new offline version is available.', 'update', [reload, later])
+}
+
+/** Ask the waiting worker to skip waiting; `controllerchange` will reload the page. */
+function applyWaitingUpdate (
+  status: Pick<StatusBanner, 'showStatus'>,
+  registration: ServiceWorkerRegistration,
+  message: string
+): void {
+  const worker = registration.waiting
+  if (!worker) return
+
+  worker.postMessage({ type: 'SKIP_WAITING' })
+  status.showStatus(message, 'update')
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/service-worker-reset.ts b/examples/static-mpa-offline/src/globals/global-client/service-worker-reset.ts
new file mode 100644
index 00000000..32dd4c63
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/service-worker-reset.ts
@@ -0,0 +1,71 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Recovery and watch-mode cleanup helpers for sticky service-worker state.
+ *
+ * These paths intentionally live outside registration logic because they are
+ * destructive: they unregister workers, delete owned caches, and reload/navigate
+ * pages to escape stale or broken service-worker control.
+ */
+
+export type ServiceWorkerResetOptions = {
+  cachePrefixes: string[]
+}
+
+/** Return true when the current URL requests a client-side service-worker reset. */
+export function shouldResetServiceWorker (): boolean {
+  const params = new URLSearchParams(window.location.search)
+  return params.has('reset-sw') || params.has('reset-service-worker')
+}
+
+/** Reset service workers/caches from a page that still loads enough JS to recover. */
+export async function resetServiceWorkerFromWindow (
+  status: Pick<StatusBanner, 'showStatus'>,
+  options: ServiceWorkerResetOptions
+): Promise<void> {
+  status.showStatus('Resetting service worker and offline caches…', 'update')
+
+  await unregisterServiceWorkersAndDeleteCaches(options)
+
+  const url = new URL(window.location.href)
+  url.searchParams.delete('reset-sw')
+  url.searchParams.delete('reset-service-worker')
+  window.location.replace(url.href)
+}
+
+/** Clear production SW state during watch mode, where no domstack manifest is emitted. */
+export async function disableServiceWorkerForWatchMode (
+  status: Pick<StatusBanner, 'showStatus'>,
+  options: ServiceWorkerResetOptions
+): Promise<void> {
+  const hadController = Boolean(navigator.serviceWorker.controller)
+  await unregisterServiceWorkersAndDeleteCaches(options)
+
+  if (hadController) {
+    status.showStatus('Service worker disabled in watch mode. Reloading without offline cache…', 'update')
+    window.location.reload()
+    return
+  }
+
+  status.showStatus('Service worker disabled in watch mode. Use `npm run serve` to test offline caching.', 'info')
+}
+
+/** Unregister all same-origin service workers and delete caches matching owned prefixes. */
+async function unregisterServiceWorkersAndDeleteCaches (options: ServiceWorkerResetOptions): Promise<void> {
+  const registrations = await navigator.serviceWorker.getRegistrations()
+  for (const registration of registrations) {
+    registration.active?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    registration.waiting?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    registration.installing?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    await registration.unregister()
+  }
+
+  if ('caches' in window) {
+    const cacheNames = await caches.keys()
+    await Promise.all(
+      cacheNames
+        .filter(name => options.cachePrefixes.some(prefix => name.startsWith(prefix)))
+        .map(name => caches.delete(name))
+    )
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/global-client/status-banner.ts b/examples/static-mpa-offline/src/globals/global-client/status-banner.ts
new file mode 100644
index 00000000..5c045740
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global-client/status-banner.ts
@@ -0,0 +1,73 @@
+/**
+ * Minimal status UI adapter used by the example client modules.
+ *
+ * Keeping this as a small interface lets lifecycle/connectivity modules receive
+ * UI capabilities as arguments instead of importing DOM rendering directly.
+ */
+
+export type StatusBanner = {
+  showConnectionStatus (online: boolean): void
+  showStatus (message: string, state?: string, actions?: HTMLElement[]): void
+}
+
+/** Create the default in-page banner implementation for this example. */
+export function createStatusBanner (): StatusBanner {
+  getStatusBanner()
+
+  return {
+    showConnectionStatus,
+    showStatus,
+  }
+}
+
+/** Render a status message and optional action buttons in the shared banner. */
+function showStatus (message: string, state = 'info', actions: HTMLElement[] = []): void {
+  const status = getStatusBanner()
+
+  status.dataset.state = state
+  status.replaceChildren(getConnectionIndicator())
+
+  const text = document.createElement('span')
+  text.textContent = message
+  status.append(text)
+
+  if (actions.length > 0) {
+    const actionList = document.createElement('span')
+    actionList.className = 'offline-status__actions'
+    actionList.append(...actions)
+    status.append(actionList)
+  }
+}
+
+/** Render the online/offline badge without changing the current status message. */
+function showConnectionStatus (online: boolean): void {
+  const indicator = getConnectionIndicator()
+  indicator.dataset.state = online ? 'online' : 'offline'
+  indicator.textContent = online ? 'Online' : 'Offline'
+}
+
+/** Return the shared status banner, creating it at the top of the body if needed. */
+function getStatusBanner (): HTMLElement {
+  let status = document.querySelector<HTMLElement>('.offline-status')
+  if (!status) {
+    status = document.createElement('div')
+    status.className = 'offline-status'
+    document.body.prepend(status)
+  }
+
+  return status
+}
+
+/** Return the connection badge, preserving it across banner re-renders. */
+function getConnectionIndicator (): HTMLElement {
+  let indicator = document.querySelector<HTMLElement>('.connection-status')
+  if (!indicator) {
+    indicator = document.createElement('span')
+    indicator.className = 'connection-status'
+  }
+
+  const status = getStatusBanner()
+  if (!status.contains(indicator)) status.prepend(indicator)
+
+  return indicator
+}
diff --git a/examples/static-mpa-offline/src/globals/global.css b/examples/static-mpa-offline/src/globals/global.css
new file mode 100644
index 00000000..2ed5910c
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global.css
@@ -0,0 +1,102 @@
+:root {
+  --offline-status-height: 4rem;
+  color-scheme: light dark;
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+
+body {
+  margin: 0;
+}
+
+body::before {
+  block-size: var(--offline-status-height);
+  content: "";
+  display: block;
+  flex: none;
+}
+
+main {
+  margin-inline: auto;
+  max-width: 42rem;
+  padding: 2rem;
+}
+
+a {
+  color: #0b65c2;
+}
+
+.example-navigation {
+  box-sizing: border-box;
+  margin-inline: auto;
+  max-width: 42rem;
+  padding: 1.5rem 2rem 0;
+}
+
+.home-button {
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  display: inline-block;
+  font-weight: 700;
+  padding: 0.375rem 0.75rem;
+  text-decoration: none;
+}
+
+.home-button:hover {
+  text-decoration: underline;
+}
+
+.offline-status {
+  align-items: center;
+  background: Canvas;
+  block-size: var(--offline-status-height);
+  border-block-end: 1px solid color-mix(in srgb, currentColor 20%, transparent);
+  box-sizing: border-box;
+  display: flex;
+  font-size: 0.875rem;
+  gap: 0.75rem;
+  inset-block-start: 0;
+  inset-inline: 0;
+  justify-content: space-between;
+  overflow: hidden;
+  padding: 0.75rem 2rem;
+  position: fixed;
+  z-index: 10;
+}
+
+.connection-status {
+  border: 1px solid color-mix(in srgb, currentColor 35%, transparent);
+  border-radius: 999px;
+  font-size: 0.75rem;
+  font-weight: 700;
+  padding: 0.125rem 0.5rem;
+}
+
+.connection-status[data-state="online"] {
+  color: green;
+}
+
+.connection-status[data-state="offline"] {
+  color: crimson;
+}
+
+.offline-status__actions {
+  display: inline-flex;
+  gap: 0.5rem;
+}
+
+.offline-status button {
+  cursor: pointer;
+}
+
+.offline-status[data-state="ready"] {
+  background: color-mix(in srgb, green 14%, transparent);
+}
+
+.offline-status[data-state="update"] {
+  background: color-mix(in srgb, orange 18%, transparent);
+}
+
+.offline-status[data-state="error"] {
+  background: color-mix(in srgb, red 16%, transparent);
+}
diff --git a/examples/static-mpa-offline/src/globals/global.vars.ts b/examples/static-mpa-offline/src/globals/global.vars.ts
new file mode 100644
index 00000000..662255b0
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/global.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'root',
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/globals/service-worker/background-events.ts b/examples/static-mpa-offline/src/globals/service-worker/background-events.ts
new file mode 100644
index 00000000..49d6fc40
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/background-events.ts
@@ -0,0 +1,111 @@
+/// <reference lib="webworker" />
+
+import { serviceWorkerNotificationTag } from '#service-worker-settings'
+import { postToWindowClients } from './clients.ts'
+
+/**
+ * Optional background-event extension hooks for the offline example.
+ *
+ * These handlers intentionally do not subscribe users, request permissions,
+ * register sync jobs, or cache app data. They only surface events to open pages
+ * and, for push, show a notification when permission has already been granted.
+ *
+ * Related functions:
+ * - `handlePushEvent()` handles Push API events.
+ * - `handleSyncEvent()` handles one-off Background Sync events.
+ * - `handlePeriodicSyncEvent()` handles Periodic Background Sync events.
+ *
+ * MDN quick links:
+ * - Push API: https://developer.mozilla.org/en-US/docs/Web/API/Push_API
+ * - PushEvent: https://developer.mozilla.org/en-US/docs/Web/API/PushEvent
+ * - Notifications API: https://developer.mozilla.org/en-US/docs/Web/API/Notifications_API
+ * - Background Synchronization API: https://developer.mozilla.org/en-US/docs/Web/API/Background_Synchronization_API
+ * - Periodic Background Sync API: https://developer.mozilla.org/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+type ExtendableEventLike = Event & {
+  waitUntil (promise: Promise<unknown>): void
+}
+
+export type PushEventLike = ExtendableEventLike & {
+  data?: {
+    json (): unknown
+    text (): string
+  }
+}
+
+export type SyncEventLike = ExtendableEventLike & {
+  tag?: string
+}
+
+/**
+ * Handle a push payload by notifying open windows and optionally showing a notification.
+ *
+ * See MDN PushEvent: https://developer.mozilla.org/en-US/docs/Web/API/PushEvent
+ */
+export async function handlePushEvent (event: PushEventLike): Promise<void> {
+  const payload = readPushPayload(event)
+
+  await postToWindowClients({
+    payload,
+    type: 'DOMSTACK_PUSH_RECEIVED',
+  })
+
+  if (!('Notification' in self) || Notification.permission !== 'granted') return
+
+  const notification = normalizeNotificationPayload(payload)
+  await self.registration.showNotification(notification.title, {
+    body: notification.body,
+    data: notification.data,
+    tag: serviceWorkerNotificationTag,
+  })
+}
+
+/** Surface a one-off Background Sync event to open windows. */
+export async function handleSyncEvent (event: SyncEventLike): Promise<void> {
+  await postToWindowClients({
+    tag: event.tag ?? null,
+    type: 'DOMSTACK_SYNC_RECEIVED',
+  })
+}
+
+/** Surface a Periodic Background Sync event to open windows. */
+export async function handlePeriodicSyncEvent (event: SyncEventLike): Promise<void> {
+  await postToWindowClients({
+    tag: event.tag ?? null,
+    type: 'DOMSTACK_PERIODIC_SYNC_RECEIVED',
+  })
+}
+
+function readPushPayload (event: PushEventLike): unknown {
+  if (!event.data) return null
+
+  try {
+    return event.data.json()
+  } catch {
+    return event.data.text()
+  }
+}
+
+function normalizeNotificationPayload (payload: unknown): {
+  title: string
+  body?: string
+  data?: unknown
+} {
+  if (payload && typeof payload === 'object') {
+    const record = payload as Record<string, unknown>
+    return {
+      title: typeof record.title === 'string' ? record.title : 'Static MPA offline example',
+      body: typeof record.body === 'string' ? record.body : undefined,
+      data: payload,
+    }
+  }
+
+  return {
+    title: 'Static MPA offline example',
+    body: typeof payload === 'string' ? payload : undefined,
+    data: payload,
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/cache-inspection.ts b/examples/static-mpa-offline/src/globals/service-worker/cache-inspection.ts
new file mode 100644
index 00000000..b890ef31
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/cache-inspection.ts
@@ -0,0 +1,93 @@
+/// <reference lib="webworker" />
+
+/**
+ * Respond to demo cache-inspection requests from controlled pages.
+ *
+ * This is intentionally diagnostic-only: it exposes cache names, request URLs,
+ * response status/type, selected headers, and approximate body size for caches
+ * owned by this example service worker.
+ */
+
+export type CacheInspectionConfig = {
+  cachePrefixes: string[]
+}
+
+export function handleCacheInspectionMessage (
+  config: CacheInspectionConfig,
+  event: ExtendableMessageEvent
+): boolean {
+  if (event.data?.type !== 'DOMSTACK_INSPECT_CACHES') return false
+
+  event.waitUntil((async () => {
+    const inspection = await inspectOwnedCaches(config)
+    event.source?.postMessage({
+      id: event.data.id,
+      payload: inspection,
+      type: 'DOMSTACK_CACHE_INSPECTION_RESULT',
+    })
+  })())
+
+  return true
+}
+
+async function inspectOwnedCaches (config: CacheInspectionConfig): Promise<unknown> {
+  const cacheNames = (await caches.keys())
+    .filter(name => config.cachePrefixes.some(prefix => name.startsWith(prefix)))
+    .sort()
+
+  return {
+    generatedAt: new Date().toISOString(),
+    caches: await Promise.all(cacheNames.map(inspectCache)),
+  }
+}
+
+async function inspectCache (name: string): Promise<unknown> {
+  const cache = await caches.open(name)
+  const requests = await cache.keys()
+  const entries = await Promise.all(requests.map(request => inspectCacheEntry(cache, request)))
+
+  return {
+    name,
+    entries: entries.sort((a, b) => a.url.localeCompare(b.url)),
+  }
+}
+
+async function inspectCacheEntry (cache: Cache, request: Request): Promise<{
+  bodyBytes: number | null
+  contentLength: string | null
+  contentType: string | null
+  status: number
+  type: ResponseType
+  url: string
+}> {
+  const response = await cache.match(request)
+  if (!response) {
+    return {
+      bodyBytes: null,
+      contentLength: null,
+      contentType: null,
+      status: 0,
+      type: 'error',
+      url: request.url,
+    }
+  }
+
+  const bodyBytes = await estimateBodyBytes(response)
+
+  return {
+    bodyBytes,
+    contentLength: response.headers.get('content-length'),
+    contentType: response.headers.get('content-type'),
+    status: response.status,
+    type: response.type,
+    url: request.url,
+  }
+}
+
+async function estimateBodyBytes (response: Response): Promise<number | null> {
+  try {
+    return (await response.clone().arrayBuffer()).byteLength
+  } catch {
+    return null
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/clients.ts b/examples/static-mpa-offline/src/globals/service-worker/clients.ts
new file mode 100644
index 00000000..13773bf4
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/clients.ts
@@ -0,0 +1,31 @@
+/// <reference lib="webworker" />
+
+/**
+ * Window-client helpers for service-worker-to-page communication.
+ *
+ * Related functions:
+ * - `postToWindowClients()` broadcasts background event messages to open pages.
+ *
+ * MDN quick links:
+ * - Clients: https://developer.mozilla.org/en-US/docs/Web/API/Clients
+ * - Client: https://developer.mozilla.org/en-US/docs/Web/API/Client
+ * - WindowClient: https://developer.mozilla.org/en-US/docs/Web/API/WindowClient
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+/**
+ * Broadcast a structured-cloneable message to every same-origin window client.
+ *
+ * See MDN Client.postMessage(): https://developer.mozilla.org/en-US/docs/Web/API/Client/postMessage
+ */
+export async function postToWindowClients (message: Record<string, unknown>): Promise<void> {
+  const clients = await self.clients.matchAll({
+    includeUncontrolled: true,
+    type: 'window',
+  })
+
+  for (const client of clients) {
+    client.postMessage(message)
+  }
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/fetch-handlers.ts b/examples/static-mpa-offline/src/globals/service-worker/fetch-handlers.ts
new file mode 100644
index 00000000..6d235da5
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/fetch-handlers.ts
@@ -0,0 +1,166 @@
+/// <reference lib="webworker" />
+
+import {
+  getRuntimeStrategy,
+  getServiceWorkerPolicyEntry,
+  matchInPrecache,
+} from './precache.ts'
+import {
+  cacheFirstRuntimeCache,
+  networkFirstRuntimeCache,
+} from './runtime-cache.ts'
+import type {
+  ActiveServiceWorkerConfig,
+  StaticMpaOfflineServiceWorkerPolicyEntry,
+} from '#service-worker-settings'
+
+/**
+ * Fetch-event routing for navigations and static subresources.
+ *
+ * Related functions:
+ * - `handleFetchEvent()` is the event-level router.
+ * - `handleNavigation()` handles MPA navigations and offline fallback policy.
+ * - `cacheFirst()` serves static subresources from precache when available.
+ * - `navigationCandidates()` mirrors Workbox-like URL variations for static MPAs.
+ *
+ * MDN quick links:
+ * - FetchEvent: https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent
+ * - respondWith(): https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith
+ * - preloadResponse: https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/preloadResponse
+ * - Request.destination: https://developer.mozilla.org/en-US/docs/Web/API/Request/destination
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+/**
+ * Route only same-origin GET requests that this service worker owns.
+ *
+ * See MDN `FetchEvent.respondWith()` constraints:
+ * https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith
+ */
+export function handleFetchEvent (config: ActiveServiceWorkerConfig, event: FetchEvent): void {
+  const { request } = event
+
+  if (request.method !== 'GET') return
+
+  const url = new URL(request.url)
+  if (url.origin !== self.location.origin) return
+
+  if (isDevelopmentRequest(url)) return
+
+  if (request.mode === 'navigate') {
+    event.respondWith(handleNavigation(config, request, event.preloadResponse, event))
+    return
+  }
+
+  event.respondWith(handleSubresource(config, request))
+}
+
+/** Serve cached navigations first, then network/preload, then configured offline fallback. */
+async function handleNavigation (
+  config: ActiveServiceWorkerConfig,
+  request: Request,
+  preloadResponsePromise: Promise<Response | undefined>,
+  event: FetchEvent
+): Promise<Response> {
+  event.waitUntil(preloadResponsePromise.catch(() => undefined))
+
+  const cached = await matchNavigation(config, request)
+  if (cached) return cached
+
+  try {
+    if (shouldRuntimeCacheRequest(config, request)) {
+      return await networkFirstRuntimeCache(config, request, preloadResponsePromise)
+    }
+
+    const preloadResponse = await preloadResponsePromise
+    if (preloadResponse) return preloadResponse
+
+    return await fetch(request)
+  } catch (error) {
+    const fallback = await matchInPrecache(config, config.policy.offlineFallbackUrl)
+    if (fallback) return fallback
+
+    throw error
+  }
+}
+
+async function handleSubresource (config: ActiveServiceWorkerConfig, request: Request): Promise<Response> {
+  if (shouldRuntimeCacheRequest(config, request)) {
+    return await cacheFirstRuntimeCache(config, request)
+  }
+
+  return await cacheFirstStaticSubresource(config, request)
+}
+
+/** Serve manifest-known static subresources from precache, otherwise fall through to network. */
+async function cacheFirstStaticSubresource (config: ActiveServiceWorkerConfig, request: Request): Promise<Response> {
+  const cached = await matchInPrecache(config, request.url)
+  if (cached) return cached
+
+  try {
+    return await fetch(request)
+  } catch {
+    return Response.error()
+  }
+}
+
+async function matchNavigation (config: ActiveServiceWorkerConfig, request: Request): Promise<Response | undefined> {
+  for (const url of navigationCandidates(new URL(request.url))) {
+    const cached = await matchInPrecache(config, url)
+    if (cached) return cached
+  }
+
+  return undefined
+}
+
+/** Generate static MPA URL candidates, similar to Workbox's precache URL variations. */
+function navigationCandidates (url: URL): string[] {
+  const withoutIgnoredParams = new URL(url.href)
+  withoutIgnoredParams.hash = ''
+  for (const param of Array.from(withoutIgnoredParams.searchParams.keys())) {
+    if (/^utm_/.test(param) || param === 'fbclid') {
+      withoutIgnoredParams.searchParams.delete(param)
+    }
+  }
+
+  const pathname = withoutIgnoredParams.pathname
+  const candidates = new Set<string>()
+
+  candidates.add(withoutIgnoredParams.pathname + withoutIgnoredParams.search)
+
+  if (pathname.endsWith('/')) {
+    candidates.add(pathname + 'index.html')
+  } else {
+    candidates.add(pathname + '/')
+    candidates.add(pathname + '.html')
+    candidates.add(pathname + '/index.html')
+  }
+
+  if (pathname === '/') candidates.add('/index.html')
+
+  return Array.from(candidates)
+}
+
+function isDevelopmentRequest (url: URL): boolean {
+  return url.pathname.startsWith('/__bs/') ||
+    url.pathname.startsWith('/browser-sync/') ||
+    url.pathname === '/browser-sync-client.js'
+}
+
+function shouldRuntimeCacheRequest (config: ActiveServiceWorkerConfig, request: Request): boolean {
+  const policyEntry = getRequestPolicyEntry(config, request)
+  return policyEntry ? getRuntimeStrategy(config, policyEntry) === 'runtime' : false
+}
+
+function getRequestPolicyEntry (config: ActiveServiceWorkerConfig, request: Request): StaticMpaOfflineServiceWorkerPolicyEntry | undefined {
+  const directEntry = getServiceWorkerPolicyEntry(config, request.url)
+  if (directEntry) return directEntry
+
+  if (!request.referrer) return undefined
+
+  const referrer = new URL(request.referrer)
+  if (referrer.origin !== self.location.origin) return undefined
+
+  return getServiceWorkerPolicyEntry(config, referrer.href)
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/lifecycle.ts b/examples/static-mpa-offline/src/globals/service-worker/lifecycle.ts
new file mode 100644
index 00000000..88ccf8cc
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/lifecycle.ts
@@ -0,0 +1,47 @@
+/// <reference lib="webworker" />
+
+import {
+  activatePrecache,
+  deleteOwnedCaches,
+} from './precache.ts'
+import type {
+  ActiveServiceWorkerConfig,
+  ServiceWorkerConfig,
+} from '#service-worker-settings'
+
+/**
+ * Service-worker lifecycle helpers that are independent of fetch routing.
+ *
+ * Related functions:
+ * - `activateWorker()` enables navigation preload, cleans precache state, and claims clients.
+ * - `resetServiceWorker()` clears owned caches and unregisters this worker.
+ *
+ * MDN quick links:
+ * - install event: https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/install_event
+ * - activate event: https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/activate_event
+ * - Clients.claim(): https://developer.mozilla.org/en-US/docs/Web/API/Clients/claim
+ * - NavigationPreloadManager: https://developer.mozilla.org/en-US/docs/Web/API/NavigationPreloadManager
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+/**
+ * Complete activation work after install succeeds.
+ *
+ * `clients.claim()` lets this active worker control existing clients:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Clients/claim
+ */
+export async function activateWorker (config: ActiveServiceWorkerConfig): Promise<void> {
+  if (self.registration.navigationPreload) {
+    await self.registration.navigationPreload.enable()
+  }
+
+  await activatePrecache(config)
+  await self.clients.claim()
+}
+
+/** Remove this worker and its owned caches. */
+export async function resetServiceWorker (config: ServiceWorkerConfig): Promise<void> {
+  await deleteOwnedCaches(config)
+  await self.registration.unregister()
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/precache.ts b/examples/static-mpa-offline/src/globals/service-worker/precache.ts
new file mode 100644
index 00000000..5773164c
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/precache.ts
@@ -0,0 +1,206 @@
+/// <reference lib="webworker" />
+
+import {
+  maxPrecacheBytes,
+  revisionParam,
+} from '#service-worker-settings'
+import type {
+  ActiveServiceWorkerConfig,
+  ServiceWorkerConfig,
+  StaticMpaOfflinePrecacheEntry,
+  StaticMpaOfflineRuntimeStrategy,
+  StaticMpaOfflineServiceWorkerPolicy,
+  StaticMpaOfflineServiceWorkerPolicyEntry,
+} from '#service-worker-settings'
+
+/**
+ * Injected-manifest-driven precache implementation for the static MPA example.
+ *
+ * The service worker consumes Domstack manifest entries directly and derives the
+ * small amount of cache behavior it needs from their resolved manifest vars.
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+type NavigationRoutePolicy = {
+  offline: boolean
+  pathname: string
+  precache: boolean
+}
+
+let currentPolicyVersion: string | undefined
+let currentUrlToEntry: Map<string, StaticMpaOfflineServiceWorkerPolicyEntry> | undefined
+let currentNavigationRoutes: NavigationRoutePolicy[] | undefined
+
+/** Install-time precache step. Rejecting here keeps the old worker active. */
+export async function installPrecache (config: ActiveServiceWorkerConfig): Promise<void> {
+  const cache = await caches.open(config.precacheName)
+
+  for (const entry of precacheEntries(config)) {
+    const cacheKey = precacheKey(entry)
+    const cached = await cache.match(cacheKey)
+    if (cached) continue
+
+    const request = new Request(entry.url, {
+      cache: 'reload',
+      credentials: 'same-origin',
+    })
+    const assetResponse = await fetch(request)
+
+    if (!assetResponse.ok) {
+      throw new Error(`Refusing to precache ${entry.url}: ${assetResponse.status}`)
+    }
+
+    await cache.put(cacheKey, assetResponse)
+  }
+
+  await caches.delete(config.runtimeCacheName)
+  await deleteOutdatedPrecacheEntries(config)
+  setCurrentPolicy(config.policy)
+}
+
+/** Activation-time cleanup for legacy caches and outdated revisioned entries. */
+export async function activatePrecache (config: ActiveServiceWorkerConfig): Promise<void> {
+  const cacheNames = await caches.keys()
+  await Promise.all(
+    cacheNames
+      .filter(name => name.startsWith(config.precacheName))
+      .filter(name => name !== config.precacheName)
+      .map(name => caches.delete(name))
+  )
+
+  await deleteOutdatedPrecacheEntries(config)
+}
+
+/** Match a public URL against the current precache policy and cache storage. */
+export async function matchInPrecache (config: ActiveServiceWorkerConfig, url: string): Promise<Response | undefined> {
+  const entry = getServiceWorkerPolicyEntry(config, url)
+  if (!entry || !shouldPrecache(config, entry)) return undefined
+
+  const cache = await caches.open(config.precacheName)
+  return cache.match(precacheKey(entry))
+}
+
+/** Return a manifest entry for a public URL. */
+export function getServiceWorkerPolicyEntry (
+  config: ActiveServiceWorkerConfig,
+  url: string
+): StaticMpaOfflineServiceWorkerPolicyEntry | undefined {
+  ensurePolicyMaps(config.policy)
+  return currentUrlToEntry?.get(normalizeCacheUrl(url))
+}
+
+/** Return the runtime strategy derived from a manifest entry and its route policy. */
+export function getRuntimeStrategy (
+  config: ActiveServiceWorkerConfig,
+  entry: StaticMpaOfflineServiceWorkerPolicyEntry
+): StaticMpaOfflineRuntimeStrategy | undefined {
+  const policy = entry.role === 'navigation'
+    ? navigationPolicy(entry)
+    : routePolicyForUrl(config.policy, entry.url)
+
+  if (!policy) return undefined
+  if (!policy.offline) return 'network-only'
+  if (!policy.precache) return 'runtime'
+  return undefined
+}
+
+/** Delete all cache names owned by this example's service worker. */
+export async function deleteOwnedCaches (config: ServiceWorkerConfig): Promise<void> {
+  const cacheNames = await caches.keys()
+  await Promise.all(
+    cacheNames
+      .filter(name => config.cachePrefixes.some(prefix => name.startsWith(prefix)))
+      .map(name => caches.delete(name))
+  )
+}
+
+async function deleteOutdatedPrecacheEntries (config: ActiveServiceWorkerConfig): Promise<void> {
+  const expectedCacheKeys = new Set(precacheEntries(config).map(entry => normalizeCacheUrl(precacheKey(entry))))
+  const cache = await caches.open(config.precacheName)
+  const requests = await cache.keys()
+
+  await Promise.all(
+    requests
+      .filter(request => !expectedCacheKeys.has(request.url))
+      .map(request => cache.delete(request))
+  )
+}
+
+function setCurrentPolicy (policy: StaticMpaOfflineServiceWorkerPolicy): void {
+  currentPolicyVersion = policy.version
+  currentUrlToEntry = new Map(
+    policy.entries.map(entry => [normalizeCacheUrl(entry.url), entry])
+  )
+  currentNavigationRoutes = navigationRoutes(policy)
+}
+
+function ensurePolicyMaps (policy: StaticMpaOfflineServiceWorkerPolicy): void {
+  if (currentPolicyVersion === policy.version) return
+  setCurrentPolicy(policy)
+}
+
+function precacheEntries (config: ActiveServiceWorkerConfig): StaticMpaOfflinePrecacheEntry[] {
+  return config.policy.entries.filter(entry => shouldPrecache(config, entry))
+}
+
+function shouldPrecache (
+  config: ActiveServiceWorkerConfig,
+  entry: StaticMpaOfflineServiceWorkerPolicyEntry
+): entry is StaticMpaOfflinePrecacheEntry {
+  if (!entry.revision) return false
+  if (entry.bytes && entry.bytes > maxPrecacheBytes) return false
+  if (entry.static !== true) return false
+  if (entry.kind === 'chunk') return true
+  if (getRuntimeStrategy(config, entry)) return false
+  if (entry.role === 'subresource') return true
+  return entry.manifestVars?.precache === true
+}
+
+function navigationRoutes (policy: StaticMpaOfflineServiceWorkerPolicy): NavigationRoutePolicy[] {
+  return policy.entries
+    .filter(entry => entry.role === 'navigation' && entry.manifestVars)
+    .map(entry => navigationPolicy(entry))
+    .filter(route => route !== undefined)
+    .sort((a, b) => b.pathname.length - a.pathname.length)
+}
+
+function navigationPolicy (entry: StaticMpaOfflineServiceWorkerPolicyEntry): NavigationRoutePolicy | undefined {
+  if (!entry.manifestVars) return undefined
+  return {
+    offline: entry.manifestVars.offline === true,
+    pathname: pathname(entry.url),
+    precache: entry.manifestVars.precache === true,
+  }
+}
+
+function routePolicyForUrl (
+  policy: StaticMpaOfflineServiceWorkerPolicy,
+  url: string
+): NavigationRoutePolicy | undefined {
+  ensurePolicyMaps(policy)
+  const requestPathname = pathname(url)
+  return currentNavigationRoutes?.find(route => routeContains(route.pathname, requestPathname))
+}
+
+function routeContains (routePathname: string, requestPathname: string): boolean {
+  if (routePathname === '/') return requestPathname === '/'
+  return requestPathname === routePathname || requestPathname.startsWith(routePathname)
+}
+
+function pathname (url: string): string {
+  return new URL(url, self.location.origin).pathname
+}
+
+function precacheKey (entry: StaticMpaOfflinePrecacheEntry): string {
+  const url = new URL(entry.url, self.location.origin)
+  url.hash = ''
+  if (!entry.urlRevisioned) url.searchParams.set(revisionParam, entry.revision)
+  return url.pathname + url.search
+}
+
+function normalizeCacheUrl (url: string): string {
+  const normalized = new URL(url, self.location.origin)
+  normalized.hash = ''
+  return normalized.href
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/runtime-cache.ts b/examples/static-mpa-offline/src/globals/service-worker/runtime-cache.ts
new file mode 100644
index 00000000..c27f8777
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/runtime-cache.ts
@@ -0,0 +1,86 @@
+/// <reference lib="webworker" />
+
+import type { ServiceWorkerConfig } from '#service-worker-settings'
+
+/**
+ * Runtime cache for demo routes that intentionally are not precached.
+ *
+ * The static MPA example uses this to show a second offline pattern: a page and
+ * its same-route subresources can be omitted from install-time precache, then
+ * learned after the user visits them online.
+ */
+
+/** Serve from network first and store successful responses for later offline visits. */
+export async function networkFirstRuntimeCache (
+  config: ServiceWorkerConfig,
+  request: Request,
+  preloadResponsePromise?: Promise<Response | undefined>
+): Promise<Response> {
+  const cached = await matchInRuntimeCache(config, request)
+
+  try {
+    const preloadResponse = preloadResponsePromise ? await preloadResponsePromise : undefined
+    if (preloadResponse) {
+      await cacheRuntimeResponse(config, request, preloadResponse.clone())
+      return preloadResponse
+    }
+
+    const response = await fetchRuntimeRequest(request)
+    await cacheRuntimeResponse(config, request, response.clone())
+    return response
+  } catch (error) {
+    if (cached) return cached
+    throw error
+  }
+}
+
+/** Serve from runtime cache first, fetching and storing the response on misses. */
+export async function cacheFirstRuntimeCache (
+  config: ServiceWorkerConfig,
+  request: Request
+): Promise<Response> {
+  const cached = await matchInRuntimeCache(config, request)
+  if (cached) return cached
+
+  try {
+    const response = await fetchRuntimeRequest(request)
+    await cacheRuntimeResponse(config, request, response.clone())
+    return response
+  } catch {
+    return Response.error()
+  }
+}
+
+async function matchInRuntimeCache (config: ServiceWorkerConfig, request: Request): Promise<Response | undefined> {
+  const cache = await caches.open(config.runtimeCacheName)
+  return cache.match(normalizeRuntimeRequest(request))
+}
+
+async function cacheRuntimeResponse (
+  config: ServiceWorkerConfig,
+  request: Request,
+  response: Response
+): Promise<void> {
+  if (!response.ok) return
+  if (response.type !== 'basic') return
+
+  const cache = await caches.open(config.runtimeCacheName)
+  await cache.put(normalizeRuntimeRequest(request), response)
+}
+
+function fetchRuntimeRequest (request: Request): Promise<Response> {
+  return fetch(new Request(request.url, {
+    cache: 'reload',
+    credentials: 'same-origin',
+    method: 'GET',
+  }))
+}
+
+function normalizeRuntimeRequest (request: Request): Request {
+  const url = new URL(request.url)
+  url.hash = ''
+  return new Request(url.href, {
+    credentials: 'same-origin',
+    method: 'GET',
+  })
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/service-worker-settings.ts b/examples/static-mpa-offline/src/globals/service-worker/service-worker-settings.ts
new file mode 100644
index 00000000..eeff1859
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/service-worker-settings.ts
@@ -0,0 +1,53 @@
+import type { DomstackManifestEntry } from '@domstack/static/types.ts'
+
+export const cachePrefix = 'domstack-static-mpa'
+export const maxPrecacheBytes = 2 * 1024 * 1024
+export const offlineFallbackUrl = '/offline/'
+export const offlineRecheckIntervalMs = 5000
+export const offlineStorageKey = `${cachePrefix}-offline`
+export const onlineCheckTimeoutMs = 3000
+export const precacheName = `${cachePrefix}-precache`
+export const revisionParam = '__DOMSTACK_REVISION__'
+export const runtimeCacheName = `${cachePrefix}-runtime`
+export const serviceWorkerNotificationTag = 'domstack-static-mpa-offline'
+export const serviceWorkerPolicyDefineName = '__DOMSTACK_SERVICE_WORKER_POLICY__'
+
+export const cachePrefixes = [precacheName, runtimeCacheName] as const
+
+export type StaticMpaOfflineRuntimeStrategy = 'network-only' | 'runtime'
+
+export type StaticMpaOfflineManifestVars = {
+  offline?: boolean
+  precache?: boolean
+}
+
+export type StaticMpaOfflinePageVars = StaticMpaOfflineManifestVars & {
+  layout?: 'root' | 'admin' | 'progressive-cache'
+  title?: string
+}
+
+export type StaticMpaOfflinePolicy = {
+  offlineFallbackUrl: string
+}
+
+export type ServiceWorkerConfig = {
+  cachePrefixes: string[]
+  precacheName: string
+  runtimeCacheName: string
+}
+
+export type ActiveServiceWorkerConfig = ServiceWorkerConfig & {
+  policy: StaticMpaOfflineServiceWorkerPolicy
+}
+
+export type StaticMpaOfflineServiceWorkerPolicy = {
+  version: string
+  entries: StaticMpaOfflineServiceWorkerPolicyEntry[]
+  offlineFallbackUrl: string
+}
+
+export type StaticMpaOfflineServiceWorkerPolicyEntry = DomstackManifestEntry<StaticMpaOfflineManifestVars>
+
+export type StaticMpaOfflinePrecacheEntry = StaticMpaOfflineServiceWorkerPolicyEntry & {
+  revision: string
+}
diff --git a/examples/static-mpa-offline/src/globals/service-worker/service-worker.ts b/examples/static-mpa-offline/src/globals/service-worker/service-worker.ts
new file mode 100644
index 00000000..881bc346
--- /dev/null
+++ b/examples/static-mpa-offline/src/globals/service-worker/service-worker.ts
@@ -0,0 +1,105 @@
+/// <reference lib="webworker" />
+
+import { handleCacheInspectionMessage } from './cache-inspection.ts'
+import {
+  handlePeriodicSyncEvent,
+  handlePushEvent,
+  handleSyncEvent,
+  type PushEventLike,
+  type SyncEventLike,
+} from './background-events.ts'
+import { handleFetchEvent } from './fetch-handlers.ts'
+import {
+  activateWorker,
+  resetServiceWorker,
+} from './lifecycle.ts'
+import { installPrecache } from './precache.ts'
+import {
+  cachePrefixes,
+  precacheName,
+  runtimeCacheName,
+} from '#service-worker-settings'
+import type {
+  ActiveServiceWorkerConfig,
+  ServiceWorkerConfig,
+  StaticMpaOfflineServiceWorkerPolicy,
+} from '#service-worker-settings'
+
+/**
+ * Static MPA service-worker entrypoint.
+ *
+ * This file owns example-specific config and event wiring. Implementation
+ * details live in focused modules so caching, fetch routing, lifecycle reset,
+ * client messaging, and optional background events can evolve independently.
+ *
+ * MDN quick links:
+ * - Service Worker API: https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+ * - ServiceWorkerGlobalScope: https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope
+ * - ExtendableEvent.waitUntil(): https://developer.mozilla.org/en-US/docs/Web/API/ExtendableEvent/waitUntil
+ * - skipWaiting(): https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
+ */
+
+declare const self: ServiceWorkerGlobalScope
+
+declare const __DOMSTACK_SERVICE_WORKER_POLICY__: StaticMpaOfflineServiceWorkerPolicy
+
+const config: ServiceWorkerConfig = {
+  cachePrefixes: [...cachePrefixes],
+  precacheName,
+  runtimeCacheName,
+}
+
+const policy = typeof __DOMSTACK_SERVICE_WORKER_POLICY__ === 'undefined'
+  ? undefined
+  : __DOMSTACK_SERVICE_WORKER_POLICY__
+
+if (policy) {
+  const activeConfig: ActiveServiceWorkerConfig = { ...config, policy }
+
+  self.addEventListener('install', event => {
+    event.waitUntil(installPrecache(activeConfig))
+  })
+
+  self.addEventListener('activate', event => {
+    event.waitUntil(activateWorker(activeConfig))
+  })
+
+  self.addEventListener('message', event => {
+    if (handleCacheInspectionMessage(activeConfig, event)) return
+
+    if (event.data?.type === 'SKIP_WAITING') {
+      event.waitUntil(self.skipWaiting())
+      return
+    }
+
+    if (event.data?.type === 'RESET_SERVICE_WORKER') {
+      event.waitUntil(resetServiceWorker(activeConfig))
+    }
+  })
+
+  self.addEventListener('fetch', event => {
+    handleFetchEvent(activeConfig, event)
+  })
+
+  self.addEventListener('push', event => {
+    event.waitUntil(handlePushEvent(event as PushEventLike))
+  })
+
+  self.addEventListener('sync', ((event: Event) => {
+    const syncEvent = event as SyncEventLike
+    syncEvent.waitUntil(handleSyncEvent(syncEvent))
+  }) as EventListener)
+
+  self.addEventListener('periodicsync', ((event: Event) => {
+    const periodicSyncEvent = event as SyncEventLike
+    periodicSyncEvent.waitUntil(handlePeriodicSyncEvent(periodicSyncEvent))
+  }) as EventListener)
+} else {
+  self.addEventListener('install', () => {
+    self.skipWaiting()
+  })
+
+  self.addEventListener('activate', event => {
+    event.waitUntil(resetServiceWorker(config))
+  })
+}
diff --git a/examples/static-mpa-offline/src/layouts/admin.layout.ts b/examples/static-mpa-offline/src/layouts/admin.layout.ts
new file mode 100644
index 00000000..8188def2
--- /dev/null
+++ b/examples/static-mpa-offline/src/layouts/admin.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Layout for protected/admin routes.
+ *
+ * These pages are marked network-only by default so the service worker does not
+ * store or replay potentially private content while offline.
+ */
+export const vars = {
+  offline: false,
+  precache: false,
+} satisfies StaticMpaOfflinePageVars
+
+/** Render admin page chrome while reusing the shared demo layout template. */
+const adminLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--admin',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Admin route',
+  })
+}
+
+export default adminLayout
diff --git a/examples/static-mpa-offline/src/layouts/progressive-cache.layout.ts b/examples/static-mpa-offline/src/layouts/progressive-cache.layout.ts
new file mode 100644
index 00000000..d0867ba1
--- /dev/null
+++ b/examples/static-mpa-offline/src/layouts/progressive-cache.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Layout for pages that should become available offline only after a visit.
+ *
+ * The route is allowed offline, but is not install-time precached. The service
+ * worker learns the page and same-route subresources through runtime caching.
+ */
+export const vars = {
+  offline: true,
+  precache: false,
+} satisfies StaticMpaOfflinePageVars
+
+/** Render progressive-cache page chrome while applying runtime-cache policy defaults. */
+const progressiveCacheLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--progressive-cache',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Progressive cache route',
+  })
+}
+
+export default progressiveCacheLayout
diff --git a/examples/static-mpa-offline/src/layouts/render-policy-layout.ts b/examples/static-mpa-offline/src/layouts/render-policy-layout.ts
new file mode 100644
index 00000000..61da1904
--- /dev/null
+++ b/examples/static-mpa-offline/src/layouts/render-policy-layout.ts
@@ -0,0 +1,51 @@
+import { html, raw, render } from 'fragtml'
+import type { HtmlResult } from 'fragtml/types.ts'
+
+/**
+ * Shared HTML shell used by the offline-policy demo layouts.
+ *
+ * Individual layouts provide policy vars and body classes; this helper owns the
+ * common document structure, stylesheet/script tags, home navigation, and child
+ * rendering for both Markdown and HTML page sources.
+ */
+export function renderPolicyLayout ({
+  bodyClass,
+  children,
+  scripts,
+  styles,
+  title,
+}: {
+  bodyClass: string
+  children: string | HtmlResult
+  scripts?: string[]
+  styles?: string[]
+  title: unknown
+}): string {
+  const head = html`
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>${String(title)}</title>
+      ${styles?.map(style => html`<link rel="stylesheet" href=${style} />`)}
+      ${scripts?.map(script => html`<script type="module" src=${script}></script>`)}
+    </head>
+  `
+
+  const body = html`
+    <body class=${bodyClass}>
+      <nav class="example-navigation mine-layout" aria-label="Example navigation">
+        <a class="home-button" href="/">Home</a>
+      </nav>
+      <main class="mine-layout">
+        ${typeof children === 'string' ? raw(children) : children}
+      </main>
+    </body>
+  `
+
+  return render(html`
+    <!doctype html>
+    <html lang="en">
+      ${head}
+      ${body}
+    </html>`)
+}
diff --git a/examples/static-mpa-offline/src/layouts/root.layout.ts b/examples/static-mpa-offline/src/layouts/root.layout.ts
new file mode 100644
index 00000000..4cc4eef7
--- /dev/null
+++ b/examples/static-mpa-offline/src/layouts/root.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Default layout for public offline-first pages.
+ *
+ * Pages using this layout are install-time precached by default, so they should
+ * be safe to serve immediately while offline.
+ */
+export const vars = {
+  offline: true,
+  precache: true,
+} satisfies StaticMpaOfflinePageVars
+
+/** Render the normal public page chrome and apply the shared navigation wrapper. */
+const rootLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--root',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Static MPA offline example',
+  })
+}
+
+export default rootLayout
diff --git a/examples/static-mpa-offline/src/offline/client.ts b/examples/static-mpa-offline/src/offline/client.ts
new file mode 100644
index 00000000..5a706bf1
--- /dev/null
+++ b/examples/static-mpa-offline/src/offline/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('offline')
diff --git a/examples/static-mpa-offline/src/offline/page.md b/examples/static-mpa-offline/src/offline/page.md
new file mode 100644
index 00000000..6a5e20ae
--- /dev/null
+++ b/examples/static-mpa-offline/src/offline/page.md
@@ -0,0 +1,4 @@
+# Offline
+
+The requested page is not in the offline cache and the network is unavailable.
+
diff --git a/examples/static-mpa-offline/src/offline/style.css b/examples/static-mpa-offline/src/offline/style.css
new file mode 100644
index 00000000..3fe90ad2
--- /dev/null
+++ b/examples/static-mpa-offline/src/offline/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: darkorange;
+}
diff --git a/examples/static-mpa-offline/src/page-client.ts b/examples/static-mpa-offline/src/page-client.ts
new file mode 100644
index 00000000..b7f611dc
--- /dev/null
+++ b/examples/static-mpa-offline/src/page-client.ts
@@ -0,0 +1,12 @@
+/// <reference lib="dom" />
+
+export function markPageClientLoaded (pageName: string): void {
+  const main = document.querySelector('main')
+  if (!main) return
+
+  const note = document.createElement('p')
+  note.className = 'page-client-note'
+  note.dataset.pageClient = pageName
+  note.textContent = `Page client loaded: ${pageName}`
+  main.append(note)
+}
diff --git a/examples/static-mpa-offline/src/page-style.css b/examples/static-mpa-offline/src/page-style.css
new file mode 100644
index 00000000..cd22656e
--- /dev/null
+++ b/examples/static-mpa-offline/src/page-style.css
@@ -0,0 +1,8 @@
+.page-client-note {
+  background: color-mix(in srgb, var(--page-accent, currentColor) 8%, transparent);
+}
+
+main h1 {
+  border-block-end: 0.125rem solid color-mix(in srgb, var(--page-accent, currentColor) 35%, transparent);
+  padding-block-end: 0.25rem;
+}
diff --git a/examples/static-mpa-offline/src/page.md b/examples/static-mpa-offline/src/page.md
new file mode 100644
index 00000000..e96e5773
--- /dev/null
+++ b/examples/static-mpa-offline/src/page.md
@@ -0,0 +1,85 @@
+# Static MPA Offline Example
+
+This small multi-page app demonstrates a production-oriented offline cache for static domstack output.
+
+- `/service-worker.js` is stable and un-hashed.
+- `/service-worker.js` receives finalized manifest data at build time.
+- Normal static pages and assets can reload offline.
+- Updates use an in-page prompt instead of a blocking dialog.
+- Watch mode disables service workers so local edits do not get stuck behind stale caches.
+- A bad service worker can be reset with `?reset-sw`.
+
+## Try it
+
+1. Run `npm run serve` in this example.
+2. Wait for the banner to say the offline cache is ready.
+3. Use DevTools to go offline.
+4. Reload the cached pages below.
+
+## Sample pages
+
+- [About the offline cache](./about/) — default policy: `offline: true`, `precache: true`.
+- [Offline fallback](./offline/) — fallback used when an uncached or network-only navigation fails offline.
+- [Admin / network-only page](./admin/) — uses the `admin` layout policy: `offline: false`, `precache: false`.
+- [Progressive cache assets](./progressive-cache/assets/) — uses the progressive-cache layout policy: `offline: true`, `precache: false`.
+- [Progressive cache asset details](./progressive-cache/assets/details/) — second progressive-cache page with its own image subresource.
+- [Progressive cache alpha](./progressive-cache/alpha/) — frontmatter selects the progressive-cache layout.
+- [Progressive cache beta](./progressive-cache/beta/) — second frontmatter-driven progressive-cache page.
+- [Progressive cache override](./progressive-cache/override/) — uses the progressive-cache layout, but overrides `precache: true` in `page.vars.ts`.
+- [Cache inspector](./cache-inspector/) — asks the service worker for cache names and cached response details.
+
+## Policy vars
+
+The example intentionally uses small, user-facing vars:
+
+```ts
+export type StaticMpaOfflinePageVars = {
+  offline?: boolean
+  precache?: boolean
+  layout?: 'root' | 'admin' | 'progressive-cache'
+}
+```
+
+Layouts export policy defaults with `export const vars`. For example, `src/layouts/root.layout.ts` makes normal pages available offline immediately:
+
+```ts
+export const vars = {
+  offline: true,
+  precache: true,
+}
+```
+
+`src/globals/domstack-manifest/domstack-manifest.settings.ts` selects the resolved `offline` and `precache` page variables for `entry.manifestVars`. The resolved variable cascade includes layout vars, page vars, and Markdown frontmatter.
+
+`src/globals/domstack-manifest/policy-build.ts` injects the finalized manifest entries into `/service-worker.js`. The service worker consumes those entries directly and derives cache behavior from their resolved `manifestVars`.
+
+## Layout policy examples
+
+The example layouts export these policy defaults:
+
+- `src/layouts/root.layout.ts`: `offline: true`, `precache: true`
+- `src/layouts/admin.layout.ts`: `offline: false`, `precache: false`
+- `src/layouts/progressive-cache.layout.ts`: `offline: true`, `precache: false`
+
+A page can select a layout in Markdown frontmatter:
+
+```md
+---
+title: Progressive cache alpha
+layout: progressive-cache
+---
+```
+
+A page can override a layout policy with `page.vars.ts`:
+
+```ts
+export default {
+  precache: true,
+}
+```
+
+## Runtime cache behavior
+
+Pages with `offline: true` and `precache: false` are skipped during install-time precaching. When visited online, the service worker stores the successful navigation in the runtime cache. Same-route subresources inherit the requesting page's generated runtime policy through `request.referrer`, because domstack does not yet emit complete page → subresource `dependencies` metadata.
+
+After visiting a runtime page online once, reload it offline to confirm it was learned at runtime.
diff --git a/examples/static-mpa-offline/src/progressive-cache/alpha/client.ts b/examples/static-mpa-offline/src/progressive-cache/alpha/client.ts
new file mode 100644
index 00000000..476d9d76
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/alpha/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache alpha')
diff --git a/examples/static-mpa-offline/src/progressive-cache/alpha/page.md b/examples/static-mpa-offline/src/progressive-cache/alpha/page.md
new file mode 100644
index 00000000..4e4ee202
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/alpha/page.md
@@ -0,0 +1,15 @@
+---
+title: Progressive cache alpha
+layout: progressive-cache
+---
+
+# Progressive cache alpha
+
+This page uses Markdown frontmatter to select `layout: progressive-cache`.
+
+That layout policy means:
+
+- `offline: true`
+- `precache: false`
+
+So this route should not be cached during service-worker install. Visit it online once, then reload it offline.
diff --git a/examples/static-mpa-offline/src/progressive-cache/alpha/style.css b/examples/static-mpa-offline/src/progressive-cache/alpha/style.css
new file mode 100644
index 00000000..b29e7cce
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/alpha/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: mediumseagreen;
+}
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/client.ts b/examples/static-mpa-offline/src/progressive-cache/assets/client.ts
new file mode 100644
index 00000000..657290c3
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache assets')
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/details/client.ts b/examples/static-mpa-offline/src/progressive-cache/assets/details/client.ts
new file mode 100644
index 00000000..3153126b
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/details/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../../page-client.ts'
+
+markPageClientLoaded('progressive-cache asset details')
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/details/details-badge.svg b/examples/static-mpa-offline/src/progressive-cache/assets/details/details-badge.svg
new file mode 100644
index 00000000..f8fd77ee
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/details/details-badge.svg
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 240" role="img" aria-labelledby="title desc">
+  <title id="title">Progressive cache details badge</title>
+  <desc id="desc">A green badge used to demonstrate a second progressive-cache page subresource.</desc>
+  <rect width="640" height="240" rx="32" fill="#167a3a"/>
+  <circle cx="120" cy="120" r="56" fill="#fff" opacity="0.9"/>
+  <path d="M88 120h64M120 88v64" fill="none" stroke="#167a3a" stroke-width="14" stroke-linecap="round"/>
+  <text x="210" y="112" fill="#fff" font-family="system-ui, sans-serif" font-size="42" font-weight="700">Details cached</text>
+  <text x="210" y="162" fill="#dcffe9" font-family="system-ui, sans-serif" font-size="24">A second learned page and image</text>
+</svg>
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/details/page.md b/examples/static-mpa-offline/src/progressive-cache/assets/details/page.md
new file mode 100644
index 00000000..181985fd
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/details/page.md
@@ -0,0 +1,10 @@
+# Progressive cache asset details
+
+This second page is also learned at runtime instead of precached.
+
+It has its own image subresource. Visit this page online once, then reload it offline to confirm both the HTML and image were cached by the runtime route.
+
+![Runtime cached green badge](./details-badge.svg)
+
+- [Back to progressive cache assets](../)
+
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/details/page.vars.ts b/examples/static-mpa-offline/src/progressive-cache/assets/details/page.vars.ts
new file mode 100644
index 00000000..d1b5119d
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/details/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'progressive-cache',
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/details/style.css b/examples/static-mpa-offline/src/progressive-cache/assets/details/style.css
new file mode 100644
index 00000000..3fcdaa25
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/details/style.css
@@ -0,0 +1,5 @@
+@import "../../../page-style.css";
+
+main {
+  --page-accent: royalblue;
+}
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/page.md b/examples/static-mpa-offline/src/progressive-cache/assets/page.md
new file mode 100644
index 00000000..904173c9
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/page.md
@@ -0,0 +1,10 @@
+# Progressive cache assets
+
+This page is intentionally **not** precached during service-worker install.
+
+Visit it while online, then go offline and reload it. The service worker should serve this page from the runtime cache because you already visited it.
+
+![Runtime cached blue badge](./runtime-badge.svg)
+
+- [Progressive cache asset details](./details/)
+
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/page.vars.ts b/examples/static-mpa-offline/src/progressive-cache/assets/page.vars.ts
new file mode 100644
index 00000000..d1b5119d
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'progressive-cache',
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/runtime-badge.svg b/examples/static-mpa-offline/src/progressive-cache/assets/runtime-badge.svg
new file mode 100644
index 00000000..87ebb98f
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/runtime-badge.svg
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 240" role="img" aria-labelledby="title desc">
+  <title id="title">Progressive cache badge</title>
+  <desc id="desc">A blue badge used to demonstrate progressive-cache subresources.</desc>
+  <rect width="640" height="240" rx="32" fill="#0b65c2"/>
+  <circle cx="120" cy="120" r="56" fill="#fff" opacity="0.9"/>
+  <path d="M94 124l18 18 38-48" fill="none" stroke="#0b65c2" stroke-width="14" stroke-linecap="round" stroke-linejoin="round"/>
+  <text x="210" y="112" fill="#fff" font-family="system-ui, sans-serif" font-size="42" font-weight="700">Progressive cache</text>
+  <text x="210" y="162" fill="#d7ecff" font-family="system-ui, sans-serif" font-size="24">Fetched online, available offline later</text>
+</svg>
diff --git a/examples/static-mpa-offline/src/progressive-cache/assets/style.css b/examples/static-mpa-offline/src/progressive-cache/assets/style.css
new file mode 100644
index 00000000..5503fb07
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/assets/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: slateblue;
+}
diff --git a/examples/static-mpa-offline/src/progressive-cache/beta/client.ts b/examples/static-mpa-offline/src/progressive-cache/beta/client.ts
new file mode 100644
index 00000000..58af6d44
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/beta/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache beta')
diff --git a/examples/static-mpa-offline/src/progressive-cache/beta/page.md b/examples/static-mpa-offline/src/progressive-cache/beta/page.md
new file mode 100644
index 00000000..90442c62
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/beta/page.md
@@ -0,0 +1,10 @@
+---
+title: Progressive cache beta
+layout: progressive-cache
+---
+
+# Progressive cache beta
+
+This is a second page using the same `progressive-cache` layout from frontmatter.
+
+It demonstrates that a layout-level policy can apply the same offline behavior to multiple pages without repeating a `page.vars.ts` file next to each page.
diff --git a/examples/static-mpa-offline/src/progressive-cache/beta/style.css b/examples/static-mpa-offline/src/progressive-cache/beta/style.css
new file mode 100644
index 00000000..b99f93e6
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/beta/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: teal;
+}
diff --git a/examples/static-mpa-offline/src/progressive-cache/override/client.ts b/examples/static-mpa-offline/src/progressive-cache/override/client.ts
new file mode 100644
index 00000000..041510a6
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/override/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache override')
diff --git a/examples/static-mpa-offline/src/progressive-cache/override/page.md b/examples/static-mpa-offline/src/progressive-cache/override/page.md
new file mode 100644
index 00000000..cf60b794
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/override/page.md
@@ -0,0 +1,16 @@
+---
+title: Progressive cache override
+layout: progressive-cache
+---
+
+# Progressive cache override
+
+This page uses the progressive-cache layout in frontmatter, but its sibling `page.vars.ts` overrides the layout policy:
+
+```ts
+export default {
+  precache: true,
+}
+```
+
+So unlike the other progressive-cache pages, this page should be available offline immediately after the service worker install finishes.
diff --git a/examples/static-mpa-offline/src/progressive-cache/override/page.vars.ts b/examples/static-mpa-offline/src/progressive-cache/override/page.vars.ts
new file mode 100644
index 00000000..951607e2
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/override/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaOfflinePageVars } from '#service-worker-settings'
+
+export default {
+  precache: true,
+} satisfies StaticMpaOfflinePageVars
diff --git a/examples/static-mpa-offline/src/progressive-cache/override/style.css b/examples/static-mpa-offline/src/progressive-cache/override/style.css
new file mode 100644
index 00000000..84d608ea
--- /dev/null
+++ b/examples/static-mpa-offline/src/progressive-cache/override/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: mediumvioletred;
+}
diff --git a/examples/static-mpa-offline/src/style.css b/examples/static-mpa-offline/src/style.css
new file mode 100644
index 00000000..83c2532b
--- /dev/null
+++ b/examples/static-mpa-offline/src/style.css
@@ -0,0 +1,5 @@
+@import "./page-style.css";
+
+main {
+  --page-accent: dodgerblue;
+}
diff --git a/examples/static-mpa-offline/tsconfig.json b/examples/static-mpa-offline/tsconfig.json
new file mode 100644
index 00000000..ec479d6a
--- /dev/null
+++ b/examples/static-mpa-offline/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "extends": "@voxpelli/tsconfig/node20.json",
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "exactOptionalPropertyTypes": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "lib": ["ES2024", "DOM"]
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "public"
+  ]
+}
diff --git a/examples/static-mpa-workbox-offline/DESIGN.md b/examples/static-mpa-workbox-offline/DESIGN.md
new file mode 100644
index 00000000..b26bc5cb
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/DESIGN.md
@@ -0,0 +1,112 @@
+# Static MPA Workbox Offline Design Notes
+
+## Status
+
+These notes describe the current Workbox offline example in `examples/static-mpa-workbox-offline`.
+
+The example keeps authored service-worker code while using Domstack's finalized manifest to generate the Workbox data.
+It does not use Workbox `injectManifest`, `self.__WB_MANIFEST`, `importScripts()`, or a runtime policy JSON fetch.
+
+## Current architecture
+
+Domstack builds a stable root service worker at `/service-worker.js`.
+The service worker is omitted from the Domstack manifest so its own output does not create a manifest/hash cycle.
+After the final manifest is built, `hooks.manifestBuilt` computes a Workbox-shaped policy and injects it into the final service-worker bundle with `defineServiceWorkerConstant()`.
+
+The injected policy has one Workbox-native field and a few app-specific route fields:
+
+```ts
+type StaticMpaWorkboxServiceWorkerPolicy = {
+  version: string
+  precacheManifest: WorkboxPrecacheEntry[]
+  runtimeUrls: string[]
+  networkOnlyUrls: string[]
+  offlineFallbackUrl: string
+}
+```
+
+`precacheManifest` is passed directly to `precacheAndRoute()`.
+The other fields are used by the app's Workbox `registerRoute()` calls and `offlineFallback()` recipe.
+
+## Manifest vars and policy
+
+The app exposes two page/layout vars to the manifest:
+
+```ts
+manifestVars: ['offline', 'precache']
+```
+
+The variable cascade is page → layout → global → default.
+Layout modules use this to define route-section defaults.
+Page vars or frontmatter can override those defaults for a single page.
+
+The root app policy carries the single offline fallback route:
+
+```ts
+policy: {
+  offlineFallbackUrl: '/offline/',
+}
+```
+
+## Workbox usage
+
+The service worker uses these Workbox APIs:
+
+- `precacheAndRoute()` for install-time precache.
+- `cleanupOutdatedCaches()` for old Workbox precache cleanup.
+- `offlineFallback()` for failed offline navigations.
+- `NetworkFirst` for progressive-cache routes.
+- `NetworkOnly` for network-only routes.
+- `CacheableResponsePlugin` to limit runtime cache writes to configured response statuses.
+- `ExpirationPlugin` to limit runtime cache age, entry count, and quota pressure.
+- `workbox-window` in the browser client for registration and update events.
+
+The example keeps Workbox's native precache shape:
+
+```ts
+type WorkboxPrecacheEntry = {
+  url: string
+  revision: string | null
+  integrity?: string
+}
+```
+
+Hashed URLs use `revision: null`.
+Unhashed URLs use the Domstack `revision` value.
+If Domstack emitted `integrity`, it is passed through to Workbox.
+
+## Runtime routes
+
+Pages with `offline: true` and `precache: false` become Workbox `NetworkFirst` runtime routes.
+Their HTML and same-section subresources can become available offline after a successful online visit.
+
+Pages with `offline: false` become navigation-only `NetworkOnly` routes.
+Failed offline navigations fall through to the configured offline fallback.
+
+Pages with `precache: true` and no runtime strategy are included in the Workbox precache when they are static, revisioned, and below the configured size limit.
+Chunks are precached in production builds so dynamic imports used by cached pages stay available offline.
+
+## Watch mode
+
+Watch mode is for editing, not offline testing.
+When `DOMSTACK_MANIFEST_ENABLED` is false, the worker installs as a cleanup worker, clears Workbox-owned caches, and does not register runtime caching routes.
+The browser client also unregisters existing workers and clears owned caches while watching.
+
+Use `npm --workspace @domstack/static-mpa-workbox-offline-example run serve` for offline-cache testing.
+
+## Update lifecycle
+
+The browser client uses `workbox-window` to register after load, detect waiting updates, and send `SKIP_WAITING` when the user accepts the update prompt.
+The page reloads once when Workbox reports that the new worker is controlling the page.
+
+Redundant worker transitions are logged to the console rather than shown as user-facing error states.
+
+## Recovery paths
+
+The example includes two recovery tiers.
+
+For recoverable mistakes where page JavaScript still runs, `?reset-sw` unregisters service workers, deletes this example's caches, removes the query parameter, and reloads.
+For severe mistakes, deploy `rescue-service-worker.js` at `/service-worker.js` to replace the broken worker with a no-op worker at the same registration URL.
+
+Do not change the service-worker URL during recovery.
+A no-op worker at a different URL leaves the broken registration active at the old URL.
diff --git a/examples/static-mpa-workbox-offline/README.md b/examples/static-mpa-workbox-offline/README.md
new file mode 100644
index 00000000..b0a02a17
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/README.md
@@ -0,0 +1,108 @@
+# Static MPA Workbox Offline Example 
+
+This example shows the same domstack static MPA offline policy model as `examples/static-mpa-offline`, but uses Workbox for the service-worker caching runtime.
+
+Key points:
+
+- Domstack emits a stable `/service-worker.js`.
+- The service worker is authored with normal Workbox calls such as `precacheAndRoute(precacheManifest)`.
+- `src/globals/domstack-manifest/domstack-manifest.settings.ts` uses `hooks.manifestBuilt` to inject a precomputed Workbox policy constant into `/service-worker.js`.
+- Layout vars define section-wide offline policy:
+  - `root.layout.ts`: `offline: true`, `precache: true`
+  - `progressive-cache.layout.ts`: `offline: true`, `precache: false`
+  - `admin.layout.ts`: `offline: false`, `precache: false`
+- Page vars/frontmatter can override layout vars through domstack's normal cascade.
+- Watch mode unregisters the worker and clears Workbox-owned caches to avoid stale dev state.
+- `?reset-sw` and `rescue-service-worker.js` are included as recovery paths.
+
+## Running
+
+```sh
+npm --workspace @domstack/static-mpa-workbox-offline-example run serve
+```
+
+Then open the served localhost URL, wait for the offline cache to be ready, and use DevTools to test offline reloads.
+
+Use watch mode only for editing:
+
+```sh
+npm --workspace @domstack/static-mpa-workbox-offline-example run watch
+```
+
+Watch mode does not inject production manifest policy into the service worker, so this example disables and unregisters service workers while watching.
+Use `serve` for offline-cache testing.
+
+## What this example proves
+
+This example uses the new manifest features together:
+
+- `role` marks navigations, subresources, workers, and metadata.
+- `static` filters cacheable build outputs.
+- `urlRevisioned` lets hashed outputs use Workbox `revision: null`.
+- `integrity` is passed through to Workbox precache entries.
+- `manifestVars` carries resolved page/layout policy vars to each entry.
+- root `policy` carries the app-level offline fallback route.
+- `hooks.manifestBuilt` injects Workbox-shaped generated data after the final manifest exists.
+
+## Workbox policy injection flow
+
+The manifest built hook computes policy from the finalized Domstack manifest and injects it into the final service-worker bundle:
+
+```ts
+context.defineServiceWorkerConstant('__DOMSTACK_WORKBOX_POLICY__', {
+  precacheManifest: [
+    { url: '/', revision: '...' },
+  ],
+  runtimeUrls: ['/progressive-cache/assets/'],
+  networkOnlyUrls: ['/admin/'],
+  offlineFallbackUrl: '/offline/',
+})
+```
+
+The authored service worker reads the injected constant, then passes the Workbox-native `precacheManifest` array directly to Workbox:
+
+```ts
+const policy = __DOMSTACK_WORKBOX_POLICY__
+precacheAndRoute(policy.precacheManifest)
+```
+
+This keeps Workbox data generated from domstack's final manifest without Workbox globbing, `self.__WB_MANIFEST`, `importScripts()`, top-level await, or a runtime policy fetch.
+
+## Pages in the sample app
+
+- `/` — home page and test instructions.
+- `/about/` — normal precached offline page.
+- `/offline/` — offline fallback page.
+- `/admin/` — admin page excluded from precache; offline reload should show `/offline/`.
+- `/progressive-cache/assets/` — page excluded from install-time precache but cached after the first online visit by Workbox `NetworkFirst`.
+- `/progressive-cache/assets/details/` — second progressive-cache page with its own image subresource.
+- `/progressive-cache/override/` — progressive-cache layout section page that opts back into precache.
+- `/cache-inspector/` — diagnostic page that asks the service worker for cache contents.
+
+## Recovery paths
+
+For recoverable mistakes where pages still load, visit:
+
+```txt
+/?reset-sw
+```
+
+For a truly bad service worker that breaks page loads, deploy `rescue-service-worker.js` at the exact production service-worker URL:
+
+```txt
+/service-worker.js
+```
+
+## Research references
+
+- <https://web.dev/learn/pwa/workbox>
+- <https://developer.chrome.com/docs/workbox/>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-precaching>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-routing>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-strategies>
+- <https://developer.chrome.com/docs/workbox/modules/workbox-build>
+- <https://developer.chrome.com/docs/workbox/handling-service-worker-updates>
+- <https://developer.chrome.com/docs/workbox/remove-buggy-service-workers>
+- <https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API>
+- `plans/workbox-workflow-integration.md`
+- `examples/static-mpa-offline/README.md`
diff --git a/examples/static-mpa-workbox-offline/package.json b/examples/static-mpa-workbox-offline/package.json
new file mode 100644
index 00000000..3dcd9079
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "@domstack/static-mpa-workbox-offline-example",
+    "version": "0.0.0",
+    "description": "Static MPA offline Workbox service worker example for domstack",
+  "type": "module",
+  "imports": {
+    "#service-worker-settings": "./src/globals/service-worker/service-worker-settings.ts"
+  },
+  "scripts": {
+    "start": "npm run serve",
+    "build": "npm run clean && domstack",
+    "clean": "rm -rf public && mkdir -p public",
+    "serve": "npm run clean && domstack --serve",
+    "watch": "npm run clean && domstack --watch"
+  },
+  "keywords": [
+    "domstack",
+    "service-worker",
+    "offline",
+    "pwa"
+  ],
+  "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
+  "license": "MIT",
+  "dependencies": {
+    "@domstack/static": "file:../../.",
+    "workbox-cacheable-response": "^7.4.1",
+    "workbox-core": "^7.4.1",
+    "workbox-expiration": "^7.4.1",
+    "workbox-precaching": "^7.4.1",
+    "workbox-recipes": "^7.4.1",
+    "workbox-routing": "^7.4.1",
+    "workbox-strategies": "^7.4.1",
+    "workbox-window": "^7.4.1"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
+  }
+}
diff --git a/examples/static-mpa-workbox-offline/rescue-service-worker.js b/examples/static-mpa-workbox-offline/rescue-service-worker.js
new file mode 100644
index 00000000..6fd54873
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/rescue-service-worker.js
@@ -0,0 +1,31 @@
+// Emergency replacement for a bad production service worker.
+//
+// To use: deploy this file's contents at the SAME URL as the broken worker:
+// /service-worker.js. Keeping the exact URL is critical; otherwise the broken
+// registration will continue controlling its old scope.
+//
+// This follows Workbox's documented recovery approach: install and activate
+// immediately, avoid a fetch handler entirely so requests pass through to the
+// browser/network, and reload controlled windows once the no-op worker is active.
+
+const CACHE_PREFIXES = ['domstack-workbox-static-mpa-precache', 'domstack-workbox-static-mpa-runtime']
+
+self.addEventListener('install', () => {
+  self.skipWaiting()
+})
+
+self.addEventListener('activate', event => {
+  event.waitUntil((async () => {
+    const cacheNames = await caches.keys()
+    await Promise.all(
+      cacheNames
+        .filter(name => CACHE_PREFIXES.some(prefix => name.startsWith(prefix)))
+        .map(name => caches.delete(name))
+    )
+
+    const windowClients = await self.clients.matchAll({ type: 'window' })
+    await Promise.all(
+      windowClients.map(windowClient => windowClient.navigate(windowClient.url))
+    )
+  })())
+})
diff --git a/examples/static-mpa-workbox-offline/src/about/client.ts b/examples/static-mpa-workbox-offline/src/about/client.ts
new file mode 100644
index 00000000..501ab0cb
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/about/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('about')
diff --git a/examples/static-mpa-workbox-offline/src/about/page.md b/examples/static-mpa-workbox-offline/src/about/page.md
new file mode 100644
index 00000000..941a71ba
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/about/page.md
@@ -0,0 +1,6 @@
+# About the offline cache
+
+This page is a second static MPA route. It should be available after the service worker installs successfully.
+
+The worker intentionally avoids caching data/API requests. It focuses on the static application surface: HTML, CSS, JavaScript, chunks, workers, and selected static files.
+
diff --git a/examples/static-mpa-workbox-offline/src/about/style.css b/examples/static-mpa-workbox-offline/src/about/style.css
new file mode 100644
index 00000000..6d94a4ae
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/about/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: seagreen;
+}
diff --git a/examples/static-mpa-workbox-offline/src/admin/client.ts b/examples/static-mpa-workbox-offline/src/admin/client.ts
new file mode 100644
index 00000000..a5861929
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/admin/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('admin')
diff --git a/examples/static-mpa-workbox-offline/src/admin/page.md b/examples/static-mpa-workbox-offline/src/admin/page.md
new file mode 100644
index 00000000..70345265
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/admin/page.md
@@ -0,0 +1,23 @@
+---
+title: Admin / network-only page
+---
+
+# Admin / network-only page
+
+This route demonstrates opting a section out of offline availability.
+
+Its sibling `page.vars.ts` selects the `admin` layout:
+
+```ts
+export default {
+  layout: 'admin',
+}
+```
+
+`src/layouts/admin.layout.ts` exports these layout vars:
+
+- `offline: false`
+- `precache: false`
+
+So `/admin/` should load while online, but an offline reload should show the offline fallback page instead of this page.
+
diff --git a/examples/static-mpa-workbox-offline/src/admin/page.vars.ts b/examples/static-mpa-workbox-offline/src/admin/page.vars.ts
new file mode 100644
index 00000000..17083364
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/admin/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'admin',
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/admin/style.css b/examples/static-mpa-workbox-offline/src/admin/style.css
new file mode 100644
index 00000000..02dfb14b
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/admin/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: crimson;
+}
diff --git a/examples/static-mpa-workbox-offline/src/cache-inspector/client.ts b/examples/static-mpa-workbox-offline/src/cache-inspector/client.ts
new file mode 100644
index 00000000..64f8e588
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/cache-inspector/client.ts
@@ -0,0 +1,62 @@
+/// <reference lib="dom" />
+
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('cache inspector')
+
+const workboxCacheInspectorButton = document.querySelector<HTMLButtonElement>('#inspect-caches')
+const workboxCacheInspectorOutput = document.querySelector<HTMLPreElement>('#cache-inspection-output')
+
+workboxCacheInspectorButton?.addEventListener('click', async () => {
+  writeOutput('Requesting cache details from the service worker…')
+
+  try {
+    writeOutput(JSON.stringify(await inspectWorkboxExampleCaches(), null, 2))
+  } catch (error) {
+    writeOutput(error instanceof Error ? error.message : String(error))
+  }
+})
+
+function writeOutput (message: string): void {
+  if (!workboxCacheInspectorOutput) return
+  workboxCacheInspectorOutput.textContent = message
+}
+
+async function inspectWorkboxExampleCaches (): Promise<unknown> {
+  if (!('serviceWorker' in navigator)) throw new Error('Service workers are not supported in this browser.')
+  if (!navigator.serviceWorker.controller) throw new Error('This page is not controlled by a service worker yet. Reload after the worker is ready.')
+
+  const id = crypto.randomUUID()
+
+  return await new Promise((resolve, reject) => {
+    const timeout = window.setTimeout(() => {
+      navigator.serviceWorker.removeEventListener('message', onMessage)
+      reject(new Error('Timed out waiting for service-worker cache details.'))
+    }, 5000)
+
+    function onMessage (event: MessageEvent): void {
+      const message = event.data
+      if (!isWorkboxCacheInspectionResult(message, id)) return
+
+      window.clearTimeout(timeout)
+      navigator.serviceWorker.removeEventListener('message', onMessage)
+      resolve(message.payload)
+    }
+
+    navigator.serviceWorker.addEventListener('message', onMessage)
+    navigator.serviceWorker.controller?.postMessage({
+      id,
+      type: 'DOMSTACK_INSPECT_CACHES',
+    })
+  })
+}
+
+function isWorkboxCacheInspectionResult (
+  message: unknown,
+  id: string
+): message is { payload: unknown } {
+  if (!message || typeof message !== 'object') return false
+  return 'type' in message && message.type === 'DOMSTACK_CACHE_INSPECTION_RESULT' &&
+    'id' in message && message.id === id &&
+    'payload' in message
+}
diff --git a/examples/static-mpa-workbox-offline/src/cache-inspector/page.html b/examples/static-mpa-workbox-offline/src/cache-inspector/page.html
new file mode 100644
index 00000000..8b102a56
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/cache-inspector/page.html
@@ -0,0 +1,7 @@
+<h1>Cache inspector</h1>
+
+<p>This page asks the active service worker for a diagnostic list of caches owned by this example.</p>
+
+<button type="button" id="inspect-caches">Inspect service-worker caches</button>
+
+<pre id="cache-inspection-output">Press the button to inspect cached files.</pre>
diff --git a/examples/static-mpa-workbox-offline/src/cache-inspector/page.vars.ts b/examples/static-mpa-workbox-offline/src/cache-inspector/page.vars.ts
new file mode 100644
index 00000000..900ec8c9
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/cache-inspector/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  title: 'Cache inspector',
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/cache-inspector/style.css b/examples/static-mpa-workbox-offline/src/cache-inspector/style.css
new file mode 100644
index 00000000..023710a9
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/cache-inspector/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: rebeccapurple;
+}
diff --git a/examples/static-mpa-workbox-offline/src/client.ts b/examples/static-mpa-workbox-offline/src/client.ts
new file mode 100644
index 00000000..968078da
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from './page-client.ts'
+
+markPageClientLoaded('home')
diff --git a/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts b/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
new file mode 100644
index 00000000..41087d69
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/domstack-manifest.settings.ts
@@ -0,0 +1,21 @@
+import type { DomstackManifestOptions } from '@domstack/static/types.ts'
+import type {
+  StaticMpaWorkboxManifestVars,
+  StaticMpaWorkboxPageVars,
+  StaticMpaWorkboxPolicy,
+} from '#service-worker-settings'
+import { offlineFallbackUrl } from '#service-worker-settings'
+import { emitWorkboxManifest } from './policy-build.ts'
+
+const settings = {
+  manifestVars: ['offline', 'precache'],
+  policy: {
+    offlineFallbackUrl,
+  },
+  hooks: {
+    manifestBuilt: [emitWorkboxManifest],
+  },
+  includeEntry: entry => entry.kind !== 'metadata' && entry.kind !== 'sourcemap',
+} satisfies DomstackManifestOptions<StaticMpaWorkboxPolicy, StaticMpaWorkboxManifestVars, StaticMpaWorkboxPageVars>
+
+export default settings
diff --git a/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/policy-build.ts b/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/policy-build.ts
new file mode 100644
index 00000000..6ba6442c
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/domstack-manifest/policy-build.ts
@@ -0,0 +1,121 @@
+import type {
+  DomstackManifest,
+  DomstackManifestBuiltHookContext,
+  DomstackManifestEntry,
+} from '@domstack/static/types.ts'
+import type {
+  StaticMpaWorkboxManifestVars,
+  StaticMpaWorkboxPolicy,
+  StaticMpaWorkboxServiceWorkerPolicy,
+  WorkboxPrecacheEntry,
+} from '#service-worker-settings'
+import {
+  maxPrecacheBytes,
+  offlineFallbackUrl,
+  workboxPolicyDefineName,
+} from '#service-worker-settings'
+
+/**
+ * Build-time Workbox manifest generation.
+ *
+ * The hook computes policy data consumed by the authored service worker.
+ * The `precacheManifest` field uses Workbox's native precache entry shape;
+ * runtime route lists and fallback URLs remain app/Domstack policy.
+ */
+
+/** Inject Workbox precache and route-policy data into `/service-worker.js`. */
+export async function emitWorkboxManifest (
+  context: DomstackManifestBuiltHookContext<StaticMpaWorkboxPolicy, StaticMpaWorkboxManifestVars>
+): Promise<void> {
+  const policy = buildWorkboxPolicy(context.manifest)
+  context.defineServiceWorkerConstant(workboxPolicyDefineName, policy)
+}
+
+function buildWorkboxPolicy (
+  manifest: DomstackManifest<StaticMpaWorkboxPolicy, StaticMpaWorkboxManifestVars>
+): StaticMpaWorkboxServiceWorkerPolicy {
+  const routes = navigationRoutes(manifest.entries)
+  return {
+    version: manifest.version,
+    precacheManifest: manifest.entries
+      .filter(entry => shouldPrecache(entry, runtimeStrategyFor(entry, routes)))
+      .map(toWorkboxPrecacheEntry),
+    runtimeUrls: manifest.entries
+      .filter(entry => runtimeStrategyFor(entry, routes) === 'runtime')
+      .map(entry => entry.url),
+    networkOnlyUrls: manifest.entries
+      .filter(entry => runtimeStrategyFor(entry, routes) === 'network-only')
+      .map(entry => entry.url),
+    offlineFallbackUrl: manifest.policy?.offlineFallbackUrl ?? offlineFallbackUrl,
+  }
+}
+
+function toWorkboxPrecacheEntry (entry: DomstackManifestEntry<StaticMpaWorkboxManifestVars>): WorkboxPrecacheEntry {
+  return {
+    url: entry.url,
+    revision: entry.urlRevisioned ? null : entry.revision,
+    ...(entry.integrity ? { integrity: entry.integrity } : {}),
+  }
+}
+
+type NavigationRoutePolicy = {
+  offline: boolean
+  pathname: string
+  precache: boolean
+}
+
+function navigationRoutes (entries: DomstackManifestEntry<StaticMpaWorkboxManifestVars>[]): NavigationRoutePolicy[] {
+  return entries
+    .filter(entry => entry.role === 'navigation' && entry.manifestVars)
+    .map(entry => ({
+      offline: entry.manifestVars?.offline === true,
+      pathname: pathname(entry.url),
+      precache: entry.manifestVars?.precache === true,
+    }))
+    .sort((a, b) => b.pathname.length - a.pathname.length)
+}
+
+function runtimeStrategyFor (
+  entry: DomstackManifestEntry<StaticMpaWorkboxManifestVars>,
+  routes: NavigationRoutePolicy[]
+): 'network-only' | 'runtime' | undefined {
+  const policy = entry.role === 'navigation'
+    ? navigationPolicy(entry)
+    : routes.find(route => routeContains(route.pathname, pathname(entry.url)))
+
+  if (!policy) return undefined
+  if (!policy.offline) return 'network-only'
+  if (!policy.precache) return 'runtime'
+  return undefined
+}
+
+function navigationPolicy (entry: DomstackManifestEntry<StaticMpaWorkboxManifestVars>): NavigationRoutePolicy | undefined {
+  if (!entry.manifestVars) return undefined
+  return {
+    offline: entry.manifestVars.offline === true,
+    pathname: pathname(entry.url),
+    precache: entry.manifestVars.precache === true,
+  }
+}
+
+function shouldPrecache (
+  entry: DomstackManifestEntry<StaticMpaWorkboxManifestVars>,
+  runtimeStrategy: 'network-only' | 'runtime' | undefined
+): boolean {
+  if (!entry.revision) return false
+  if (entry.bytes && entry.bytes > maxPrecacheBytes) return false
+  if (entry.static !== true) return false
+  if (entry.kind === 'chunk') return true
+  if (runtimeStrategy) return false
+  if (entry.role === 'subresource') return true
+  return entry.manifestVars?.precache === true
+}
+
+function routeContains (routePathname: string, requestPathname: string): boolean {
+  if (routePathname === '/') return requestPathname === '/'
+  return requestPathname === routePathname || requestPathname.startsWith(routePathname)
+}
+
+function pathname (url: string): string {
+  return new URL(url, 'https://example.invalid').pathname
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/connection-status.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/connection-status.ts
new file mode 100644
index 00000000..f9379c31
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/connection-status.ts
@@ -0,0 +1,172 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Online/offline indicator state for cached navigations.
+ *
+ * This module mostly trusts `navigator.onLine`, but remembers when the current
+ * tab observed offline so cached page-to-page navigations do not incorrectly
+ * reset the indicator to online. While offline, it periodically probes the
+ * origin to detect recovery when browser `online` events are unreliable.
+ */
+
+export type ConnectionStatusOptions = {
+  offlineRecheckIntervalMs: number
+  offlineStorageKey: string
+  onlineCheckTimeoutMs: number
+}
+
+let connectionStatusCheck = 0
+let connectionStatusOnline = navigator.onLine
+let offlineRecheckTimer: number | undefined
+let onlineCheckPromise: Promise<boolean> | undefined
+
+/** Register browser lifecycle listeners and render the initial connection state. */
+export function initializeConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  window.addEventListener('online', () => updateConnectionStatus(status, options))
+  window.addEventListener('offline', () => updateConnectionStatus(status, options))
+  window.addEventListener('focus', () => updateConnectionStatus(status, options))
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') {
+      updateConnectionStatus(status, options)
+    } else {
+      stopOfflineRecheck()
+    }
+  })
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => updateConnectionStatus(status, options), { once: true })
+  } else {
+    updateConnectionStatus(status, options)
+  }
+}
+
+/** Update the indicator from browser state, probing only after this tab observed offline. */
+function updateConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  if (!navigator.onLine) {
+    setConnectionStatus(status, options, false)
+    return
+  }
+
+  if (wasOfflineInThisTab(options)) {
+    setConnectionStatus(status, options, false)
+    verifyOfflineRecovery(status, options)
+    return
+  }
+
+  setConnectionStatus(status, options, true)
+}
+
+/** Persist and render the current connection state, starting/stopping recovery checks. */
+function setConnectionStatus (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions,
+  online: boolean
+): void {
+  connectionStatusOnline = online
+  rememberConnectionStatus(options, online)
+  status.showConnectionStatus(online)
+
+  if (online) {
+    stopOfflineRecheck()
+  } else {
+    startOfflineRecheck(status, options)
+  }
+}
+
+/** Start a low-frequency recovery probe while the tab is visible and marked offline. */
+function startOfflineRecheck (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  if (offlineRecheckTimer !== undefined) return
+  if (document.visibilityState === 'hidden') return
+
+  offlineRecheckTimer = window.setInterval(() => {
+    if (!connectionStatusOnline) verifyOfflineRecovery(status, options)
+  }, options.offlineRecheckIntervalMs)
+}
+
+/** Stop the offline recovery probe. */
+function stopOfflineRecheck (): void {
+  if (offlineRecheckTimer === undefined) return
+
+  window.clearInterval(offlineRecheckTimer)
+  offlineRecheckTimer = undefined
+}
+
+/** Probe the origin once and flip online only if the network check succeeds. */
+function verifyOfflineRecovery (
+  status: Pick<StatusBanner, 'showConnectionStatus'>,
+  options: ConnectionStatusOptions
+): void {
+  const check = ++connectionStatusCheck
+
+  verifyOnlineStatus(options).then(online => {
+    if (check !== connectionStatusCheck) return
+    if (online) setConnectionStatus(status, options, true)
+  }).catch(() => {
+    if (check !== connectionStatusCheck) return
+    setConnectionStatus(status, options, false)
+  })
+}
+
+/** Coalesce concurrent origin reachability checks into one in-flight request. */
+async function verifyOnlineStatus (options: ConnectionStatusOptions): Promise<boolean> {
+  if (onlineCheckPromise) return onlineCheckPromise
+
+  onlineCheckPromise = fetchOnlineStatus(options)
+  try {
+    return await onlineCheckPromise
+  } finally {
+    onlineCheckPromise = undefined
+  }
+}
+
+/** Return whether this tab previously observed offline state across cached navigations. */
+function wasOfflineInThisTab (options: ConnectionStatusOptions): boolean {
+  try {
+    return window.sessionStorage.getItem(options.offlineStorageKey) === 'true'
+  } catch {
+    return !connectionStatusOnline
+  }
+}
+
+/** Store offline state in sessionStorage so cached navigations preserve the indicator. */
+function rememberConnectionStatus (options: ConnectionStatusOptions, online: boolean): void {
+  try {
+    if (online) {
+      window.sessionStorage.removeItem(options.offlineStorageKey)
+    } else {
+      window.sessionStorage.setItem(options.offlineStorageKey, 'true')
+    }
+  } catch {
+    // Storage can be unavailable in private browsing or restrictive contexts.
+  }
+}
+
+/** Fetch the origin with cache bypass to confirm network reachability after offline state. */
+async function fetchOnlineStatus (options: ConnectionStatusOptions): Promise<boolean> {
+  const controller = new AbortController()
+  const timeout = window.setTimeout(() => controller.abort(), options.onlineCheckTimeoutMs)
+
+  try {
+    const url = new URL(window.location.origin)
+    url.searchParams.set('__domstack_online_check', String(Date.now()))
+
+    const response = await fetch(url.href, {
+      cache: 'no-store',
+      credentials: 'same-origin',
+      signal: controller.signal,
+    })
+
+    return response.ok
+  } finally {
+    window.clearTimeout(timeout)
+  }
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/global.client.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/global.client.ts
new file mode 100644
index 00000000..197ddd67
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/global.client.ts
@@ -0,0 +1,72 @@
+import { initializeConnectionStatus } from './connection-status.ts'
+import { initializeServiceWorkerEventMessages } from './service-worker-events.ts'
+import { registerServiceWorker } from './service-worker-registration.ts'
+import {
+  disableServiceWorkerForWatchMode,
+  resetServiceWorkerFromWindow,
+  shouldResetServiceWorker,
+} from './service-worker-reset.ts'
+import { createStatusBanner } from './status-banner.ts'
+import {
+  cachePrefixes,
+  offlineRecheckIntervalMs,
+  offlineStorageKey,
+  onlineCheckTimeoutMs,
+} from '#service-worker-settings'
+
+/**
+ * Browser entrypoint for the offline static MPA example.
+ *
+ * This file owns example-specific config and wires independent modules together:
+ * connection status, service-worker registration, reset/watch cleanup, and the
+ * in-page status UI. The modules receive only the config/UI capabilities they need.
+ */
+
+const config = {
+  cachePrefixes: [...cachePrefixes],
+  manifestEnabled: process.env.DOMSTACK_MANIFEST_ENABLED === 'true',
+  offlineRecheckIntervalMs,
+  offlineStorageKey,
+  onlineCheckTimeoutMs,
+  serviceWorkerScope: process.env.DOMSTACK_SERVICE_WORKER_SCOPE,
+  serviceWorkerUrl: process.env.DOMSTACK_SERVICE_WORKER_URL,
+}
+
+const status = createStatusBanner()
+
+initializeConnectionStatus(status, config)
+initializeServiceWorkerEventMessages(status)
+
+const { serviceWorkerScope, serviceWorkerUrl } = config
+
+if (serviceWorkerUrl && serviceWorkerScope && 'serviceWorker' in navigator) {
+  if (shouldResetServiceWorker()) {
+    try {
+      await resetServiceWorkerFromWindow(status, config)
+    } catch (error) {
+      console.error('Service worker reset failed', error)
+    }
+  } else if (!config.manifestEnabled) {
+    try {
+      await disableServiceWorkerForWatchMode(status, config)
+    } catch (error) {
+      console.error('Service worker watch-mode cleanup failed', error)
+    }
+  } else {
+    try {
+      await windowLoaded()
+      await registerServiceWorker(status, serviceWorkerUrl, serviceWorkerScope)
+    } catch (error) {
+      console.error('Service worker registration failed', error)
+    }
+  }
+}
+
+/** Resolve after the load event so service-worker registration avoids competing with first paint. */
+async function windowLoaded (): Promise<void> {
+  if (document.readyState === 'complete') return
+
+  await new Promise<void>(resolve => {
+    window.addEventListener('load', () => resolve(), { once: true })
+  })
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-events.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-events.ts
new file mode 100644
index 00000000..ea5c94f0
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-events.ts
@@ -0,0 +1,43 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Display optional service-worker background events in the example UI.
+ *
+ * The service worker can receive push, one-off sync, and periodic sync events.
+ * This module keeps those example-only messages separate from registration and
+ * update lifecycle code.
+ */
+
+/** Listen for background-event messages from the service worker and render/log them. */
+export function initializeServiceWorkerEventMessages (status: Pick<StatusBanner, 'showStatus'>): void {
+  if (!('serviceWorker' in navigator)) return
+
+  navigator.serviceWorker.addEventListener('message', event => {
+    const message = event.data
+    if (!isServiceWorkerEventMessage(message)) return
+
+    if (message.type === 'DOMSTACK_PUSH_RECEIVED') {
+      console.info('Service worker push event received', message.payload)
+      status.showStatus('Push event received by the service worker.', 'info')
+    }
+
+    if (message.type === 'DOMSTACK_SYNC_RECEIVED') {
+      console.info('Service worker sync event received', message.tag)
+      status.showStatus(`Sync event received: ${String(message.tag ?? 'untagged')}`, 'info')
+    }
+
+    if (message.type === 'DOMSTACK_PERIODIC_SYNC_RECEIVED') {
+      console.info('Service worker periodic sync event received', message.tag)
+      status.showStatus(`Periodic sync event received: ${String(message.tag ?? 'untagged')}`, 'info')
+    }
+  })
+}
+
+/** Narrow structured-clone messages to the simple event shape this example understands. */
+function isServiceWorkerEventMessage (value: unknown): value is {
+  payload?: unknown
+  tag?: unknown
+  type: string
+} {
+  return Boolean(value) && typeof value === 'object' && typeof (value as { type?: unknown }).type === 'string'
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-registration.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-registration.ts
new file mode 100644
index 00000000..259286a6
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-registration.ts
@@ -0,0 +1,116 @@
+import { Workbox } from 'workbox-window'
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Service-worker registration and update UX for the static MPA example.
+ *
+ * This module uses `workbox-window` to track browser registration, waiting
+ * worker prompts, and the one-time reload after a user-approved update takes
+ * control. It receives a UI interface from the entrypoint instead of importing
+ * a banner implementation.
+ */
+
+/** Register the service worker after page load and wire update lifecycle events. */
+export async function registerServiceWorker (
+  status: Pick<StatusBanner, 'showStatus'>,
+  url: string,
+  scope: string
+): Promise<void> {
+  const workbox = new Workbox(url, {
+    scope,
+    type: 'module',
+    updateViaCache: 'none',
+  })
+  const hadControllerAtRegistration = Boolean(navigator.serviceWorker.controller)
+  let applyingUpdate = false
+  let lifecycleStatusShown = false
+
+  const showLifecycleStatus = (...args: Parameters<StatusBanner['showStatus']>): void => {
+    lifecycleStatusShown = true
+    status.showStatus(...args)
+  }
+
+  workbox.addEventListener('installing', () => {
+    showLifecycleStatus('Installing offline cache…')
+  })
+
+  workbox.addEventListener('activated', event => {
+    if (!event.isUpdate) showLifecycleStatus('Offline cache is ready.', 'ready')
+  })
+
+  workbox.addEventListener('waiting', event => {
+    if (event.wasWaitingBeforeRegister) {
+      applyingUpdate = true
+      workbox.messageSkipWaiting()
+      showLifecycleStatus('Applying offline update from previous visit…', 'update')
+      return
+    }
+
+    lifecycleStatusShown = true
+    promptForUpdate(status, workbox, () => {
+      applyingUpdate = true
+    })
+  })
+
+  workbox.addEventListener('controlling', () => {
+    if (hadControllerAtRegistration || applyingUpdate) {
+      window.location.reload()
+      return
+    }
+
+    showLifecycleStatus('Offline cache is ready.', 'ready')
+  })
+
+  workbox.addEventListener('redundant', event => {
+    console.info('Service worker became redundant during registration.', event)
+  })
+
+  const registration = await workbox.register({ immediate: true })
+  await workbox.update()
+  if (lifecycleStatusShown) return
+
+  if (registration?.installing) {
+    status.showStatus('Installing offline cache…')
+    return
+  }
+
+  if (registration?.waiting) {
+    promptForUpdate(status, workbox, () => {
+      applyingUpdate = true
+    })
+    return
+  }
+
+  if (registration?.active) {
+    status.showStatus('Offline cache is ready.', 'ready')
+    return
+  }
+
+  status.showStatus('Service worker registered.', 'info')
+}
+
+/** Show the in-page update prompt for a newly installed waiting worker. */
+function promptForUpdate (
+  status: Pick<StatusBanner, 'showStatus'>,
+  workbox: Workbox,
+  onApplyUpdate: () => void
+): void {
+  const reload = document.createElement('button')
+  reload.type = 'button'
+  reload.textContent = 'Reload now'
+  reload.addEventListener('click', () => {
+    reload.disabled = true
+    onApplyUpdate()
+    workbox.messageSkipWaiting()
+    status.showStatus('Updating offline cache…', 'update')
+  })
+
+  const later = document.createElement('button')
+  later.type = 'button'
+  later.textContent = 'Later'
+  later.addEventListener('click', () => {
+    status.showStatus('Update will be applied after all tabs are closed.', 'info')
+  })
+
+  status.showStatus('A new offline version is available.', 'update', [reload, later])
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-reset.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-reset.ts
new file mode 100644
index 00000000..32dd4c63
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/service-worker-reset.ts
@@ -0,0 +1,71 @@
+import type { StatusBanner } from './status-banner.ts'
+
+/**
+ * Recovery and watch-mode cleanup helpers for sticky service-worker state.
+ *
+ * These paths intentionally live outside registration logic because they are
+ * destructive: they unregister workers, delete owned caches, and reload/navigate
+ * pages to escape stale or broken service-worker control.
+ */
+
+export type ServiceWorkerResetOptions = {
+  cachePrefixes: string[]
+}
+
+/** Return true when the current URL requests a client-side service-worker reset. */
+export function shouldResetServiceWorker (): boolean {
+  const params = new URLSearchParams(window.location.search)
+  return params.has('reset-sw') || params.has('reset-service-worker')
+}
+
+/** Reset service workers/caches from a page that still loads enough JS to recover. */
+export async function resetServiceWorkerFromWindow (
+  status: Pick<StatusBanner, 'showStatus'>,
+  options: ServiceWorkerResetOptions
+): Promise<void> {
+  status.showStatus('Resetting service worker and offline caches…', 'update')
+
+  await unregisterServiceWorkersAndDeleteCaches(options)
+
+  const url = new URL(window.location.href)
+  url.searchParams.delete('reset-sw')
+  url.searchParams.delete('reset-service-worker')
+  window.location.replace(url.href)
+}
+
+/** Clear production SW state during watch mode, where no domstack manifest is emitted. */
+export async function disableServiceWorkerForWatchMode (
+  status: Pick<StatusBanner, 'showStatus'>,
+  options: ServiceWorkerResetOptions
+): Promise<void> {
+  const hadController = Boolean(navigator.serviceWorker.controller)
+  await unregisterServiceWorkersAndDeleteCaches(options)
+
+  if (hadController) {
+    status.showStatus('Service worker disabled in watch mode. Reloading without offline cache…', 'update')
+    window.location.reload()
+    return
+  }
+
+  status.showStatus('Service worker disabled in watch mode. Use `npm run serve` to test offline caching.', 'info')
+}
+
+/** Unregister all same-origin service workers and delete caches matching owned prefixes. */
+async function unregisterServiceWorkersAndDeleteCaches (options: ServiceWorkerResetOptions): Promise<void> {
+  const registrations = await navigator.serviceWorker.getRegistrations()
+  for (const registration of registrations) {
+    registration.active?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    registration.waiting?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    registration.installing?.postMessage({ type: 'RESET_SERVICE_WORKER' })
+    await registration.unregister()
+  }
+
+  if ('caches' in window) {
+    const cacheNames = await caches.keys()
+    await Promise.all(
+      cacheNames
+        .filter(name => options.cachePrefixes.some(prefix => name.startsWith(prefix)))
+        .map(name => caches.delete(name))
+    )
+  }
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global-client/status-banner.ts b/examples/static-mpa-workbox-offline/src/globals/global-client/status-banner.ts
new file mode 100644
index 00000000..5c045740
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global-client/status-banner.ts
@@ -0,0 +1,73 @@
+/**
+ * Minimal status UI adapter used by the example client modules.
+ *
+ * Keeping this as a small interface lets lifecycle/connectivity modules receive
+ * UI capabilities as arguments instead of importing DOM rendering directly.
+ */
+
+export type StatusBanner = {
+  showConnectionStatus (online: boolean): void
+  showStatus (message: string, state?: string, actions?: HTMLElement[]): void
+}
+
+/** Create the default in-page banner implementation for this example. */
+export function createStatusBanner (): StatusBanner {
+  getStatusBanner()
+
+  return {
+    showConnectionStatus,
+    showStatus,
+  }
+}
+
+/** Render a status message and optional action buttons in the shared banner. */
+function showStatus (message: string, state = 'info', actions: HTMLElement[] = []): void {
+  const status = getStatusBanner()
+
+  status.dataset.state = state
+  status.replaceChildren(getConnectionIndicator())
+
+  const text = document.createElement('span')
+  text.textContent = message
+  status.append(text)
+
+  if (actions.length > 0) {
+    const actionList = document.createElement('span')
+    actionList.className = 'offline-status__actions'
+    actionList.append(...actions)
+    status.append(actionList)
+  }
+}
+
+/** Render the online/offline badge without changing the current status message. */
+function showConnectionStatus (online: boolean): void {
+  const indicator = getConnectionIndicator()
+  indicator.dataset.state = online ? 'online' : 'offline'
+  indicator.textContent = online ? 'Online' : 'Offline'
+}
+
+/** Return the shared status banner, creating it at the top of the body if needed. */
+function getStatusBanner (): HTMLElement {
+  let status = document.querySelector<HTMLElement>('.offline-status')
+  if (!status) {
+    status = document.createElement('div')
+    status.className = 'offline-status'
+    document.body.prepend(status)
+  }
+
+  return status
+}
+
+/** Return the connection badge, preserving it across banner re-renders. */
+function getConnectionIndicator (): HTMLElement {
+  let indicator = document.querySelector<HTMLElement>('.connection-status')
+  if (!indicator) {
+    indicator = document.createElement('span')
+    indicator.className = 'connection-status'
+  }
+
+  const status = getStatusBanner()
+  if (!status.contains(indicator)) status.prepend(indicator)
+
+  return indicator
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global.css b/examples/static-mpa-workbox-offline/src/globals/global.css
new file mode 100644
index 00000000..7f30a721
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global.css
@@ -0,0 +1,110 @@
+:root {
+  --offline-status-height: 4rem;
+  color-scheme: light dark;
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+
+body {
+  margin: 0;
+}
+
+body::before {
+  block-size: var(--offline-status-height);
+  content: "";
+  display: block;
+  flex: none;
+}
+
+main {
+  margin-inline: auto;
+  max-width: 42rem;
+  padding: 2rem;
+}
+
+a {
+  color: #0b65c2;
+}
+
+.example-navigation {
+  box-sizing: border-box;
+  margin-inline: auto;
+  max-width: 42rem;
+  padding: 1.5rem 2rem 0;
+}
+
+.home-button {
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  display: inline-block;
+  font-weight: 700;
+  padding: 0.375rem 0.75rem;
+  text-decoration: none;
+}
+
+.home-button:hover {
+  text-decoration: underline;
+}
+
+.page-client-note {
+  border-inline-start: 0.25rem solid color-mix(in srgb, currentColor 35%, transparent);
+  color: color-mix(in srgb, currentColor 70%, transparent);
+  font-size: 0.875rem;
+  margin-block-start: 2rem;
+  padding-inline-start: 0.75rem;
+}
+
+.offline-status {
+  align-items: center;
+  background: Canvas;
+  block-size: var(--offline-status-height);
+  border-block-end: 1px solid color-mix(in srgb, currentColor 20%, transparent);
+  box-sizing: border-box;
+  display: flex;
+  font-size: 0.875rem;
+  gap: 0.75rem;
+  inset-block-start: 0;
+  inset-inline: 0;
+  justify-content: space-between;
+  overflow: hidden;
+  padding: 0.75rem 2rem;
+  position: fixed;
+  z-index: 10;
+}
+
+.connection-status {
+  border: 1px solid color-mix(in srgb, currentColor 35%, transparent);
+  border-radius: 999px;
+  font-size: 0.75rem;
+  font-weight: 700;
+  padding: 0.125rem 0.5rem;
+}
+
+.connection-status[data-state="online"] {
+  color: green;
+}
+
+.connection-status[data-state="offline"] {
+  color: crimson;
+}
+
+.offline-status__actions {
+  display: inline-flex;
+  gap: 0.5rem;
+}
+
+.offline-status button {
+  cursor: pointer;
+}
+
+.offline-status[data-state="ready"] {
+  background: color-mix(in srgb, green 14%, transparent);
+}
+
+.offline-status[data-state="update"] {
+  background: color-mix(in srgb, orange 18%, transparent);
+}
+
+.offline-status[data-state="error"] {
+  background: color-mix(in srgb, red 16%, transparent);
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/global.vars.ts b/examples/static-mpa-workbox-offline/src/globals/global.vars.ts
new file mode 100644
index 00000000..a632b3fe
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/global.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'root',
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/globals/service-worker/background-events.ts b/examples/static-mpa-workbox-offline/src/globals/service-worker/background-events.ts
new file mode 100644
index 00000000..3254b2f7
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/service-worker/background-events.ts
@@ -0,0 +1,108 @@
+/// <reference lib="webworker" />
+
+/**
+ * Demo-only background event handlers for browser DevTools.
+ *
+ * Workbox does not provide generic push, one-off sync, or periodic sync
+ * handlers. The Workbox background-sync package is for replaying failed
+ * requests, so this example uses the platform events directly and forwards
+ * visible messages to open pages.
+ */
+
+/** Register native background-event handlers used by browser DevTools demos. */
+export function initializeBackgroundEventDemos (scope: ServiceWorkerGlobalScope): void {
+  scope.addEventListener('push', event => {
+    event.waitUntil(handlePush(scope, event as PushEventLike))
+  })
+
+  scope.addEventListener('sync', ((event: Event) => {
+    const syncEvent = event as TaggedExtendableEvent
+    syncEvent.waitUntil(handleSync(scope, syncEvent, 'DOMSTACK_SYNC_RECEIVED'))
+  }) as EventListener)
+
+  scope.addEventListener('periodicsync', ((event: Event) => {
+    const periodicSyncEvent = event as TaggedExtendableEvent
+    periodicSyncEvent.waitUntil(handleSync(scope, periodicSyncEvent, 'DOMSTACK_PERIODIC_SYNC_RECEIVED'))
+  }) as EventListener)
+}
+
+type PushEventLike = ExtendableEvent & {
+  data?: {
+    json: () => unknown
+    text: () => string
+  }
+}
+
+type TaggedExtendableEvent = ExtendableEvent & {
+  tag?: string
+}
+
+type ServiceWorkerEventMessage = {
+  payload?: unknown
+  tag?: string
+  type: 'DOMSTACK_PERIODIC_SYNC_RECEIVED' | 'DOMSTACK_PUSH_RECEIVED' | 'DOMSTACK_SYNC_RECEIVED'
+}
+
+async function handlePush (scope: ServiceWorkerGlobalScope, event: PushEventLike): Promise<void> {
+  const payload = readPushPayload(event)
+  await Promise.all([
+    postToWindowClients(scope, {
+      payload,
+      type: 'DOMSTACK_PUSH_RECEIVED',
+    }),
+    showPushNotification(scope, payload),
+  ])
+}
+
+async function handleSync (
+  scope: ServiceWorkerGlobalScope,
+  event: TaggedExtendableEvent,
+  type: ServiceWorkerEventMessage['type']
+): Promise<void> {
+  await postToWindowClients(scope, {
+    tag: event.tag,
+    type,
+  })
+}
+
+function readPushPayload (event: PushEventLike): unknown {
+  if (!event.data) return undefined
+
+  try {
+    return event.data.json()
+  } catch {
+    return event.data.text()
+  }
+}
+
+async function postToWindowClients (
+  scope: ServiceWorkerGlobalScope,
+  message: ServiceWorkerEventMessage
+): Promise<void> {
+  const clients = await scope.clients.matchAll({
+    includeUncontrolled: true,
+    type: 'window',
+  })
+
+  for (const client of clients) client.postMessage(message)
+}
+
+async function showPushNotification (scope: ServiceWorkerGlobalScope, payload: unknown): Promise<void> {
+  if (Notification.permission !== 'granted') return
+
+  await scope.registration.showNotification('Domstack push event', {
+    body: stringifyPushPayload(payload),
+    tag: 'domstack-push-demo',
+  })
+}
+
+function stringifyPushPayload (payload: unknown): string {
+  if (payload === undefined) return 'Push event received from DevTools.'
+  if (typeof payload === 'string') return payload
+
+  try {
+    return JSON.stringify(payload)
+  } catch {
+    return 'Push event received from DevTools.'
+  }
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/service-worker/cache-inspection.ts b/examples/static-mpa-workbox-offline/src/globals/service-worker/cache-inspection.ts
new file mode 100644
index 00000000..b890ef31
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/service-worker/cache-inspection.ts
@@ -0,0 +1,93 @@
+/// <reference lib="webworker" />
+
+/**
+ * Respond to demo cache-inspection requests from controlled pages.
+ *
+ * This is intentionally diagnostic-only: it exposes cache names, request URLs,
+ * response status/type, selected headers, and approximate body size for caches
+ * owned by this example service worker.
+ */
+
+export type CacheInspectionConfig = {
+  cachePrefixes: string[]
+}
+
+export function handleCacheInspectionMessage (
+  config: CacheInspectionConfig,
+  event: ExtendableMessageEvent
+): boolean {
+  if (event.data?.type !== 'DOMSTACK_INSPECT_CACHES') return false
+
+  event.waitUntil((async () => {
+    const inspection = await inspectOwnedCaches(config)
+    event.source?.postMessage({
+      id: event.data.id,
+      payload: inspection,
+      type: 'DOMSTACK_CACHE_INSPECTION_RESULT',
+    })
+  })())
+
+  return true
+}
+
+async function inspectOwnedCaches (config: CacheInspectionConfig): Promise<unknown> {
+  const cacheNames = (await caches.keys())
+    .filter(name => config.cachePrefixes.some(prefix => name.startsWith(prefix)))
+    .sort()
+
+  return {
+    generatedAt: new Date().toISOString(),
+    caches: await Promise.all(cacheNames.map(inspectCache)),
+  }
+}
+
+async function inspectCache (name: string): Promise<unknown> {
+  const cache = await caches.open(name)
+  const requests = await cache.keys()
+  const entries = await Promise.all(requests.map(request => inspectCacheEntry(cache, request)))
+
+  return {
+    name,
+    entries: entries.sort((a, b) => a.url.localeCompare(b.url)),
+  }
+}
+
+async function inspectCacheEntry (cache: Cache, request: Request): Promise<{
+  bodyBytes: number | null
+  contentLength: string | null
+  contentType: string | null
+  status: number
+  type: ResponseType
+  url: string
+}> {
+  const response = await cache.match(request)
+  if (!response) {
+    return {
+      bodyBytes: null,
+      contentLength: null,
+      contentType: null,
+      status: 0,
+      type: 'error',
+      url: request.url,
+    }
+  }
+
+  const bodyBytes = await estimateBodyBytes(response)
+
+  return {
+    bodyBytes,
+    contentLength: response.headers.get('content-length'),
+    contentType: response.headers.get('content-type'),
+    status: response.status,
+    type: response.type,
+    url: request.url,
+  }
+}
+
+async function estimateBodyBytes (response: Response): Promise<number | null> {
+  try {
+    return (await response.clone().arrayBuffer()).byteLength
+  } catch {
+    return null
+  }
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker-settings.ts b/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker-settings.ts
new file mode 100644
index 00000000..ed36e5ab
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker-settings.ts
@@ -0,0 +1,42 @@
+export const cachePrefix = 'domstack-workbox-static-mpa'
+export const maxPrecacheBytes = 2 * 1024 * 1024
+export const offlineFallbackUrl = '/offline/'
+export const offlineRecheckIntervalMs = 5000
+export const offlineStorageKey = `${cachePrefix}-offline`
+export const onlineCheckTimeoutMs = 3000
+export const runtimeCacheMaxAgeSeconds = 30 * 24 * 60 * 60
+export const runtimeCacheMaxEntries = 50
+export const runtimeCacheName = `${cachePrefix}-runtime`
+export const runtimeCacheableStatuses = [200] as const
+export const workboxOfflineFallbackCacheName = 'workbox-offline-fallbacks'
+export const workboxPolicyDefineName = '__DOMSTACK_WORKBOX_POLICY__'
+
+export const cachePrefixes = [cachePrefix, workboxOfflineFallbackCacheName] as const
+
+export type StaticMpaWorkboxManifestVars = {
+  offline?: boolean
+  precache?: boolean
+}
+
+export type StaticMpaWorkboxPageVars = StaticMpaWorkboxManifestVars & {
+  layout?: 'root' | 'admin' | 'progressive-cache'
+  title?: string
+}
+
+export type StaticMpaWorkboxPolicy = {
+  offlineFallbackUrl: string
+}
+
+export type WorkboxPrecacheEntry = {
+  integrity?: string
+  revision: string | null
+  url: string
+}
+
+export type StaticMpaWorkboxServiceWorkerPolicy = {
+  networkOnlyUrls: string[]
+  offlineFallbackUrl: string
+  precacheManifest: WorkboxPrecacheEntry[]
+  runtimeUrls: string[]
+  version: string
+}
diff --git a/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker.ts b/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker.ts
new file mode 100644
index 00000000..3782eb94
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/globals/service-worker/service-worker.ts
@@ -0,0 +1,128 @@
+/// <reference lib="webworker" />
+
+import { CacheableResponsePlugin } from 'workbox-cacheable-response'
+import { clientsClaim, setCacheNameDetails } from 'workbox-core'
+import { ExpirationPlugin } from 'workbox-expiration'
+import { handleCacheInspectionMessage } from './cache-inspection.ts'
+import { initializeBackgroundEventDemos } from './background-events.ts'
+import {
+  cleanupOutdatedCaches,
+  precacheAndRoute,
+} from 'workbox-precaching'
+import { offlineFallback } from 'workbox-recipes'
+import { registerRoute } from 'workbox-routing'
+import { NetworkFirst, NetworkOnly } from 'workbox-strategies'
+import {
+  cachePrefix,
+  cachePrefixes,
+  runtimeCacheMaxAgeSeconds,
+  runtimeCacheMaxEntries,
+  runtimeCacheName,
+  runtimeCacheableStatuses,
+  type StaticMpaWorkboxServiceWorkerPolicy,
+} from '#service-worker-settings'
+
+/**
+ * Workbox service-worker entrypoint for the static MPA offline example.
+ *
+ * Domstack's `manifestBuilt` hook computes final policy data from the build
+ * manifest and injects it into this final service-worker bundle. The
+ * Workbox-native `precacheManifest` field is passed directly to Workbox.
+ */
+
+export {}
+
+declare const self: ServiceWorkerGlobalScope
+declare const __DOMSTACK_WORKBOX_POLICY__: StaticMpaWorkboxServiceWorkerPolicy
+
+const manifestEnabled = process.env.DOMSTACK_MANIFEST_ENABLED === 'true'
+const manifestVersion = process.env.DOMSTACK_MANIFEST_VERSION ?? ''
+
+setCacheNameDetails({ prefix: cachePrefix })
+initializeBackgroundEventDemos(self)
+
+if (manifestEnabled) {
+  const policy = __DOMSTACK_WORKBOX_POLICY__
+  const runtimeStrategy = new NetworkFirst({
+    cacheName: runtimeCacheName,
+    plugins: [
+      new CacheableResponsePlugin({
+        statuses: [...runtimeCacheableStatuses],
+      }),
+      new ExpirationPlugin({
+        maxAgeSeconds: runtimeCacheMaxAgeSeconds,
+        maxEntries: runtimeCacheMaxEntries,
+        purgeOnQuotaError: true,
+      }),
+    ],
+  })
+  if (manifestVersion && policy.version !== manifestVersion) {
+    throw new Error('Generated Workbox policy version does not match the bundled domstack manifest version.')
+  }
+
+  const runtimeUrls = new Set(policy.runtimeUrls.map(normalizePath))
+  const networkOnlyUrls = new Set(policy.networkOnlyUrls.map(normalizePath))
+
+  cleanupOutdatedCaches()
+  precacheAndRoute(policy.precacheManifest, {
+    ignoreURLParametersMatching: [/^utm_/, /^fbclid$/],
+  })
+
+  registerRoute(
+    ({ request, url }) => request.mode === 'navigate' && runtimeUrls.has(normalizePath(url.pathname)),
+    runtimeStrategy
+  )
+
+  registerRoute(
+    ({ request, url }) => request.mode !== 'navigate' && runtimeUrls.has(normalizePath(url.pathname)),
+    runtimeStrategy
+  )
+
+  registerRoute(
+    ({ request, url }) => request.mode === 'navigate' && networkOnlyUrls.has(normalizePath(url.pathname)),
+    new NetworkOnly()
+  )
+
+  offlineFallback({
+    pageFallback: policy.offlineFallbackUrl,
+  })
+
+  clientsClaim()
+
+  self.addEventListener('message', event => {
+    if (handleCacheInspectionMessage({ cachePrefixes: [...cachePrefixes] }, event)) return
+
+    if (event.data?.type === 'SKIP_WAITING') {
+      event.waitUntil(self.skipWaiting())
+      return
+    }
+
+    if (event.data?.type === 'RESET_SERVICE_WORKER') {
+      event.waitUntil(resetServiceWorker())
+    }
+  })
+} else {
+  clientsClaim()
+
+  self.addEventListener('install', () => {
+    self.skipWaiting()
+  })
+
+  self.addEventListener('activate', event => {
+    event.waitUntil(resetServiceWorker())
+  })
+}
+
+async function resetServiceWorker (): Promise<void> {
+  const cacheNames = await caches.keys()
+  await Promise.all(
+    cacheNames
+      .filter(name => cachePrefixes.some(cachePrefix => name.startsWith(cachePrefix)))
+      .map(name => caches.delete(name))
+  )
+}
+
+function normalizePath (pathname: string): string {
+  if (pathname.endsWith('/index.html')) return pathname.slice(0, -'index.html'.length)
+  return pathname
+}
diff --git a/examples/static-mpa-workbox-offline/src/layouts/admin.layout.ts b/examples/static-mpa-workbox-offline/src/layouts/admin.layout.ts
new file mode 100644
index 00000000..a321b12f
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/layouts/admin.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Layout for protected/admin routes.
+ *
+ * These pages are marked network-only by default so Workbox does not store or
+ * replay potentially private content while offline.
+ */
+export const vars = {
+  offline: false,
+  precache: false,
+} satisfies StaticMpaWorkboxPageVars
+
+/** Render admin page chrome while reusing the shared demo layout template. */
+const adminLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--admin',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Admin route',
+  })
+}
+
+export default adminLayout
diff --git a/examples/static-mpa-workbox-offline/src/layouts/progressive-cache.layout.ts b/examples/static-mpa-workbox-offline/src/layouts/progressive-cache.layout.ts
new file mode 100644
index 00000000..b6439554
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/layouts/progressive-cache.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Layout for pages that should become available offline only after a visit.
+ *
+ * The route is allowed offline, but is not install-time precached. Workbox learns
+ * the page and same-route subresources through runtime caching.
+ */
+export const vars = {
+  offline: true,
+  precache: false,
+} satisfies StaticMpaWorkboxPageVars
+
+/** Render progressive-cache page chrome while applying runtime-cache policy defaults. */
+const progressiveCacheLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--progressive-cache',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Progressive cache route',
+  })
+}
+
+export default progressiveCacheLayout
diff --git a/examples/static-mpa-workbox-offline/src/layouts/render-policy-layout.ts b/examples/static-mpa-workbox-offline/src/layouts/render-policy-layout.ts
new file mode 100644
index 00000000..96febeb1
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/layouts/render-policy-layout.ts
@@ -0,0 +1,51 @@
+import { html, raw, render } from 'fragtml'
+import type { HtmlResult } from 'fragtml/types.ts'
+
+/**
+ * Shared HTML shell used by the Workbox offline-policy demo layouts.
+ *
+ * Individual layouts provide policy vars and body classes; this helper owns the
+ * common document structure, stylesheet/script tags, home navigation, and child
+ * rendering for both Markdown and HTML page sources.
+ */
+export function renderPolicyLayout ({
+  bodyClass,
+  children,
+  scripts,
+  styles,
+  title,
+}: {
+  bodyClass: string
+  children: string | HtmlResult
+  scripts?: string[]
+  styles?: string[]
+  title: unknown
+}): string {
+  const head = html`
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>${String(title)}</title>
+      ${styles?.map(style => html`<link rel="stylesheet" href=${style} />`)}
+      ${scripts?.map(script => html`<script type="module" src=${script}></script>`)}
+    </head>
+  `
+
+  const body = html`
+    <body class=${bodyClass}>
+      <nav class="example-navigation mine-layout" aria-label="Example navigation">
+        <a class="home-button" href="/">Home</a>
+      </nav>
+      <main class="mine-layout">
+        ${typeof children === 'string' ? raw(children) : children}
+      </main>
+    </body>
+  `
+
+  return render(html`
+    <!doctype html>
+    <html lang="en">
+      ${head}
+      ${body}
+    </html>`)
+}
diff --git a/examples/static-mpa-workbox-offline/src/layouts/root.layout.ts b/examples/static-mpa-workbox-offline/src/layouts/root.layout.ts
new file mode 100644
index 00000000..dc6bc813
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/layouts/root.layout.ts
@@ -0,0 +1,33 @@
+import type { HtmlResult } from 'fragtml/types.ts'
+import type { LayoutFunction } from '@domstack/static/types.ts'
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+import { renderPolicyLayout } from './render-policy-layout.ts'
+
+/**
+ * Default layout for public offline-first pages.
+ *
+ * Pages using this layout are included in the generated Workbox precache by
+ * default, so they should be safe to serve immediately while offline.
+ */
+export const vars = {
+  offline: true,
+  precache: true,
+} satisfies StaticMpaWorkboxPageVars
+
+/** Render the normal public page chrome and apply the shared navigation wrapper. */
+const rootLayout: LayoutFunction<Record<string, unknown>, string | HtmlResult, string> = ({
+  children,
+  scripts,
+  styles,
+  vars,
+}) => {
+  return renderPolicyLayout({
+    bodyClass: 'policy-layout policy-layout--root',
+    children,
+    scripts,
+    styles,
+    title: vars.title ?? 'Static MPA offline example',
+  })
+}
+
+export default rootLayout
diff --git a/examples/static-mpa-workbox-offline/src/offline/client.ts b/examples/static-mpa-workbox-offline/src/offline/client.ts
new file mode 100644
index 00000000..5a706bf1
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/offline/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../page-client.ts'
+
+markPageClientLoaded('offline')
diff --git a/examples/static-mpa-workbox-offline/src/offline/page.md b/examples/static-mpa-workbox-offline/src/offline/page.md
new file mode 100644
index 00000000..6a5e20ae
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/offline/page.md
@@ -0,0 +1,4 @@
+# Offline
+
+The requested page is not in the offline cache and the network is unavailable.
+
diff --git a/examples/static-mpa-workbox-offline/src/offline/style.css b/examples/static-mpa-workbox-offline/src/offline/style.css
new file mode 100644
index 00000000..3fe90ad2
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/offline/style.css
@@ -0,0 +1,5 @@
+@import "../page-style.css";
+
+main {
+  --page-accent: darkorange;
+}
diff --git a/examples/static-mpa-workbox-offline/src/page-client.ts b/examples/static-mpa-workbox-offline/src/page-client.ts
new file mode 100644
index 00000000..b7f611dc
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/page-client.ts
@@ -0,0 +1,12 @@
+/// <reference lib="dom" />
+
+export function markPageClientLoaded (pageName: string): void {
+  const main = document.querySelector('main')
+  if (!main) return
+
+  const note = document.createElement('p')
+  note.className = 'page-client-note'
+  note.dataset.pageClient = pageName
+  note.textContent = `Page client loaded: ${pageName}`
+  main.append(note)
+}
diff --git a/examples/static-mpa-workbox-offline/src/page-style.css b/examples/static-mpa-workbox-offline/src/page-style.css
new file mode 100644
index 00000000..cd22656e
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/page-style.css
@@ -0,0 +1,8 @@
+.page-client-note {
+  background: color-mix(in srgb, var(--page-accent, currentColor) 8%, transparent);
+}
+
+main h1 {
+  border-block-end: 0.125rem solid color-mix(in srgb, var(--page-accent, currentColor) 35%, transparent);
+  padding-block-end: 0.25rem;
+}
diff --git a/examples/static-mpa-workbox-offline/src/page.md b/examples/static-mpa-workbox-offline/src/page.md
new file mode 100644
index 00000000..e8d153ab
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/page.md
@@ -0,0 +1,86 @@
+# Static MPA Workbox Offline Example
+
+This small multi-page app demonstrates Workbox precaching and runtime caching driven by domstack's final build manifest.
+
+- `/service-worker.js` is stable and un-hashed.
+- The service worker source uses normal Workbox calls such as `precacheAndRoute(policy.precacheManifest)`.
+- `hooks.manifestBuilt` injects Workbox precache entries into the final service-worker bundle.
+- Normal static pages and assets can reload offline.
+- Updates use an in-page prompt instead of a blocking dialog.
+- Watch mode disables service workers so local edits do not get stuck behind stale caches.
+- A bad service worker can be reset with `?reset-sw`.
+
+## Try it
+
+1. Run `npm run serve` in this example.
+2. Wait for the banner to say the offline cache is ready.
+3. Use DevTools to go offline.
+4. Reload the cached pages below.
+
+## Sample pages
+
+- [About the offline cache](./about/) — default policy: `offline: true`, `precache: true`.
+- [Offline fallback](./offline/) — fallback used when an uncached or network-only navigation fails offline.
+- [Admin / network-only page](./admin/) — uses the `admin` layout policy: `offline: false`, `precache: false`.
+- [Progressive cache assets](./progressive-cache/assets/) — uses the progressive-cache layout policy: `offline: true`, `precache: false`.
+- [Progressive cache asset details](./progressive-cache/assets/details/) — second progressive-cache page with its own image subresource.
+- [Progressive cache alpha](./progressive-cache/alpha/) — frontmatter selects the progressive-cache layout.
+- [Progressive cache beta](./progressive-cache/beta/) — second frontmatter-driven progressive-cache page.
+- [Progressive cache override](./progressive-cache/override/) — uses the progressive-cache layout, but overrides `precache: true` in `page.vars.ts`.
+- [Cache inspector](./cache-inspector/) — asks the service worker for cache names and cached response details.
+
+## Policy vars
+
+The example intentionally uses small, user-facing vars:
+
+```ts
+export type StaticMpaWorkboxPageVars = {
+  offline?: boolean
+  precache?: boolean
+  layout?: 'root' | 'admin' | 'progressive-cache'
+}
+```
+
+Layouts export policy defaults with `export const vars`. For example, `src/layouts/root.layout.ts` makes normal pages available offline immediately:
+
+```ts
+export const vars = {
+  offline: true,
+  precache: true,
+}
+```
+
+`src/globals/domstack-manifest/domstack-manifest.settings.ts` selects the resolved `offline` and `precache` page variables for `entry.manifestVars`. The resolved variable cascade includes layout vars, page vars, and Markdown frontmatter.
+
+`src/globals/domstack-manifest/policy-build.ts` reads the finished manifest in a `manifestBuilt` hook and injects `__DOMSTACK_WORKBOX_POLICY__` into the final service-worker bundle. The service worker passes `policy.precacheManifest` directly to Workbox and uses the remaining policy fields to configure runtime routes and the offline fallback.
+
+## Layout policy examples
+
+The example layouts export these policy defaults:
+
+- `src/layouts/root.layout.ts`: `offline: true`, `precache: true`
+- `src/layouts/admin.layout.ts`: `offline: false`, `precache: false`
+- `src/layouts/progressive-cache.layout.ts`: `offline: true`, `precache: false`
+
+A page can select a layout in Markdown frontmatter:
+
+```md
+---
+title: Progressive cache alpha
+layout: progressive-cache
+---
+```
+
+A page can override a layout policy with `page.vars.ts`:
+
+```ts
+export default {
+  precache: true,
+}
+```
+
+## Runtime cache behavior
+
+Pages with `offline: true` and `precache: false` are skipped during install-time precaching. When visited online, Workbox stores matching navigations and same-route subresources with a `NetworkFirst` runtime strategy.
+
+After visiting a runtime page online once, reload it offline to confirm it was learned at runtime.
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/client.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/client.ts
new file mode 100644
index 00000000..476d9d76
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache alpha')
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/page.md b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/page.md
new file mode 100644
index 00000000..4e4ee202
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/page.md
@@ -0,0 +1,15 @@
+---
+title: Progressive cache alpha
+layout: progressive-cache
+---
+
+# Progressive cache alpha
+
+This page uses Markdown frontmatter to select `layout: progressive-cache`.
+
+That layout policy means:
+
+- `offline: true`
+- `precache: false`
+
+So this route should not be cached during service-worker install. Visit it online once, then reload it offline.
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/style.css b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/style.css
new file mode 100644
index 00000000..b29e7cce
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/alpha/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: mediumseagreen;
+}
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/client.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/client.ts
new file mode 100644
index 00000000..657290c3
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache assets')
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/client.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/client.ts
new file mode 100644
index 00000000..3153126b
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../../page-client.ts'
+
+markPageClientLoaded('progressive-cache asset details')
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/details-badge.svg b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/details-badge.svg
new file mode 100644
index 00000000..f8fd77ee
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/details-badge.svg
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 240" role="img" aria-labelledby="title desc">
+  <title id="title">Progressive cache details badge</title>
+  <desc id="desc">A green badge used to demonstrate a second progressive-cache page subresource.</desc>
+  <rect width="640" height="240" rx="32" fill="#167a3a"/>
+  <circle cx="120" cy="120" r="56" fill="#fff" opacity="0.9"/>
+  <path d="M88 120h64M120 88v64" fill="none" stroke="#167a3a" stroke-width="14" stroke-linecap="round"/>
+  <text x="210" y="112" fill="#fff" font-family="system-ui, sans-serif" font-size="42" font-weight="700">Details cached</text>
+  <text x="210" y="162" fill="#dcffe9" font-family="system-ui, sans-serif" font-size="24">A second learned page and image</text>
+</svg>
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.md b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.md
new file mode 100644
index 00000000..181985fd
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.md
@@ -0,0 +1,10 @@
+# Progressive cache asset details
+
+This second page is also learned at runtime instead of precached.
+
+It has its own image subresource. Visit this page online once, then reload it offline to confirm both the HTML and image were cached by the runtime route.
+
+![Runtime cached green badge](./details-badge.svg)
+
+- [Back to progressive cache assets](../)
+
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.vars.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.vars.ts
new file mode 100644
index 00000000..b2efab8e
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'progressive-cache',
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/style.css b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/style.css
new file mode 100644
index 00000000..3fcdaa25
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/details/style.css
@@ -0,0 +1,5 @@
+@import "../../../page-style.css";
+
+main {
+  --page-accent: royalblue;
+}
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.md b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.md
new file mode 100644
index 00000000..904173c9
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.md
@@ -0,0 +1,10 @@
+# Progressive cache assets
+
+This page is intentionally **not** precached during service-worker install.
+
+Visit it while online, then go offline and reload it. The service worker should serve this page from the runtime cache because you already visited it.
+
+![Runtime cached blue badge](./runtime-badge.svg)
+
+- [Progressive cache asset details](./details/)
+
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.vars.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.vars.ts
new file mode 100644
index 00000000..b2efab8e
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  layout: 'progressive-cache',
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/runtime-badge.svg b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/runtime-badge.svg
new file mode 100644
index 00000000..87ebb98f
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/runtime-badge.svg
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 240" role="img" aria-labelledby="title desc">
+  <title id="title">Progressive cache badge</title>
+  <desc id="desc">A blue badge used to demonstrate progressive-cache subresources.</desc>
+  <rect width="640" height="240" rx="32" fill="#0b65c2"/>
+  <circle cx="120" cy="120" r="56" fill="#fff" opacity="0.9"/>
+  <path d="M94 124l18 18 38-48" fill="none" stroke="#0b65c2" stroke-width="14" stroke-linecap="round" stroke-linejoin="round"/>
+  <text x="210" y="112" fill="#fff" font-family="system-ui, sans-serif" font-size="42" font-weight="700">Progressive cache</text>
+  <text x="210" y="162" fill="#d7ecff" font-family="system-ui, sans-serif" font-size="24">Fetched online, available offline later</text>
+</svg>
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/assets/style.css b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/style.css
new file mode 100644
index 00000000..5503fb07
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/assets/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: slateblue;
+}
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/beta/client.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/client.ts
new file mode 100644
index 00000000..58af6d44
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache beta')
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/beta/page.md b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/page.md
new file mode 100644
index 00000000..90442c62
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/page.md
@@ -0,0 +1,10 @@
+---
+title: Progressive cache beta
+layout: progressive-cache
+---
+
+# Progressive cache beta
+
+This is a second page using the same `progressive-cache` layout from frontmatter.
+
+It demonstrates that a layout-level policy can apply the same offline behavior to multiple pages without repeating a `page.vars.ts` file next to each page.
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/beta/style.css b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/style.css
new file mode 100644
index 00000000..b99f93e6
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/beta/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: teal;
+}
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/override/client.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/override/client.ts
new file mode 100644
index 00000000..041510a6
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/override/client.ts
@@ -0,0 +1,3 @@
+import { markPageClientLoaded } from '../../page-client.ts'
+
+markPageClientLoaded('progressive-cache override')
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.md b/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.md
new file mode 100644
index 00000000..cf60b794
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.md
@@ -0,0 +1,16 @@
+---
+title: Progressive cache override
+layout: progressive-cache
+---
+
+# Progressive cache override
+
+This page uses the progressive-cache layout in frontmatter, but its sibling `page.vars.ts` overrides the layout policy:
+
+```ts
+export default {
+  precache: true,
+}
+```
+
+So unlike the other progressive-cache pages, this page should be available offline immediately after the service worker install finishes.
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.vars.ts b/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.vars.ts
new file mode 100644
index 00000000..8799c83f
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/override/page.vars.ts
@@ -0,0 +1,5 @@
+import type { StaticMpaWorkboxPageVars } from '#service-worker-settings'
+
+export default {
+  precache: true,
+} satisfies StaticMpaWorkboxPageVars
diff --git a/examples/static-mpa-workbox-offline/src/progressive-cache/override/style.css b/examples/static-mpa-workbox-offline/src/progressive-cache/override/style.css
new file mode 100644
index 00000000..84d608ea
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/progressive-cache/override/style.css
@@ -0,0 +1,5 @@
+@import "../../page-style.css";
+
+main {
+  --page-accent: mediumvioletred;
+}
diff --git a/examples/static-mpa-workbox-offline/src/style.css b/examples/static-mpa-workbox-offline/src/style.css
new file mode 100644
index 00000000..83c2532b
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/src/style.css
@@ -0,0 +1,5 @@
+@import "./page-style.css";
+
+main {
+  --page-accent: dodgerblue;
+}
diff --git a/examples/static-mpa-workbox-offline/tsconfig.json b/examples/static-mpa-workbox-offline/tsconfig.json
new file mode 100644
index 00000000..ec479d6a
--- /dev/null
+++ b/examples/static-mpa-workbox-offline/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "extends": "@voxpelli/tsconfig/node20.json",
+  "compilerOptions": {
+    "skipLibCheck": true,
+    "erasableSyntaxOnly": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "exactOptionalPropertyTypes": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "lib": ["ES2024", "DOM"]
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "public"
+  ]
+}
diff --git a/examples/string-layouts/package.json b/examples/string-layouts/package.json
index f0fe0cb5..28d6f6d1 100644
--- a/examples/string-layouts/package.json
+++ b/examples/string-layouts/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "string-layouts",
+  "name": "@domstack/string-layouts-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -12,5 +12,8 @@
   "license": "MIT",
   "dependencies": {
     "@domstack/static": "file:../../."
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/tailwind/package.json b/examples/tailwind/package.json
index 8438b5c2..fef6a3ce 100644
--- a/examples/tailwind/package.json
+++ b/examples/tailwind/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@domstack/preact-example",
+  "name": "@domstack/tailwind-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -15,11 +15,14 @@
   },
   "devDependencies": {
     "@domstack/static": "file:../../.",
-    "@preact/signals": "^2.0.0",
+    "@preact/signals": "^2.9.3",
     "esbuild-plugin-tailwindcss": "2.2.0",
     "htm": "^3.1.1",
-    "npm-run-all2": "^6.0.0",
-    "preact": "^10.24.0",
+    "npm-run-all2": "^9.0.2",
+    "preact": "^10.29.6",
     "preact-render-to-string": "^6.5.11"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/tailwind/src/globals/esbuild.settings.js b/examples/tailwind/src/globals/esbuild.settings.js
index 171da22a..2aaee97e 100644
--- a/examples/tailwind/src/globals/esbuild.settings.js
+++ b/examples/tailwind/src/globals/esbuild.settings.js
@@ -1,4 +1,6 @@
 /**
+ * @import { BuildOptions } from 'esbuild'
+ *
  * Tailwind CSS Integration for DOMStack
  *
  * This file configures ESBuild to process Tailwind CSS in your project.
@@ -9,8 +11,8 @@ import tailwindPlugin from 'esbuild-plugin-tailwindcss'
 /**
  * Configure ESBuild settings to include Tailwind CSS processing
  *
- * @param {import('esbuild').BuildOptions} esbuildSettings - The default ESBuild configuration
- * @return {Promise<import('esbuild').BuildOptions>} - The modified ESBuild configuration
+ * @param {BuildOptions} esbuildSettings - The default ESBuild configuration
+ * @return {Promise<BuildOptions>} - The modified ESBuild configuration
  */
 export default async function esbuildSettingsOverride (esbuildSettings) {
   // Add the Tailwind plugin to the ESBuild configuration
diff --git a/examples/tailwind/src/layouts/root.layout.js b/examples/tailwind/src/layouts/root.layout.js
index 76167838..6514b8a1 100644
--- a/examples/tailwind/src/layouts/root.layout.js
+++ b/examples/tailwind/src/layouts/root.layout.js
@@ -1,12 +1,10 @@
+/**
+ * @import { LayoutFunction } from '@domstack/static'
+ */
 // @ts-ignore
 import { html } from 'htm/preact'
 import { render } from 'preact-render-to-string'
 
-/**
- * @template {Record<string, any>} T
- * @typedef {import('../build-pages/resolve-layout.js').LayoutFunction<T>} LayoutFunction
- */
-
 /**
  * Global layout with Tailwind container styles
  *
diff --git a/examples/type-stripping/package.json b/examples/type-stripping/package.json
index f5ce3582..722074f9 100644
--- a/examples/type-stripping/package.json
+++ b/examples/type-stripping/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@domstack/preact-example",
+  "name": "@domstack/type-stripping-example",
   "version": "0.0.0",
   "type": "module",
   "scripts": {
@@ -11,17 +11,20 @@
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io/)",
   "license": "MIT",
   "dependencies": {
-    "@preact/signals": "^2.0.0",
+    "@preact/signals": "^2.9.3",
     "highlight.js": "^11.9.0",
     "htm": "^3.1.1",
-    "mine.css": "^9.0.1",
-    "preact": "^10.24.0",
+    "mine.css": "^10.0.3",
+    "preact": "^10.29.6",
     "preact-render-to-string": "^6.5.11",
     "@domstack/static": "file:../../."
   },
   "devDependencies": {
-    "@voxpelli/tsconfig": "^15.0.0",
-    "npm-run-all2": "^6.0.0",
-    "typescript": "~5.8.2"
+    "@voxpelli/tsconfig": "^16.2.1",
+    "npm-run-all2": "^9.0.2",
+    "typescript": "~6.0.3"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/type-stripping/src/isomorphic/client.ts b/examples/type-stripping/src/isomorphic/client.ts
index 78a66bba..a74a7a85 100644
--- a/examples/type-stripping/src/isomorphic/client.ts
+++ b/examples/type-stripping/src/isomorphic/client.ts
@@ -2,7 +2,6 @@ import { html } from 'htm/preact'
 import { render } from 'preact'
 import { useState, useCallback, useEffect } from 'preact/hooks'
 
-
 // ===== Type Definitions =====
 
 interface Task {
@@ -56,12 +55,12 @@ interface TaskListProps {
 
 // Generate a unique ID (simplified version)
 const generateId = (): string => {
-  return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-};
+  return Date.now().toString(36) + Math.random().toString(36).substr(2, 5)
+}
 
 // Calculate task statistics
 const calculateTaskStats = (tasks: Task[]): TaskStats => {
-  const completed = tasks.filter(t => t.completed).length;
+  const completed = tasks.filter(t => t.completed).length
 
   return {
     total: tasks.length,
@@ -72,22 +71,22 @@ const calculateTaskStats = (tasks: Task[]): TaskStats => {
       medium: tasks.filter(t => t.priority === 'medium').length,
       high: tasks.filter(t => t.priority === 'high').length
     }
-  };
-};
+  }
+}
 
 // Filter tasks based on current filters
 const filterTasks = (tasks: Task[], filters: TaskFilterState): Task[] => {
   return tasks.filter(task => {
     // Filter by status
-    if (filters.status === 'active' && task.completed) return false;
-    if (filters.status === 'completed' && !task.completed) return false;
+    if (filters.status === 'active' && task.completed) return false
+    if (filters.status === 'completed' && !task.completed) return false
 
     // Filter by priority
-    if (filters.priority !== 'all' && task.priority !== filters.priority) return false;
+    if (filters.priority !== 'all' && task.priority !== filters.priority) return false
 
-    return true;
-  });
-};
+    return true
+  })
+}
 
 // ===== Components =====
 
@@ -95,12 +94,12 @@ const filterTasks = (tasks: Task[], filters: TaskFilterState): Task[] => {
 const TaskItem = ({ task, onToggle, onDelete }: TaskItemProps) => {
   const getPriorityClass = (priority: Task['priority']): string => {
     switch (priority) {
-      case 'high': return 'task-priority-high';
-      case 'medium': return 'task-priority-medium';
-      case 'low': return 'task-priority-low';
-      default: return '';
+      case 'high': return 'task-priority-high'
+      case 'medium': return 'task-priority-medium'
+      case 'low': return 'task-priority-low'
+      default: return ''
     }
-  };
+  }
 
   return html`
     <li class="task-item ${task.completed ? 'completed' : ''} ${getPriorityClass(task.priority)}">
@@ -115,8 +114,8 @@ const TaskItem = ({ task, onToggle, onDelete }: TaskItemProps) => {
       </div>
       <button class="delete-btn" onClick=${() => onDelete(task.id)}>Delete</button>
     </li>
-  `;
-};
+  `
+}
 
 // Task Filter Component
 const TaskFilter = ({ filters, onFilterChange, stats }: TaskFilterProps) => {
@@ -176,26 +175,26 @@ const TaskFilter = ({ filters, onFilterChange, stats }: TaskFilterProps) => {
         </div>
       </div>
     </div>
-  `;
-};
+  `
+}
 
 // Task Form Component
 const TaskForm = ({ onAddTask }: TaskFormProps) => {
-  const [error, setError] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null)
 
   // Simple approach using form submit
   const handleSubmit = (e: Event): void => {
-    e.preventDefault();
+    e.preventDefault()
 
     // Get form inputs directly
-    const form = e.target as HTMLFormElement;
-    const titleInput = form.querySelector('input[name="title"]') as HTMLInputElement;
-    const prioritySelect = form.querySelector('select[name="priority"]') as HTMLSelectElement;
+    const form = e.target as HTMLFormElement
+    const titleInput = form.querySelector('input[name="title"]') as HTMLInputElement
+    const prioritySelect = form.querySelector('select[name="priority"]') as HTMLSelectElement
 
     // Validate
     if (!titleInput || !titleInput.value.trim()) {
-      setError('Task title cannot be empty');
-      return;
+      setError('Task title cannot be empty')
+      return
     }
 
     // Add task
@@ -203,13 +202,13 @@ const TaskForm = ({ onAddTask }: TaskFormProps) => {
       title: titleInput.value.trim(),
       completed: false,
       priority: prioritySelect.value as Task['priority']
-    });
+    })
 
     // Reset form
-    titleInput.value = '';
-    prioritySelect.value = 'medium';
-    setError(null);
-  };
+    titleInput.value = ''
+    prioritySelect.value = 'medium'
+    setError(null)
+  }
 
   return html`
     <form class="task-form" onSubmit=${handleSubmit}>
@@ -234,13 +233,13 @@ const TaskForm = ({ onAddTask }: TaskFormProps) => {
 
       ${error ? html`<p class="error-message">${error}</p>` : null}
     </form>
-  `;
-};
+  `
+}
 
 // Task List Component
 const TaskList = ({ tasks, onToggleTask, onDeleteTask }: TaskListProps) => {
   if (tasks.length === 0) {
-    return html`<p class="no-tasks">No tasks to display</p>`;
+    return html`<p class="no-tasks">No tasks to display</p>`
   }
 
   return html`
@@ -254,8 +253,8 @@ const TaskList = ({ tasks, onToggleTask, onDeleteTask }: TaskListProps) => {
         />
       `)}
     </ul>
-  `;
-};
+  `
+}
 
 // ===== Main Application =====
 
@@ -282,27 +281,27 @@ const initialTasks: Task[] = [
     priority: 'low',
     createdAt: new Date()
   }
-];
+]
 
 // Main TaskManager component
 const TaskManager = () => {
   // TypeScript typed state
-  const [tasks, setTasks] = useState<Task[]>(initialTasks);
+  const [tasks, setTasks] = useState<Task[]>(initialTasks)
   const [filters, setFilters] = useState<TaskFilterState>({
     status: 'all',
     priority: 'all'
-  });
+  })
 
   // Memoized task stats
-  const [stats, setStats] = useState<TaskStats>(calculateTaskStats(tasks));
+  const [stats, setStats] = useState<TaskStats>(calculateTaskStats(tasks))
 
   // Update stats when tasks change
   useEffect(() => {
-    setStats(calculateTaskStats(tasks));
-  }, [tasks]);
+    setStats(calculateTaskStats(tasks))
+  }, [tasks])
 
   // Filter tasks based on current filters
-  const filteredTasks = filterTasks(tasks, filters);
+  const filteredTasks = filterTasks(tasks, filters)
 
   // Event handlers with TypeScript types
   const handleAddTask = useCallback((newTask: Omit<Task, 'id' | 'createdAt'>): void => {
@@ -310,66 +309,66 @@ const TaskManager = () => {
       ...newTask,
       id: generateId(),
       createdAt: new Date()
-    };
+    }
 
-    setTasks(prevTasks => [...prevTasks, task]);
-  }, []);
+    setTasks(prevTasks => [...prevTasks, task])
+  }, [])
 
   const handleToggleTask = useCallback((id: string): void => {
     setTasks(prevTasks =>
       prevTasks.map(task =>
         task.id === id ? { ...task, completed: !task.completed } : task
       )
-    );
-  }, []);
+    )
+  }, [])
 
   const handleDeleteTask = useCallback((id: string): void => {
-    setTasks(prevTasks => prevTasks.filter(task => task.id !== id));
-  }, []);
+    setTasks(prevTasks => prevTasks.filter(task => task.id !== id))
+  }, [])
 
   const handleFilterChange = useCallback((newFilters: Partial<TaskFilterState>): void => {
-    setFilters(prevFilters => ({ ...prevFilters, ...newFilters }));
-  }, []);
+    setFilters(prevFilters => ({ ...prevFilters, ...newFilters }))
+  }, [])
 
   const handleClearCompleted = useCallback((): void => {
-    setTasks(prevTasks => prevTasks.filter(task => !task.completed));
-  }, []);
+    setTasks(prevTasks => prevTasks.filter(task => !task.completed))
+  }, [])
 
   // Data persistence - example of useEffect with TypeScript
   useEffect((): void => {
     // Only run in browser context
     if (typeof window !== 'undefined') {
-      const savedTasks = localStorage.getItem('isomorphic-tasks');
+      const savedTasks = localStorage.getItem('isomorphic-tasks')
       if (savedTasks) {
         try {
           // Parse and restore dates properly
           const parsedTasks = JSON.parse(savedTasks, (key, value) => {
-            return key === 'createdAt' ? new Date(value) : value;
-          });
-          setTasks(parsedTasks);
+            return key === 'createdAt' ? new Date(value) : value
+          })
+          setTasks(parsedTasks)
         } catch (err) {
-          console.error('Failed to parse saved tasks:', err);
+          console.error('Failed to parse saved tasks:', err)
         }
       }
     }
-  }, []);
+  }, [])
 
   useEffect((): (() => void) | void => {
     // Only run in browser context
     if (typeof window !== 'undefined') {
       const handleSave = (): void => {
-        localStorage.setItem('isomorphic-tasks', JSON.stringify(tasks));
-      };
+        localStorage.setItem('isomorphic-tasks', JSON.stringify(tasks))
+      }
 
       // Save on page unload
-      window.addEventListener('beforeunload', handleSave);
+      window.addEventListener('beforeunload', handleSave)
 
       // Clean up event listener
       return (): void => {
-        window.removeEventListener('beforeunload', handleSave);
-      };
+        window.removeEventListener('beforeunload', handleSave)
+      }
     }
-  }, [tasks]);
+  }, [tasks])
 
   return html`
     <div class="task-manager">
@@ -402,26 +401,26 @@ const TaskManager = () => {
         </button>
       </div>
     </div>
-  `;
-};
+  `
+}
 
 // Export for isomorphic rendering
-export const page = (): any => html`<${TaskManager} />`;
+export const page = (): any => html`<${TaskManager} />`
 
 // Client-side rendering
 if (typeof window !== 'undefined') {
   // Wait for DOM to be ready
   if (document.readyState === 'loading') {
     document.addEventListener('DOMContentLoaded', () => {
-      const renderTarget = document.querySelector('.app-main');
+      const renderTarget = document.querySelector('.app-main')
       if (renderTarget) {
-        render(page(), renderTarget);
+        render(page(), renderTarget)
       }
-    });
+    })
   } else {
-    const renderTarget = document.querySelector('.app-main');
+    const renderTarget = document.querySelector('.app-main')
     if (renderTarget) {
-      render(page(), renderTarget);
+      render(page(), renderTarget)
     }
   }
 }
diff --git a/examples/type-stripping/src/tsx-page/client.tsx b/examples/type-stripping/src/tsx-page/client.tsx
index 73a75731..68419252 100644
--- a/examples/type-stripping/src/tsx-page/client.tsx
+++ b/examples/type-stripping/src/tsx-page/client.tsx
@@ -45,8 +45,8 @@ const Button = ({ onClick, variant, children, disabled = false }: ButtonProps) =
 
 // User card component with TypeScript props
 const UserCard = ({ id, name, email, role = 'User' }: UserCardProps) => (
-  <div className="border rounded p-4 mb-2 shadow hover:shadow-md transition-shadow">
-    <h3 className="font-bold">{name}</h3>
+  <div className='border rounded p-4 mb-2 shadow hover:shadow-md transition-shadow'>
+    <h3 className='font-bold'>{name}</h3>
     <p>ID: {id}</p>
     <p>Email: {email}</p>
     <p>Role: {role}</p>
@@ -92,26 +92,26 @@ export const Page = () => {
   }, [count])
 
   return (
-    <div className="p-4 max-w-md mx-auto">
-      <h1 className="text-2xl font-bold mb-4">TypeScript JSX Example</h1>
+    <div className='p-4 max-w-md mx-auto'>
+      <h1 className='text-2xl font-bold mb-4'>TypeScript JSX Example</h1>
 
-      <div className="mb-6">
-        <p className="mb-2">Counter: {count}</p>
-        <Button onClick={incrementCounter} variant="primary">
+      <div className='mb-6'>
+        <p className='mb-2'>Counter: {count}</p>
+        <Button onClick={incrementCounter} variant='primary'>
           Increment
         </Button>
       </div>
 
-      <div className="mb-6">
-        <h2 className="text-xl font-bold mb-2">Users</h2>
+      <div className='mb-6'>
+        <h2 className='text-xl font-bold mb-2'>Users</h2>
         {users.map(user => (
           <UserCard key={user.id} {...user} />
         ))}
 
-        <div className="mt-4">
+        <div className='mt-4'>
           <Button
             onClick={addUser}
-            variant="secondary"
+            variant='secondary'
             disabled={isLoading}
           >
             {isLoading ? 'Adding...' : 'Add Random User'}
@@ -119,7 +119,7 @@ export const Page = () => {
         </div>
       </div>
 
-      <Button onClick={() => setUsers([])} variant="danger">
+      <Button onClick={() => setUsers([])} variant='danger'>
         Clear All Users
       </Button>
     </div>
diff --git a/examples/uhtml-isomorphic/package.json b/examples/uhtml-isomorphic/package.json
index 51826e5f..f08904ec 100644
--- a/examples/uhtml-isomorphic/package.json
+++ b/examples/uhtml-isomorphic/package.json
@@ -12,11 +12,14 @@
   "license": "MIT",
   "dependencies": {
     "highlight.js": "^11.9.0",
-    "mine.css": "^9.0.1",
+    "mine.css": "^10.0.3",
     "uhtml-isomorphic": "^2.1.0",
-    "@domstack/static": "../../."
+    "@domstack/static": "file:../../."
   },
   "devDependencies": {
-    "npm-run-all2": "^6.0.0"
+    "npm-run-all2": "^9.0.2"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/examples/uhtml-isomorphic/src/layouts/root.layout.js b/examples/uhtml-isomorphic/src/layouts/root.layout.js
index 72cf92a3..2b15aec3 100644
--- a/examples/uhtml-isomorphic/src/layouts/root.layout.js
+++ b/examples/uhtml-isomorphic/src/layouts/root.layout.js
@@ -1,9 +1,7 @@
-import { html, render } from 'uhtml-isomorphic'
-
 /**
- * @template {Record<string, any>} T
- * @typedef {import('../build-pages/resolve-layout.js').LayoutFunction<T>} LayoutFunction
+ * @import { LayoutFunction } from '@domstack/static'
  */
+import { html, render } from 'uhtml-isomorphic'
 
 /**
  * Build all of the bundles using esbuild.
diff --git a/examples/worker-example/package.json b/examples/worker-example/package.json
index 44d8b27f..d384e72e 100644
--- a/examples/worker-example/package.json
+++ b/examples/worker-example/package.json
@@ -9,14 +9,21 @@
     "clean": "rm -rf public && mkdir -p public",
     "watch": "npm run clean && dom --watch"
   },
-  "keywords": ["domstack", "web-workers", "static-site-generator"],
+  "keywords": [
+    "domstack",
+    "web-workers",
+    "static-site-generator"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "mine.css": "^9.0.1",
+    "mine.css": "^10.0.3",
     "@domstack/static": "file:../../."
   },
   "devDependencies": {
-    "npm-run-all2": "^6.0.0"
+    "npm-run-all2": "^9.0.2"
+  },
+  "engines": {
+    "node": "^22.0.0 || >=24.0.0"
   }
 }
diff --git a/index.js b/index.js
index 0325027f..568d48c2 100644
--- a/index.js
+++ b/index.js
@@ -3,11 +3,13 @@
  * @import { Stats } from 'node:fs'
  * @import { FSWatcher } from 'chokidar'
  * @import { WorkerBuildStepResult } from './lib/build-pages/index.js'
- * @import { BuildContext } from 'esbuild'
+
  * @import { PageInfo, TemplateInfo } from './lib/identify-pages.js'
  * @import { TestBuildResult } from './types.js'
  * @import { BsInstance } from '@domstack/sync'
  * @import { Logger as PinoLogger } from 'pino'
+ * @import { DomstackManifestRecord } from './lib/domstack-manifest/index.js'
+ * @typedef {{ dispose: () => Promise<void> }} DisposableBuildContext
  */
 import { once } from 'events'
 import assert from 'node:assert'
@@ -37,12 +39,14 @@ import {
   globalDataNames,
   esbuildSettingsNames,
   markdownItSettingsNames,
+  domstackManifestSettingsNames,
   pageClientNames,
   layoutClientSuffixs,
   globalClientNames,
   globalStyleNames,
   pageStyleName,
   pageWorkerSuffixs,
+  serviceWorkerNames,
 } from './lib/identify-pages.js'
 import { resolveVars } from './lib/build-pages/resolve-vars.js'
 import { ensureDest } from './lib/helpers/ensure-dest.js'
@@ -50,6 +54,16 @@ import { DomStackAggregateError } from './lib/helpers/domstack-aggregate-error.j
 import { createDomStackLogger } from './lib/logger.js'
 
 export { PageData } from './lib/build-pages/page-data.js'
+export {
+  DOMSTACK_MANIFEST_SCHEMA_ID,
+  DOMSTACK_MANIFEST_SCHEMA_PATH,
+  domstackManifestEntryPageMetaSchema,
+  domstackManifestEntrySchema,
+  domstackManifestKindSchema,
+  buildDomstackManifest,
+  domstackManifestSchema,
+  getDomstackManifestSchemaId,
+} from './lib/domstack-manifest/index.js'
 
 const DEFAULT_IGNORES = /** @type {const} */ ([
   '.*',
@@ -68,7 +82,7 @@ export class DomStack {
   /** @type {FSWatcher?} */ #watcher = null
   /** @type {any[]?} */ #cpxWatchers = null
   /** @type {BsInstance?} */ #syncServer = null
-  /** @type {BuildContext?} */ #esbuildContext = null
+  /** @type {DisposableBuildContext?} */ #esbuildContext = null
   /** @type {SiteData?} */ #siteData = null
   /** @type {PinoLogger} */ #logger
 
@@ -171,7 +185,15 @@ export class DomStack {
     // Build pages (initial full build)
     let report
     try {
-      const pageBuildResults = await buildPages(this.#src, this.#dest, siteData, this.opts)
+      const pageBuildResults = await buildPages(this.#src, this.#dest, siteData, {
+        ...this.opts,
+      })
+      if (pageBuildResults.errors.length > 0) {
+        throw new DomStackAggregateError(pageBuildResults.errors, 'Page build finished but there were errors.', {
+          siteData,
+          pageBuildResults,
+        })
+      }
       report = {
         warnings: [...siteData.warnings, ...pageBuildResults.warnings],
         siteData,
@@ -256,8 +278,8 @@ export class DomStack {
       })
     }
 
-    const enqueue = (/** @type {() => Promise<void>} */ fn) => {
-      this.#buildLock = this.#buildLock.then(() => fn().catch(err => errorLogger(err, this.#logger)))
+    const enqueue = (/** @type {() => Promise<unknown>} */ fn) => {
+      this.#enqueueBuild(fn)
     }
 
     watcher.on('add', path => {
@@ -316,6 +338,7 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
    */
   async #handleAddUnlink (changedPath, event) {
     const changedBasename = basename(changedPath)
+    const changedDir = relative(this.#src, dirname(changedPath))
 
     // Check if this is an esbuild entry point by basename pattern
     const isEsbuildEntry = (
@@ -323,6 +346,7 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
       layoutClientSuffixs.some(s => changedBasename.endsWith(s)) ||
       changedBasename.endsWith(layoutStyleSuffix) ||
       pageWorkerSuffixs.some(s => changedBasename.endsWith(s)) ||
+      serviceWorkerNames.includes(changedBasename) ||
       globalClientNames.includes(changedBasename) ||
       globalStyleNames.includes(changedBasename) ||
       changedBasename === pageStyleName
@@ -350,9 +374,10 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
       this.#siteData = siteData
 
       // Determine which pages are affected by this entry point change
-      const changedDir = relative(this.#src, dirname(changedPath))
-
-      if (globalClientNames.includes(changedBasename) || globalStyleNames.includes(changedBasename)) {
+      if (serviceWorkerNames.includes(changedBasename)) {
+        // Service workers are site-level esbuild entries and do not affect page HTML.
+        this.#logger.info(`"${changedBasename}" ${event}, no page rebuild needed.`)
+      } else if (globalClientNames.includes(changedBasename) || globalStyleNames.includes(changedBasename)) {
         // Global asset: rebuild all pages
         logRebuildTree(changedBasename, this.#logger, new Set(siteData.pages))
         await this.#runPageBuild(siteData)
@@ -409,17 +434,37 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
         ...(pageFilterPaths ? { pageFilterPaths } : {}),
         ...(templateFilterPaths ? { templateFilterPaths } : {}),
       })
+      if (pageBuildResults.errors.length > 0) {
+        throw new DomStackAggregateError(pageBuildResults.errors, 'Page build finished but there were errors.', {
+          siteData,
+          pageBuildResults,
+        })
+      }
       const isFiltered = pageFilterPaths !== null || templateFilterPaths !== null
       buildLogger(
         isFiltered ? pageBuildResults : { warnings: pageBuildResults.warnings, siteData, pageBuildResults },
         this.#logger,
         isFiltered ? this.#dest : undefined
       )
+      return pageBuildResults
     } catch (err) {
       errorLogger(err, this.#logger)
     }
   }
 
+  /**
+   * @param {() => Promise<unknown>} fn
+   */
+  #enqueueBuild (fn) {
+    this.#buildLock = this.#buildLock.then(async () => {
+      try {
+        await fn()
+      } catch (err) {
+        errorLogger(err, this.#logger)
+      }
+    })
+  }
+
   /**
    * Build and maintain the six watch maps from siteData.
    * `find()` returns CWD-relative paths; we resolve them to absolute for map keys.
@@ -520,6 +565,7 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
     const esbuildEntryPoints = /** @type {Set<string>} */ (new Set())
     if (siteData.globalClient) esbuildEntryPoints.add(resolve(siteData.globalClient.filepath))
     if (siteData.globalStyle) esbuildEntryPoints.add(resolve(siteData.globalStyle.filepath))
+    if (siteData.serviceWorker) esbuildEntryPoints.add(resolve(siteData.serviceWorker.filepath))
     for (const page of siteData.pages) {
       if (page.clientBundle) esbuildEntryPoints.add(resolve(page.clientBundle.filepath))
       if (page.pageStyle) esbuildEntryPoints.add(resolve(page.pageStyle.filepath))
@@ -577,6 +623,13 @@ ${siteData.errors.map(err => ` ${err.message}`).join('\n')}`)
       return this.#runPageBuild(siteData, Array.from(mdPages).map(p => p.pageFile.filepath), [])
     }
 
+    // domstack-manifest.settings.* only affects one-shot domstack manifest generation.
+    // Watch mode intentionally does not write or return a domstack manifest.
+    if (domstackManifestSettingsNames.some(n => changedBasename === n)) {
+      this.#logger.info(`"${changedBasename}" changed but domstack manifests are disabled in watch mode, skipping.`)
+      return
+    }
+
     // 6. esbuild entry point (client.js, style.css, .layout.css, .layout.client.*, *.worker.*, global.client.*, global.css)
     // esbuild's own watcher handles these. Stable filenames mean page HTML doesn't
     // change, so no page rebuild is needed.
@@ -787,24 +840,44 @@ function buildLogger (results, logger, dest) {
     // Full build: show site totals
     const layoutCount = Object.keys(results.siteData.layouts).length
     logger.info(`Pages: ${results.siteData.pages.length} Layouts: ${layoutCount} Templates: ${results.siteData.templates.length}`)
-    const report = results.pageBuildResults?.report
-    if (report) {
-      logger.info(`Pages built: ${report.pages.length} Templates built: ${report.templates.length}`)
+    const outputs = results.pageBuildResults?.report?.outputs
+    if (outputs) {
+      const summary = summarizePageDomstackManifests(outputs)
+      logger.info(`Pages built: ${summary.pages} Templates built: ${summary.templates}`)
     }
   } else if ('report' in results && results.report) {
     // Filtered build: show what was actually built
     const report = results.report
+    const outputs = report.outputs ?? []
     if (dest) {
-      for (const p of report.pages) {
-        logger.info(`  Built ${relative(dest, p.pageFilePath)}`)
-      }
-      for (const t of report.templates) {
-        for (const outputFile of t.outputs ?? []) {
-          logger.info(`  Built ${outputFile}`)
+      for (const output of outputs) {
+        if (output.kind === 'page' || output.kind === 'template') {
+          logger.info(`  Built ${relative(dest, output.filepath)}`)
         }
       }
     }
-    logger.info(`Pages built: ${report.pages.length} Templates built: ${report.templates.length}`)
+    const summary = summarizePageDomstackManifests(outputs)
+    logger.info(`Pages built: ${summary.pages} Templates built: ${summary.templates}`)
   }
   logger.info('\nBuild Success!\n\n')
 }
+
+/**
+ * @param {DomstackManifestRecord[]} outputs
+ */
+function summarizePageDomstackManifests (outputs) {
+  const templateSources = new Set()
+  let pages = 0
+
+  for (const output of outputs) {
+    if (output.kind === 'page') pages += 1
+    if (output.kind === 'template') {
+      templateSources.add(output.sourceRelname ?? output.templatePath ?? output.outputRelname)
+    }
+  }
+
+  return {
+    pages,
+    templates: templateSources.size,
+  }
+}
diff --git a/lib/build-copy/index.js b/lib/build-copy/index.js
index 693e8bbb..5e85e976 100644
--- a/lib/build-copy/index.js
+++ b/lib/build-copy/index.js
@@ -1,14 +1,16 @@
 /**
  * @import { BuildStepResult, BuildStep } from '../builder.js'
+ * @import { DomstackManifestRecord } from '../domstack-manifest/index.js'
  */
 
 import { copy } from 'cpx2'
 import { join } from 'node:path'
+import { createCopiedDomstackManifestRecords } from '../helpers/cpx2-report.js'
 
 /**
- * @typedef {BuildStepResult<'static', CopyBuilderReport>} CopyBuildStepResult
- * @typedef {BuildStep<'static', CopyBuilderReport>} CopyBuildStep
- * @typedef {Awaited<ReturnType<typeof copy>>} CopyBuilderReport
+ * @typedef {BuildStepResult<'copy', CopyBuilderReport>} CopyBuildStepResult
+ * @typedef {BuildStep<'copy', CopyBuilderReport>} CopyBuildStep
+ * @typedef {{ outputs: DomstackManifestRecord[] }} CopyBuilderReport
  */
 
 /**
@@ -28,8 +30,8 @@ export function getCopyDirs (copy = []) {
 export async function buildCopy (_src, dest, _siteData, opts) {
   /** @type {CopyBuildStepResult} */
   const results = {
-    type: 'static',
-    report: {},
+    type: 'copy',
+    report: { outputs: [] },
     errors: [],
     warnings: [],
   }
@@ -42,14 +44,17 @@ export async function buildCopy (_src, dest, _siteData, opts) {
 
   const settled = await Promise.allSettled(copyTasks)
 
-  for (const [index, result] of Object.entries(settled)) {
-    // @ts-expect-error
-    const copyDir = copyDirs[index]
+  for (const result of settled) {
     if (result.status === 'rejected') {
       const buildError = new Error('Error copying copy folders', { cause: result.reason })
       results.errors.push(buildError)
     } else {
-      /** @type {Record<string, object>} */ (results.report)[copyDir] = result.value
+      results.report.outputs.push(...createCopiedDomstackManifestRecords({
+        src: _src,
+        dest,
+        report: result.value,
+        kind: 'copy',
+      }))
     }
   }
   return results
diff --git a/lib/build-esbuild/index.js b/lib/build-esbuild/index.js
index 132cb5e6..c83f0c7d 100644
--- a/lib/build-esbuild/index.js
+++ b/lib/build-esbuild/index.js
@@ -1,28 +1,35 @@
 /**
  * @import { BuildStep, SiteData, DomStackOpts } from '../builder.js'
+ * @import { DomstackManifestKind, DomstackManifestRecord } from '../domstack-manifest/index.js'
  */
 
 import { writeFile } from 'fs/promises'
-import { join, relative, basename } from 'path'
+import { join, relative, basename, resolve, extname } from 'path'
 import esbuild from 'esbuild'
 import { resolveVars } from '../build-pages/resolve-vars.js'
+import {
+  createDomstackManifestRecord,
+  DEFAULT_DOMSTACK_MANIFEST_FILENAME,
+  isDomstackManifestEnabled,
+} from '../domstack-manifest/index.js'
+import { toPosix } from '../helpers/path.js'
 
 const __dirname = import.meta.dirname
 const DOM_STACK_DEFAULTS_PREFIX = 'domstack-defaults'
+const SERVICE_WORKER_OUTPUT_RELNAME = 'service-worker.js'
 
 /**
  * @typedef {esbuild.Format} EsbuildFormat
  * @typedef {esbuild.LogLevel} EsbuildLogLevel
  * @typedef {{[relpath: string]: string}} OutputMap
  * @typedef {esbuild.BuildOptions} EsbuildBuildOptions
- * @typedef {Awaited<ReturnType<esbuild.build>>} EsbuildBuildResults
+ * @typedef {{ dispose: () => Promise<void> }} DisposableBuildContext
+ * @typedef {{ define?: Record<string, string>, manifestVersion?: string }} ServiceWorkerBuildDefines
 
  * @typedef {BuildStep<
  *          'esbuild',
  *         {
- *           buildResults?: EsbuildBuildResults
- *           buildOpts?: EsbuildBuildOptions,
- *           outputMap?: OutputMap
+ *           outputs: DomstackManifestRecord[]
  *         }
  * >} EsBuildStep
  */
@@ -39,13 +46,14 @@ const DOM_STACK_DEFAULTS_PREFIX = 'domstack-defaults'
  * @param {string} dest
  * @returns {OutputMap}
  */
-function extractOutputMap (metafile, src, dest) {
+export function extractOutputMap (metafile, src, dest) {
   /** @type {OutputMap} */
   const outputMap = {}
   Object.keys(metafile.outputs).forEach(file => {
     const entryPoint = metafile.outputs[file]?.entryPoint
     if (entryPoint) {
-      outputMap[relative(src, entryPoint)] = relative(dest, file)
+      // Esbuild metafiles can use platform separators, while siteData keys are POSIX relnames.
+      outputMap[toPosix(relative(src, entryPoint))] = toPosix(relative(dest, file))
     }
   })
   return outputMap
@@ -59,65 +67,23 @@ function extractOutputMap (metafile, src, dest) {
  */
 function updateSiteDataOutputPaths (outputMap, siteData) {
   for (const page of siteData.pages) {
-    if (page.pageStyle) {
-      const outputRelname = outputMap[page.pageStyle.relname]
-      if (outputRelname) {
-        page.pageStyle.outputRelname = outputRelname
-        page.pageStyle.outputName = basename(outputRelname)
-      }
-    }
-
-    if (page.clientBundle) {
-      const outputRelname = outputMap[page.clientBundle.relname]
-      if (outputRelname) {
-        page.clientBundle.outputRelname = outputRelname
-        page.clientBundle.outputName = basename(outputRelname)
-      }
-    }
+    updateOutputFileInfo(outputMap, page.pageStyle)
+    updateOutputFileInfo(outputMap, page.clientBundle)
 
     if (page.workers) {
       for (const workerFile of Object.values(page.workers)) {
-        const outputRelname = outputMap[workerFile.relname]
-        if (outputRelname) {
-          workerFile.outputRelname = outputRelname
-          workerFile.outputName = basename(outputRelname)
-        }
+        updateOutputFileInfo(outputMap, workerFile)
       }
     }
   }
 
-  if (siteData.globalClient) {
-    const outputRelname = outputMap[siteData.globalClient.relname]
-    if (outputRelname) {
-      siteData.globalClient.outputRelname = outputRelname
-      siteData.globalClient.outputName = basename(outputRelname)
-    }
-  }
-
-  if (siteData.globalStyle) {
-    const outputRelname = outputMap[siteData.globalStyle.relname]
-    if (outputRelname) {
-      siteData.globalStyle.outputRelname = outputRelname
-      siteData.globalStyle.outputName = basename(outputRelname)
-    }
-  }
+  updateOutputFileInfo(outputMap, siteData.globalClient)
+  updateOutputFileInfo(outputMap, siteData.globalStyle)
+  updateOutputFileInfo(outputMap, siteData.serviceWorker)
 
   for (const layout of Object.values(siteData.layouts)) {
-    if (layout.layoutStyle) {
-      const outputRelname = outputMap[layout.layoutStyle.relname]
-      if (outputRelname) {
-        layout.layoutStyle.outputRelname = outputRelname
-        layout.layoutStyle.outputName = basename(outputRelname)
-      }
-    }
-
-    if (layout.layoutClient) {
-      const outputRelname = outputMap[layout.layoutClient.relname]
-      if (outputRelname) {
-        layout.layoutClient.outputRelname = outputRelname
-        layout.layoutClient.outputName = basename(outputRelname)
-      }
-    }
+    updateOutputFileInfo(outputMap, layout.layoutStyle)
+    updateOutputFileInfo(outputMap, layout.layoutClient)
   }
 
   if (siteData.defaultLayout) {
@@ -129,8 +95,22 @@ function updateSiteDataOutputPaths (outputMap, siteData) {
 }
 
 /**
- * Assemble the esbuild entry points and define map from siteData + opts.
- * Shared between one-shot build and watch context creation.
+ * @param {OutputMap} outputMap
+ * @param {{ relname: string, outputRelname?: string, outputName?: string } | null | undefined} fileInfo
+ */
+function updateOutputFileInfo (outputMap, fileInfo) {
+  if (!fileInfo) return
+
+  const outputRelname = outputMap[fileInfo.relname]
+  if (!outputRelname) return
+
+  fileInfo.outputRelname = outputRelname
+  fileInfo.outputName = basename(outputRelname)
+}
+
+/**
+ * Create browser-side esbuild options from siteData + opts.
+ * The root service worker intentionally uses a separate build derived from these base options.
  *
  * @param {string} src
  * @param {string} dest
@@ -139,10 +119,11 @@ function updateSiteDataOutputPaths (outputMap, siteData) {
  * @param {{ watch?: boolean }} [modeOpts]
  * @returns {Promise<esbuild.BuildOptions>}
  */
-async function assembleBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
+async function createBrowserBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
   const entryPoints = []
   if (siteData.globalClient) entryPoints.push(join(src, siteData.globalClient.relname))
   if (siteData.globalStyle) entryPoints.push(join(src, siteData.globalStyle.relname))
+
   if (siteData.defaultLayout) {
     entryPoints.push(
       { in: join(__dirname, '../defaults/default.style.css'), out: join(DOM_STACK_DEFAULTS_PREFIX, 'default.style.css') },
@@ -171,18 +152,22 @@ async function assembleBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
     key: 'browser',
   })
 
-  /** @type {{ [varName: string]: any }} */
-  const define = {}
+  const target = Array.isArray(opts?.target) ? opts.target : []
+
+  const watch = modeOpts.watch ?? false
+  /** @type {{ [varName: string]: string }} */
+  const domstackDefines = createDomstackDefines({ opts, siteData, watch })
+  /** @type {{ [varName: string]: string }} */
+  const define = { ...domstackDefines }
   if (browserVars) {
     for (const [k, v] of Object.entries(browserVars)) {
+      if (Object.hasOwn(define, k)) {
+        throw new Error(`Conflict: "${k}" is reserved by domstack.`)
+      }
       define[k] = JSON.stringify(v)
     }
   }
 
-  const target = Array.isArray(opts?.target) ? opts.target : []
-
-  const watch = modeOpts.watch ?? false
-
   /** @type {esbuild.BuildOptions} */
   const buildOpts = {
     entryPoints,
@@ -199,8 +184,8 @@ async function assembleBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
     target,
     define,
     metafile: true,
-    // In watch mode use stable (unhashed) entry filenames so the output map never changes.
-    // Chunks always use a hash to avoid collisions when multiple entry points produce chunks with the same name.
+    // In watch mode use stable unhashed entry filenames so page HTML references remain stable.
+    // Shared chunks still use content hashes so watch stays close to production behavior.
     entryNames: watch ? '[dir]/[name]' : '[dir]/[name]-[hash]',
     chunkNames: 'chunks/[ext]/[name]-[hash]',
     loader: {
@@ -233,7 +218,65 @@ async function assembleBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
     )
   }
 
-  return extendedBuildOpts
+  return {
+    ...extendedBuildOpts,
+    define: preserveDomstackDefines(extendedBuildOpts.define, domstackDefines),
+  }
+}
+
+/**
+ * Keep domstack-owned browser build facts available even when esbuild.settings
+ * replaces the define object. User settings may add custom defines, but they may
+ * not override domstack's reserved DOMSTACK_* values.
+ *
+ * @param {esbuild.BuildOptions['define']} define
+ * @param {{ [varName: string]: string }} domstackDefines
+ * @returns {{ [varName: string]: string }}
+ */
+function preserveDomstackDefines (define, domstackDefines) {
+  const mergedDefine = { ...(define ?? {}) }
+
+  for (const [key, value] of Object.entries(domstackDefines)) {
+    if (Object.hasOwn(mergedDefine, key) && mergedDefine[key] !== value) {
+      throw new Error(`Conflict: "${key}" is reserved by domstack.`)
+    }
+    mergedDefine[key] = value
+  }
+
+  return mergedDefine
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {esbuild.BuildResult} params.result
+ * @param {boolean} params.shouldWrite
+ */
+async function writeMetafile ({ dest, result, shouldWrite }) {
+  if (!result.metafile || !shouldWrite) return
+
+  await writeFile(join(dest, 'domstack-esbuild-meta.json'), JSON.stringify(result.metafile, null, ' '))
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {esbuild.BuildResult} params.result
+ * @param {SiteData} params.siteData
+ * @param {string} params.src
+ * @returns {OutputMap}
+ */
+function applyBuildOutputMap ({ dest, result, siteData, src }) {
+  const outputMap = result.metafile ? extractOutputMap(result.metafile, src, dest) : {}
+  updateSiteDataOutputPaths(outputMap, siteData)
+  return outputMap
+}
+
+/**
+ * @returns {{ outputs: DomstackManifestRecord[] }}
+ */
+function emptyEsbuildReport () {
+  return { outputs: [] }
 }
 
 /**
@@ -243,27 +286,26 @@ async function assembleBuildOpts (src, dest, siteData, opts, modeOpts = {}) {
  */
 export async function buildEsbuild (src, dest, siteData, opts) {
   try {
-    const extendedBuildOpts = await assembleBuildOpts(src, dest, siteData, opts, { watch: false })
+    const extendedBuildOpts = await createBrowserBuildOpts(src, dest, siteData, opts, { watch: false })
 
-    // @ts-ignore This actually works fine
     const buildResults = await esbuild.build(extendedBuildOpts)
 
-    if (buildResults.metafile) {
-      await writeFile(join(dest, 'domstack-esbuild-meta.json'), JSON.stringify(buildResults.metafile, null, ' '))
-    }
-
-    const outputMap = buildResults.metafile ? extractOutputMap(buildResults.metafile, src, dest) : {}
-    updateSiteDataOutputPaths(outputMap, siteData)
+    await writeMetafile({ dest, result: buildResults, shouldWrite: opts?.metafile !== false })
+    applyBuildOutputMap({ dest, result: buildResults, siteData, src })
+    const outputs = createEsbuildOutputRecords({
+      src,
+      dest,
+      siteData,
+      buildResults,
+      includeMetafileRecord: opts?.metafile !== false,
+    })
 
     return {
       type: 'esbuild',
       errors: buildResults.errors,
       warnings: buildResults.warnings,
       report: {
-        buildResults,
-        outputMap,
-        // @ts-ignore This is fine
-        buildOpts: extendedBuildOpts,
+        outputs,
       },
     }
   } catch (err) {
@@ -273,62 +315,322 @@ export async function buildEsbuild (src, dest, siteData, opts) {
         new Error('Error building JS+CSS with esbuild', { cause: err }),
       ],
       warnings: [],
-      report: {},
+      report: emptyEsbuildReport(),
+    }
+  }
+}
+
+/**
+ * Build the site service worker after the domstack manifest is finalized.
+ * The service worker is deliberately omitted from the domstack manifest so the
+ * finalized manifest version can be embedded into the worker without a circular
+ * content hash dependency.
+ *
+ * @param {string} src
+ * @param {string} dest
+ * @param {SiteData} siteData
+ * @param {DomStackOpts} opts
+ * @param {ServiceWorkerBuildDefines} [defines]
+ * @returns {Promise<EsBuildStepResults>}
+ */
+export async function buildServiceWorkerEsbuild (src, dest, siteData, opts, defines = {}) {
+  if (!siteData.serviceWorker) {
+    return {
+      type: 'esbuild',
+      errors: [],
+      warnings: [],
+      report: emptyEsbuildReport(),
+    }
+  }
+
+  try {
+    const extendedBuildOpts = await createBrowserBuildOpts(src, dest, siteData, opts, { watch: false })
+    const serviceWorkerBuildOpts = createServiceWorkerBuildOpts({
+      buildOpts: extendedBuildOpts,
+      defines,
+      serviceWorker: siteData.serviceWorker,
+      src,
+    })
+    const serviceWorkerBuildResults = await esbuild.build(serviceWorkerBuildOpts)
+    applyBuildOutputMap({ dest, result: serviceWorkerBuildResults, siteData, src })
+
+    return {
+      type: 'esbuild',
+      errors: serviceWorkerBuildResults.errors,
+      warnings: serviceWorkerBuildResults.warnings,
+      report: emptyEsbuildReport(),
+    }
+  } catch (err) {
+    return {
+      type: 'esbuild',
+      errors: [
+        new Error('Error building service worker with esbuild', { cause: err }),
+      ],
+      warnings: [],
+      report: emptyEsbuildReport(),
     }
   }
 }
 
 /**
- * Create an esbuild watch context with stable (unhashed) output filenames.
- * Calls onEnd after each rebuild. Returns the context for disposal.
+ * Production entry filenames are content-hashed globally. Service workers need
+ * a stable root URL, so they get a tiny second build with a fixed entry name.
+ * Emitting at /service-worker.js also gives the worker root scope by default.
+ *
+ * @param {object} params
+ * @param {esbuild.BuildOptions} params.buildOpts
+ * @param {ServiceWorkerBuildDefines} params.defines
+ * @param {NonNullable<SiteData['serviceWorker']>} params.serviceWorker
+ * @param {string} params.src
+ * @returns {esbuild.BuildOptions}
+ */
+function createServiceWorkerBuildOpts ({ buildOpts, defines, serviceWorker, src }) {
+  return {
+    ...buildOpts,
+    define: createServiceWorkerDefineMap(buildOpts.define, defines),
+    entryPoints: [
+      {
+        in: join(src, serviceWorker.relname),
+        out: 'service-worker',
+      },
+    ],
+    entryNames: '[name]',
+    splitting: false,
+  }
+}
+
+/**
+ * @param {esbuild.BuildOptions['define']} baseDefine
+ * @param {ServiceWorkerBuildDefines} defines
+ * @returns {{ [varName: string]: string }}
+ */
+function createServiceWorkerDefineMap (baseDefine, defines) {
+  const define = { ...(baseDefine ?? {}) }
+  const serviceWorkerDefine = defines.define ?? {}
+
+  for (const [key, value] of Object.entries(serviceWorkerDefine)) {
+    if (Object.hasOwn(define, key) && define[key] !== value) {
+      throw new Error(`Conflict: "${key}" is already defined for the service-worker build.`)
+    }
+    define[key] = value
+  }
+
+  define['process.env.DOMSTACK_MANIFEST_VERSION'] = JSON.stringify(defines.manifestVersion ?? '')
+  return define
+}
+
+/**
+ * Provide domstack-owned build facts to all browser-side bundles.
+ *
+ * @param {object} params
+ * @param {DomStackOpts | null} params.opts
+ * @param {SiteData} params.siteData
+ * @param {boolean} params.watch
+ */
+function createDomstackDefines ({ opts, siteData, watch }) {
+  const hasServiceWorker = Boolean(siteData.serviceWorker)
+  const domstackManifestSettingsPath = siteData?.domstackManifestSettings?.filepath
+
+  return {
+    'process.env.DOMSTACK_MANIFEST_URL': JSON.stringify(`/${DEFAULT_DOMSTACK_MANIFEST_FILENAME}`),
+    'process.env.DOMSTACK_MANIFEST_VERSION': JSON.stringify(''),
+    'process.env.DOMSTACK_MANIFEST_ENABLED': JSON.stringify(String(!watch && isDomstackManifestEnabled({ domstackManifestSettingsPath, opts: opts ?? undefined }))),
+    'process.env.DOMSTACK_SERVICE_WORKER_URL': JSON.stringify(hasServiceWorker ? `/${SERVICE_WORKER_OUTPUT_RELNAME}` : ''),
+    'process.env.DOMSTACK_SERVICE_WORKER_SCOPE': JSON.stringify(hasServiceWorker ? '/' : ''),
+  }
+}
+
+/**
+ * Create esbuild watch contexts with stable unhashed entry filenames.
+ * The browser context keeps production-like code splitting.
+ * The service-worker context is separate and self-contained so watch-mode cleanup can run reliably.
  *
  * @param {string} src
  * @param {string} dest
  * @param {SiteData} siteData
  * @param {DomStackOpts} opts
  * @param {{ onEnd?: (result: esbuild.BuildResult) => void }} [watchOpts]
- * @returns {Promise<{ context: esbuild.BuildContext, outputMap: OutputMap }>}
+ * @returns {Promise<{ context: DisposableBuildContext, outputMap: OutputMap, buildResults: esbuild.BuildResult, buildOpts: EsbuildBuildOptions }>}
  */
 export async function buildEsbuildWatch (src, dest, siteData, opts, watchOpts = {}) {
-  const extendedBuildOpts = await assembleBuildOpts(src, dest, siteData, opts, { watch: true })
+  const extendedBuildOpts = await createBrowserBuildOpts(src, dest, siteData, opts, { watch: true })
+  const browserWatch = await createWatchBuild({
+    buildOpts: extendedBuildOpts,
+    dest,
+    label: 'JS/CSS',
+    onEnd: watchOpts.onEnd,
+    shouldWriteMetafile: opts?.metafile !== false,
+  })
+
+  const initialResult = browserWatch.initialResult
+
+  await writeMetafile({ dest, result: initialResult, shouldWrite: opts?.metafile !== false })
+  const outputMap = applyBuildOutputMap({ dest, result: initialResult, siteData, src })
+
+  /** @type {esbuild.BuildContext[]} */
+  const contexts = [browserWatch.context]
+
+  if (siteData.serviceWorker) {
+    // Keep service-worker-only defines and no-policy watch cleanup behavior out of browser bundles.
+    const serviceWorkerBuildOpts = createServiceWorkerBuildOpts({
+      buildOpts: extendedBuildOpts,
+      defines: {},
+      serviceWorker: siteData.serviceWorker,
+      src,
+    })
+    const serviceWorkerWatch = await createWatchBuild({
+      buildOpts: serviceWorkerBuildOpts,
+      dest,
+      label: 'Service worker',
+      shouldWriteMetafile: false,
+    })
+    applyBuildOutputMap({
+      dest,
+      result: serviceWorkerWatch.initialResult,
+      siteData,
+      src,
+    })
+    contexts.push(serviceWorkerWatch.context)
+  }
+
+  return {
+    context: createDisposableBuildContext(contexts),
+    outputMap,
+    buildResults: initialResult,
+    buildOpts: extendedBuildOpts,
+  }
+}
 
-  const plugins = extendedBuildOpts.plugins ?? []
+/**
+ * @param {object} params
+ * @param {esbuild.BuildOptions} params.buildOpts
+ * @param {string} params.dest
+ * @param {string} params.label
+ * @param {(result: esbuild.BuildResult) => void | Promise<void>} [params.onEnd]
+ * @param {boolean} params.shouldWriteMetafile
+ * @returns {Promise<{ context: esbuild.BuildContext, initialResult: esbuild.BuildResult }>}
+ */
+async function createWatchBuild ({ buildOpts, dest, label, onEnd, shouldWriteMetafile }) {
+  let startedWatching = false
+  const plugins = buildOpts.plugins ?? []
 
   /** @type {esbuild.Plugin} */
   const onEndPlugin = {
-    name: 'domstack-on-end',
+    name: `domstack-${label.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-')}-on-end`,
     setup (build) {
-      build.onEnd(result => {
+      build.onEnd(async result => {
         if (result.errors.length > 0) {
-          console.error('JS/CSS rebuild failed:')
+          console.error(`${label} rebuild failed:`)
           for (const err of result.errors) {
             console.error(' ', err.text)
           }
         } else {
-          console.log('JS/CSS rebuild complete.')
+          console.log(`${label} rebuild complete.`)
         }
-        if (watchOpts.onEnd) watchOpts.onEnd(result)
+        await writeMetafile({ dest, result, shouldWrite: shouldWriteMetafile })
+        if (startedWatching && onEnd) await onEnd(result)
       })
     }
   }
 
-  const contextOpts = { ...extendedBuildOpts, plugins: [...plugins, onEndPlugin] }
+  const contextOpts = { ...buildOpts, plugins: [...plugins, onEndPlugin] }
 
   // @ts-ignore esbuild context() accepts same opts as build()
   const context = await esbuild.context(contextOpts)
-
-  // Trigger initial build to get the metafile / outputMap
   const initialResult = await context.rebuild()
 
-  if (initialResult.metafile) {
-    await writeFile(join(dest, 'domstack-esbuild-meta.json'), JSON.stringify(initialResult.metafile, null, ' '))
+  await context.watch()
+  startedWatching = true
+
+  return { context, initialResult }
+}
+
+/**
+ * @param {esbuild.BuildContext[]} contexts
+ * @returns {DisposableBuildContext}
+ */
+function createDisposableBuildContext (contexts) {
+  return {
+    async dispose () {
+      await Promise.all(contexts.map(context => context.dispose()))
+    },
   }
+}
 
-  const outputMap = initialResult.metafile ? extractOutputMap(initialResult.metafile, src, dest) : {}
-  updateSiteDataOutputPaths(outputMap, siteData)
+/**
+ * @param {object} params
+ * @param {string} params.src
+ * @param {string} params.dest
+ * @param {SiteData} params.siteData
+ * @param {esbuild.BuildResult} params.buildResults
+ * @param {boolean} params.includeMetafileRecord
+ * @returns {DomstackManifestRecord[]}
+ */
+export function createEsbuildOutputRecords ({ src, dest, siteData, buildResults, includeMetafileRecord }) {
+  /** @type {DomstackManifestRecord[]} */
+  const outputs = []
+  const metafile = buildResults.metafile
+  if (!metafile) return outputs
 
-  // Start watching — esbuild handles its own rebuild loop from here
-  await context.watch()
+  const workerOutputRelnames = new Set()
+  for (const page of siteData.pages) {
+    if (!page.workers) continue
+    for (const worker of Object.values(page.workers)) {
+      if (worker.outputRelname) workerOutputRelnames.add(toPosix(worker.outputRelname))
+    }
+  }
+  const serviceWorkerOutputRelname = siteData.serviceWorker?.outputRelname
+    ? toPosix(siteData.serviceWorker.outputRelname)
+    : undefined
+
+  for (const [outputPath, outputMeta] of Object.entries(metafile.outputs)) {
+    const filepath = resolve(outputPath)
+    const outputRelname = toPosix(relative(dest, filepath))
+    const kind = classifyEsbuildOutput({
+      outputRelname,
+      entryPoint: outputMeta.entryPoint,
+      workerOutputRelnames,
+      serviceWorkerOutputRelname,
+    })
+
+    outputs.push(createDomstackManifestRecord({
+      dest,
+      filepath,
+      outputRelname,
+      kind,
+      entryPoint: outputMeta.entryPoint,
+      sourceRelname: outputMeta.entryPoint ? toPosix(relative(src, resolve(outputMeta.entryPoint))) : undefined,
+    }))
+  }
+
+  if (includeMetafileRecord) {
+    outputs.push(createDomstackManifestRecord({
+      dest,
+      outputRelname: 'domstack-esbuild-meta.json',
+      kind: 'metadata',
+    }))
+  }
+
+  return outputs
+}
 
-  return { context, outputMap }
+/**
+ * Classify a dest-relative esbuild output.
+ *
+ * @param {object} params
+ * @param {string} params.outputRelname
+ * @param {string | undefined} params.entryPoint
+ * @param {Set<string>} params.workerOutputRelnames
+ * @param {string | undefined} [params.serviceWorkerOutputRelname]
+ * @returns {DomstackManifestKind}
+ */
+function classifyEsbuildOutput ({ outputRelname, entryPoint, workerOutputRelnames, serviceWorkerOutputRelname }) {
+  const ext = extname(outputRelname)
+
+  if (ext === '.map') return 'sourcemap'
+  if (serviceWorkerOutputRelname && outputRelname === serviceWorkerOutputRelname) return 'service-worker'
+  if (workerOutputRelnames.has(outputRelname)) return 'worker'
+  if (ext === '.css') return 'style'
+  if (ext === '.js' && entryPoint) return 'script'
+  return 'chunk'
 }
diff --git a/lib/build-pages/index.js b/lib/build-pages/index.js
index 15498101..1003ef95 100644
--- a/lib/build-pages/index.js
+++ b/lib/build-pages/index.js
@@ -3,6 +3,7 @@
  * @import { BuildStep, SiteData, DomStackOpts } from '../builder.js'
  * @import { PageInfo, TemplateInfo } from '../identify-pages.js'
  * @import { ResolvedLayout } from './page-data.js'
+ * @import { DomstackManifestRecord } from '../domstack-manifest/index.js'
  */
 
 import { Worker } from 'worker_threads'
@@ -21,8 +22,7 @@ const __dirname = import.meta.dirname
 
 /**
  * @typedef {{
- *   pages: Awaited<ReturnType<typeof pageWriter>>[]
- *   templates: Awaited<ReturnType<typeof templateBuilder>>[]
+ *   outputs: DomstackManifestRecord[]
  * }} PageBuilderReport
  */
 
@@ -171,19 +171,18 @@ export function buildPages (src, dest, siteData, opts) {
  * All layouts, variables and page builders need to resolve in here
  * so that it can be run more than once, after the source files change.
  *
- * @param {string} src
+ * @param {string} _src
  * @param {string} dest
  * @param {SiteData} siteData
  * @param {DomStackOpts & BuildPagesOpts} [_opts]
  * @returns {Promise<WorkerBuildStepResult>}
  */
-export async function buildPagesDirect (src, dest, siteData, _opts) {
+export async function buildPagesDirect (_src, dest, siteData, _opts) {
   /** @type {WorkerBuildStepResult} */
   const result = {
     type: 'page',
     report: {
-      pages: [],
-      templates: [],
+      outputs: [],
     },
     errors: [],
     warnings: [],
@@ -208,9 +207,10 @@ export async function buildPagesDirect (src, dest, siteData, _opts) {
 
   /** @type {ResolvedLayout<object, any, string>[]} */
   const resolvedLayoutResults = await pMap(Object.values(siteData.layouts), async (layout) => {
-    const render = await resolveLayout(layout.filepath)
+    const resolvedLayout = await resolveLayout(layout.filepath)
     return {
-      render,
+      render: resolvedLayout.render,
+      vars: resolvedLayout.vars,
       name: layout.layoutName,
       layoutStylePath: layout.layoutStyle ? `/${layout.layoutStyle.outputRelname}` : null,
       layoutClientPath: layout.layoutClient ? `/${layout.layoutClient.outputRelname}` : null,
@@ -292,14 +292,13 @@ export async function buildPagesDirect (src, dest, siteData, _opts) {
   await Promise.all([
     pMap(pagesToRender, async (page) => {
       try {
-        const buildResult = await pageWriter({
-          src,
+        const outputRecords = await pageWriter({
           dest,
           page,
           pages,
         })
 
-        result.report.pages.push(buildResult)
+        result.report.outputs.push(...outputRecords)
       } catch (err) {
         const buildError = new Error('Error building page', { cause: err })
         // I can't put stuff on the error, the worker swallows it for some reason.
@@ -308,14 +307,14 @@ export async function buildPagesDirect (src, dest, siteData, _opts) {
     }, { concurrency: dividedConcurrency[0] }),
     pMap(templatesToRender, async (template) => {
       try {
-        const buildResult = await templateBuilder({
+        const outputRecords = await templateBuilder({
           dest,
           globalVars: templateGlobalVars,
           template,
           pages,
         })
 
-        result.report.templates.push(buildResult)
+        result.report.outputs.push(...outputRecords)
       } catch (err) {
         if (!(err instanceof Error)) throw new Error('Non-error thrown while building pages', { cause: err })
         const buildError = new Error('Error building template', { cause: { message: err.message, stack: err.stack } })
diff --git a/lib/build-pages/page-builders/page-writer.js b/lib/build-pages/page-builders/page-writer.js
index b286a712..41ff35b6 100644
--- a/lib/build-pages/page-builders/page-writer.js
+++ b/lib/build-pages/page-builders/page-writer.js
@@ -1,10 +1,12 @@
 /**
  * @import { PageInfo } from '../../identify-pages.js'
  * @import { PageData } from '../page-data.js'
+ * @import { DomstackManifestRecord } from '../../domstack-manifest/index.js'
  */
 
 import { join } from 'path'
 import { writeFile, mkdir } from 'fs/promises'
+import { createDomstackManifestRecord } from '../../domstack-manifest/index.js'
 
 /**
  * @typedef {Object} BuilderOptions
@@ -85,10 +87,10 @@ import { writeFile, mkdir } from 'fs/promises'
  * @template [U=any] U - The return type of the page function (defaults to any)
  * @template [V=string] V - The return type of the layout function (defaults to string)
  * @param {object} params
- * @param {string} params.src   - The src folder.
  * @param {string} params.dest  - The dest folder.
  * @param {PageData<T, U, V>} params.page  - The PageInfo object of the current page
  * @param {PageData<T, U, V>[]} params.pages - The PageInfo[] array of all pages
+ * @returns {Promise<DomstackManifestRecord[]>}
  */
 export async function pageWriter ({
   dest,
@@ -103,6 +105,27 @@ export async function pageWriter ({
   await mkdir(pageDir, { recursive: true })
   await writeFile(pageFilePath, formattedPageOutput)
 
+  /** @type {DomstackManifestRecord[]} */
+  const outputs = [
+    createDomstackManifestRecord({
+      dest,
+      filepath: pageFilePath,
+      outputRelname: page.pageInfo.outputRelname,
+      kind: 'page',
+      url: page.pageInfo.url,
+      sourceRelname: page.pageInfo.pageFile.relname,
+      pagePath: page.pageInfo.path,
+      pageUrl: page.pageInfo.url,
+      pageVars: page.vars,
+      manifestRole: extractManifestRole(page.vars),
+      page: {
+        path: page.pageInfo.path,
+        url: page.pageInfo.url,
+        vars: extractPrecacheVars(page),
+      },
+    }),
+  ]
+
   // Generate meta.json with worker mappings if page has workers
   if (page.pageInfo?.workers) {
     /** @type { {[workerName: string]: string } } */
@@ -122,8 +145,37 @@ export async function pageWriter ({
       const workersFilePath = join(pageDir, 'workers.json')
       const workersContent = JSON.stringify(workerMappings, null, 2)
       await writeFile(workersFilePath, workersContent)
+      outputs.push(createDomstackManifestRecord({
+        dest,
+        filepath: workersFilePath,
+        outputRelname: join(page.pageInfo.path, 'workers.json'),
+        kind: 'worker-manifest',
+        pagePath: page.pageInfo.path,
+        pageUrl: page.pageInfo.url,
+      }))
     }
   }
 
-  return { pageFilePath }
+  return outputs
+}
+
+/**
+ * @param {PageData<any, any, any>} page
+ */
+function extractPrecacheVars (page) {
+  /** @type {{ precache?: unknown, offline?: unknown }} */
+  const vars = {}
+  const source = /** @type {{ precache?: unknown, offline?: unknown }} */ (page.vars)
+  if (Object.hasOwn(source, 'precache')) vars.precache = source.precache
+  if (Object.hasOwn(source, 'offline')) vars.offline = source.offline
+  return vars
+}
+
+/**
+ * @param {unknown} vars
+ */
+function extractManifestRole (vars) {
+  if (!vars || typeof vars !== 'object') return undefined
+  const source = /** @type {{ manifestRole?: unknown }} */ (vars)
+  return typeof source.manifestRole === 'string' ? source.manifestRole : undefined
 }
diff --git a/lib/build-pages/page-builders/template-builder.js b/lib/build-pages/page-builders/template-builder.js
index 98ff90f6..64f9516d 100644
--- a/lib/build-pages/page-builders/template-builder.js
+++ b/lib/build-pages/page-builders/template-builder.js
@@ -1,10 +1,13 @@
 /**
  * @import { TemplateInfo } from '../../identify-pages.js'
  * @import { PageData } from '../page-data.js'
+ * @import { DomstackManifestRecord } from '../../domstack-manifest/index.js'
  */
 
-import { join, resolve, dirname } from 'path'
+import { dirname, join, relative, resolve } from 'node:path'
 import { writeFile, mkdir } from 'fs/promises'
+import { createDomstackManifestRecord } from '../../domstack-manifest/index.js'
+import { assertInsideDest, toPosix } from '../../helpers/path.js'
 
 /** @typedef {{
  *   outputName: string,
@@ -26,10 +29,7 @@ import { writeFile, mkdir } from 'fs/promises'
  *
  * @template {Record<string, any>} T - The type of variables for the template
  * @callback TemplateFunction
- * @param {object} params - The parameters for the template.
- * @param {T} params.vars - All of the site globalVars merged with global.data.js output.
- * @param {TemplateInfo} params.template - Info about the current template
- * @param {PageData<T, any, string>[]} params.pages - An array of info about every page
+ * @param {TemplateFunctionParams<T>} params - The parameters for the template.
  * @returns {Promise<string | TemplateOutputOverride | TemplateOutputOverride[]>}
  *  } - The results of a template build
  */
@@ -42,14 +42,6 @@ import { writeFile, mkdir } from 'fs/promises'
  * @returns {AsyncIterable<TemplateOutputOverride>}
  */
 
-/**
- * @typedef TemplateReport
- *
- * @property {TemplateInfo} templateInfo - The input TemplateInfo object
- * @property {string[]} outputs - Array of paths the template output to
- * @property {'content'|'object'|'array'|'async-iterator'} [type] - The template return type
- */
-
 /**
  * The template builder renders templates against the globalVars variables.
  * globalVars passed here already includes global.data.js output merged in.
@@ -59,6 +51,7 @@ import { writeFile, mkdir } from 'fs/promises'
  * @param  {T} params.globalVars - globalVars merged with global.data.js output.
  * @param  {TemplateInfo} params.template   - The TemplateInfo of the template.
  * @param  {PageData<T, any, string>[]} params.pages      - The array of PageData object.
+ * @returns {Promise<DomstackManifestRecord[]>}
  */
 export async function templateBuilder ({
   dest,
@@ -84,55 +77,62 @@ export async function templateBuilder ({
   const templateResults = await renderTemplate(finalVars)
 
   const fileDir = join(dest, template.path)
-  const filePath = join(fileDir, template.outputName)
 
-  /** @type {TemplateReport} */
-  const templateReport = {
-    templateInfo: template,
-    outputs: [],
-    type: 'content',
-  }
+  /** @type {DomstackManifestRecord[]} */
+  const outputRecords = []
 
   if (typeof templateResults === 'string') {
-    await mkdir(fileDir, { recursive: true })
-    await writeFile(filePath, templateResults)
-    templateReport.outputs.push(template.outputName)
-    templateReport.type = 'content'
+    await writeTemplateOutput({
+      dest,
+      fileDir,
+      outputName: template.outputName,
+      content: templateResults,
+      template,
+      outputRecords,
+    })
   } else if (
     Array.isArray(templateResults) &&
     templateResults.every(item => 'outputName' in item && 'content' in item)
   ) {
-    templateReport.type = 'array'
     for (const templateResult of templateResults) {
-      const filePathOverride = resolve(fileDir, templateResult.outputName)
-      const filePathOverrideDirname = dirname(filePathOverride)
-      await mkdir(filePathOverrideDirname, { recursive: true })
-      await writeFile(filePathOverride, templateResult.content)
-      templateReport.outputs.push(templateResult.outputName)
+      await writeTemplateOutput({
+        dest,
+        fileDir,
+        outputName: templateResult.outputName,
+        content: templateResult.content,
+        template,
+        outputRecords,
+      })
     }
   } else if (
+    templateResults &&
     typeof templateResults === 'object' &&
     'outputName' in templateResults &&
     'content' in templateResults
   ) {
-    templateReport.type = 'object'
-    const filePathOverride = resolve(fileDir, templateResults.outputName)
-    const filePathOverrideDirname = dirname(filePathOverride)
-    await mkdir(filePathOverrideDirname, { recursive: true })
-    await writeFile(filePathOverride, templateResults.content)
-    templateReport.outputs.push(templateResults.outputName)
+    await writeTemplateOutput({
+      dest,
+      fileDir,
+      outputName: templateResults.outputName,
+      content: templateResults.content,
+      template,
+      outputRecords,
+    })
   } else if (
+    templateResults &&
     typeof templateResults === 'object' &&
     !Array.isArray(templateResults) &&
     typeof templateResults[Symbol.asyncIterator] === 'function') {
-    templateReport.type = 'async-iterator'
     for await (const templateResult of templateResults) {
       if ('outputName' in templateResult && 'content' in templateResult) {
-        const filePathOverride = resolve(fileDir, templateResult.outputName)
-        const filePathOverrideDirname = dirname(filePathOverride)
-        await mkdir(filePathOverrideDirname, { recursive: true })
-        await writeFile(filePathOverride, templateResult.content)
-        templateReport.outputs.push(templateResult.outputName)
+        await writeTemplateOutput({
+          dest,
+          fileDir,
+          outputName: templateResult.outputName,
+          content: templateResult.content,
+          template,
+          outputRecords,
+        })
       } else {
         throw new Error(`Template file returned unknown return type: ${typeof templateResult}`)
       }
@@ -141,5 +141,39 @@ export async function templateBuilder ({
     throw new Error(`Template file returned unknown return type: ${typeof templateResults}`)
   }
 
-  return templateReport
+  return outputRecords
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {string} params.fileDir
+ * @param {string} params.outputName
+ * @param {string} params.content
+ * @param {TemplateInfo} params.template
+ * @param {DomstackManifestRecord[]} params.outputRecords
+ */
+async function writeTemplateOutput ({
+  dest,
+  fileDir,
+  outputName,
+  content,
+  template,
+  outputRecords,
+}) {
+  const filepath = resolve(fileDir, outputName)
+  assertInsideDest(dest, filepath, `Template output escapes dest: ${filepath}`)
+  const filePathDirname = dirname(filepath)
+  await mkdir(filePathDirname, { recursive: true })
+  await writeFile(filepath, content)
+
+  const outputRelname = toPosix(relative(dest, filepath))
+  outputRecords.push(createDomstackManifestRecord({
+    dest,
+    filepath,
+    outputRelname,
+    kind: 'template',
+    sourceRelname: template.templateFile.relname,
+    templatePath: template.path,
+  }))
 }
diff --git a/lib/build-pages/page-data.js b/lib/build-pages/page-data.js
index c0c54445..c801bbe5 100644
--- a/lib/build-pages/page-data.js
+++ b/lib/build-pages/page-data.js
@@ -4,7 +4,7 @@
  */
 
 import { readFile } from 'node:fs/promises'
-import { resolveVars, resolvePostVars } from './resolve-vars.js'
+import { resolveVars, resolvePostVars, resolveVarsExport } from './resolve-vars.js'
 import { pageBuilders } from './page-builders/index.js'
 import { parseMdFileContents } from './page-builders/md/parse-md.js'
 import pretty from 'pretty'
@@ -21,14 +21,43 @@ import pretty from 'pretty'
  * @template [U=any] U - The return type of the page function (defaults to any)
  * @template [V=string] V - The return type of the layout function (defaults to string)
  * @param {string} layoutPath - The string path to the layout ESM module.
- * @returns {Promise<InternalLayoutFunction<T, U, V>>} The resolved layout exported as default from the module.
+ * @returns {Promise<{ render: InternalLayoutFunction<T, U, V>, vars: object }>} The resolved layout render function and optional vars exported from the module.
  */
 export async function resolveLayout (layoutPath) {
-  const { default: layout } = await import(layoutPath)
+  const { default: layout, vars } = await import(layoutPath)
 
-  return layout
+  return {
+    render: layout,
+    vars: await resolveVarsExport(vars, 'Layout vars'),
+  }
 }
 
+/**
+ * Synchronous layout vars export.
+ *
+ * Layout modules may export `vars` as an object or function. These vars are
+ * merged into `PageData.vars` after global vars and before page/frontmatter vars.
+ *
+ * @template {Record<string, any>} T - The layout vars shape.
+ * @callback LayoutVarsFunction
+ * @returns {T}
+ */
+
+/**
+ * Asynchronous layout vars export.
+ *
+ * @template {Record<string, any>} T - The layout vars shape.
+ * @callback AsyncLayoutVarsFunction
+ * @returns {Promise<T>}
+ */
+
+/**
+ * Layout vars export value.
+ *
+ * @template {Record<string, any>} T - The layout vars shape.
+ * @typedef {T | LayoutVarsFunction<T> | AsyncLayoutVarsFunction<T>} LayoutVars
+ */
+
 /**
   * Common parameters for layout functions.
   *
@@ -84,6 +113,7 @@ export async function resolveLayout (layoutPath) {
  * @template [V=string] V - The return type of the layout function (defaults to string)
  * @typedef ResolvedLayout
  * @property {InternalLayoutFunction<T, U, V>} render - The layout function
+ * @property {object} [vars] - Variables exported by the layout module.
  * @property {string} name - The name of the layout
  * @property {string | null} layoutStylePath - The string path to the layout style
  * @property {string | null} layoutClientPath - The string path to the layout client
@@ -100,6 +130,7 @@ export class PageData {
   /** @type {ResolvedLayout<T, U, V> | null | undefined} */ layout
   /** @type {object} */ globalVars
   /** @type {object} */ globalDataVars = {}
+  /** @type {object} */ layoutVars = {}
   /** @type {object?} */ pageVars = null
   /** @type {object?} */ builderVars = null
   /** @type {string[]} */ styles = []
@@ -107,7 +138,7 @@ export class PageData {
   /** @type {WorkerFiles} */ workerFiles = {}
   /** @type {boolean} */ #initialized = false
   /** @type {T | null} */ #varsCache = null
-  /** @type {[object, object, object | null, object | null] | null} */ #varsCacheSources = null
+  /** @type {[object, object, object, object | null, object | null] | null} */ #varsCacheSources = null
   /** @type {string?} */ #defaultStyle = null
   /** @type {string?} */ #defaultClient = null
   /** @type {BuilderOptions} */ builderOptions
@@ -149,13 +180,14 @@ export class PageData {
 
   /**
    * Returns the cached, shallow-frozen variable set for the page. Requires initialization.
-   * @return {T} globalVars, pageVars, and buildVars merged together
+   * @return {T} default/global, layout, page, and builder vars merged together
    */
   get vars () {
     if (!this.#initialized) throw new Error(`Initialize PageData before accessing vars for page "${this.pageInfo?.path ?? '<unknown page>'}"`)
-    const sources = /** @type {[object, object, object | null, object | null]} */ ([
+    const sources = /** @type {[object, object, object, object | null, object | null]} */ ([
       this.globalVars,
       this.globalDataVars,
+      this.layoutVars,
       this.pageVars,
       this.builderVars,
     ])
@@ -169,10 +201,11 @@ export class PageData {
     }
 
     try {
-      const { globalVars, globalDataVars, pageVars, builderVars } = this
+      const { globalVars, globalDataVars, layoutVars, pageVars, builderVars } = this
       this.#varsCache = /** @type {T} */ (/** @type {unknown} */ (Object.freeze({
         ...globalVars,
         ...globalDataVars,
+        ...layoutVars,
         ...pageVars,
         ...builderVars,
       })))
@@ -225,18 +258,11 @@ export class PageData {
     const { vars: builderVars } = await builder({ pageInfo, options: this.builderOptions })
     this.builderVars = builderVars
 
-    /** @type {object} */
-    const finalVars = {
-      ...globalVars,
-      ...this.pageVars,
-      ...builderVars,
-    }
-
-    if (!('layout' in finalVars)) throw new Error('Page variables missing a layout var')
-    if (typeof finalVars.layout !== 'string') throw new Error('Layout variable must be a string')
+    const layoutName = resolveLayoutName(globalVars, this.pageVars, builderVars)
 
-    this.layout = layouts[finalVars.layout]
+    this.layout = layouts[layoutName]
     if (!this.layout) throw new Error('Unable to resolve a layout')
+    this.layoutVars = this.layout.vars ?? {}
 
     if (this.layout.layoutStylePath) {
       this.styles.push(this.layout.layoutStylePath)
@@ -262,6 +288,15 @@ export class PageData {
       }
     }
 
+    /** @type {object} */
+    const finalVars = {
+      ...globalVars,
+      ...this.globalDataVars,
+      ...this.layoutVars,
+      ...this.pageVars,
+      ...builderVars,
+    }
+
     // disable-eslint-next-line dot-notation
     if ('defaultStyle' in finalVars && finalVars.defaultStyle) {
       if (this.#defaultClient) this.scripts.unshift(`/${this.#defaultClient}`)
@@ -311,3 +346,26 @@ export class PageData {
     return pretty(String(rendered))
   }
 }
+
+/**
+ * Resolve the selected layout name without constructing a partial vars object.
+ *
+ * Layout selection intentionally uses only pre-layout sources to avoid circular
+ * dependency on the selected layout's own vars. The lookup preserves the same
+ * precedence as the previous spread: builder/page-frontmatter vars, then
+ * page.vars, then global vars.
+ *
+ * @param {object} globalVars
+ * @param {object | null} pageVars
+ * @param {object | null} builderVars
+ * @returns {string}
+ */
+function resolveLayoutName (globalVars, pageVars, builderVars) {
+  for (const source of [builderVars, pageVars, globalVars]) {
+    if (!source || !('layout' in source)) continue
+    if (typeof source.layout !== 'string') throw new Error('Layout variable must be a string')
+    return source.layout
+  }
+
+  throw new Error('Page variables missing a layout var')
+}
diff --git a/lib/build-pages/page-data.test.js b/lib/build-pages/page-data.test.js
index 1d2363b2..cc82b87c 100644
--- a/lib/build-pages/page-data.test.js
+++ b/lib/build-pages/page-data.test.js
@@ -9,11 +9,11 @@ import assert from 'node:assert'
 import { mkdtemp, writeFile, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
-import { PageData } from './page-data.js'
+import { PageData, resolveLayout } from './page-data.js'
 import { computePageUrl } from './compute-page-url.js'
 
 /**
- * @typedef {Record<string, unknown> & { layout: string, title?: string, fromGlobalData?: boolean }} TestVars
+ * @typedef {Record<string, unknown> & { layout: string, title?: string, fromGlobal?: string, fromGlobalData?: string | boolean, fromLayout?: string, fromPage?: string }} TestVars
  */
 
 /** @type {BuilderOptions} */
@@ -23,6 +23,7 @@ const builderOptions = {}
 const fakeLayout = {
   name: 'default',
   render: async ({ children }) => String(children),
+  vars: {},
   layoutStylePath: null,
   layoutClientPath: null,
 }
@@ -93,6 +94,86 @@ test.describe('PageData.vars', () => {
     }
   })
 
+  test('resolves layout vars exports', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'domstack-resolve-layout-vars-test-'))
+    const layoutFile = join(dir, 'test.layout.mjs')
+
+    try {
+      await writeFile(layoutFile, `export const vars = async () => ({ fromLayout: 'layout vars' })
+export default function layout ({ children }) { return String(children) }
+`)
+
+      const layout = await resolveLayout(layoutFile)
+      const layoutVars = /** @type {{ fromLayout?: unknown }} */ (layout.vars)
+      assert.strictEqual(layoutVars.fromLayout, 'layout vars')
+      assert.strictEqual(typeof layout.render, 'function')
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+
+  test('merges layout vars between global and page vars', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'domstack-pagedata-layout-vars-test-'))
+    const mdFile = join(dir, 'test.md')
+    const pageVarsFile = join(dir, 'page.vars.js')
+
+    try {
+      await writeFile(mdFile, '---\ntitle: Frontmatter title\nfromLayout: frontmatter overrides layout\n---\n# Markdown title\n\nContent.')
+      await writeFile(pageVarsFile, `export default {
+  fromPage: 'page vars',
+  fromGlobalData: 'page overrides global data'
+}\n`)
+
+      /** @type {ResolvedLayout<TestVars, string, string>} */
+      const layout = {
+        name: 'default',
+        render: async ({ children }) => String(children),
+        vars: {
+          fromGlobal: 'layout overrides global',
+          fromLayout: 'layout vars',
+          fromPage: 'layout default',
+        },
+        layoutStylePath: null,
+        layoutClientPath: null,
+      }
+
+      /** @type {PageData<TestVars, string, string>} */
+      const pd = new PageData({
+        pageInfo: {
+          ...mdPageInfo(mdFile),
+          pageVars: {
+            root: dir,
+            filepath: pageVarsFile,
+            relname: 'blog/post/page.vars.js',
+            basename: 'page.vars.js',
+            parentName: 'blog/post',
+          },
+        },
+        globalVars: {
+          layout: 'default',
+          fromGlobal: 'global vars',
+          fromGlobalData: 'global vars',
+        },
+        globalStyle: undefined,
+        globalClient: undefined,
+        defaultStyle: null,
+        defaultClient: null,
+        builderOptions,
+      })
+
+      await pd.init({ layouts: { default: layout } })
+      pd.globalDataVars = { fromGlobalData: 'global data' }
+
+      assert.strictEqual(pd.vars['fromGlobal'], 'layout overrides global')
+      assert.strictEqual(pd.vars['fromGlobalData'], 'page overrides global data')
+      assert.strictEqual(pd.vars['fromLayout'], 'frontmatter overrides layout')
+      assert.strictEqual(pd.vars['fromPage'], 'page vars')
+      assert.strictEqual(pd.vars['title'], 'Frontmatter title')
+    } finally {
+      await rm(dir, { recursive: true, force: true })
+    }
+  })
+
   test('reads markdown content without front matter', async () => {
     const dir = await mkdtemp(join(tmpdir(), 'domstack-pagedata-md-content-test-'))
     const mdFile = join(dir, 'test.md')
diff --git a/lib/build-pages/resolve-vars.js b/lib/build-pages/resolve-vars.js
index 33ebcd38..b9bd52c2 100644
--- a/lib/build-pages/resolve-vars.js
+++ b/lib/build-pages/resolve-vars.js
@@ -1,3 +1,26 @@
+import { isFunction, isObject } from '../helpers/type-guards.js'
+
+/**
+ * Resolve an object-or-function vars export.
+ *
+ * @param {unknown} maybeVars
+ * @param {string} errorLabel
+ * @returns {Promise<object>}
+ */
+export async function resolveVarsExport (maybeVars, errorLabel) {
+  if (!maybeVars) return {}
+
+  if (isObject(maybeVars)) {
+    return maybeVars
+  } else if (isFunction(maybeVars)) {
+    const resolvedVars = await maybeVars()
+    if (isObject(resolvedVars)) return resolvedVars
+    throw new Error(`${errorLabel} function must resolve to an object`)
+  } else {
+    return {}
+  }
+}
+
 /**
  * Resolve variables by importing them from a specified path.
  *
@@ -13,21 +36,7 @@ export async function resolveVars ({
   if (!varsPath) return {}
 
   const imported = await import(varsPath)
-
-  const maybeVars = imported[key]
-
-  if (isObject(maybeVars)) {
-    return maybeVars
-  } else if (isFunction(maybeVars)) {
-    const resolvedVars = await maybeVars()
-    if (isObject(resolvedVars)) {
-      return resolvedVars
-    } else {
-      throw new Error('Var functions must resolve to an object')
-    }
-  } else {
-    return {}
-  }
+  return await resolveVarsExport(imported[key], 'Var')
 }
 
 /**
@@ -87,23 +96,3 @@ export async function resolvePostVars ({
 
   return null
 }
-
-/**
- * Checks if the given value is an object.
- *
- * @param {*} value - The value to check.
- * @returns {value is object}
- */
-function isObject (value) {
-  return value !== null && typeof value === 'object'
-}
-
-/**
- * Checks if the given value is an object.
- *
- * @param {*} value - The value to check.
- * @returns {value is function}
- */
-function isFunction (value) {
-  return value !== null && typeof value === 'function'
-}
diff --git a/lib/build-static/index.js b/lib/build-static/index.js
index 08315db7..95dfed6d 100644
--- a/lib/build-static/index.js
+++ b/lib/build-static/index.js
@@ -1,11 +1,13 @@
 /**
  * @import { BuildStepResult } from '../builder.js'
  * @import { BuildStep } from '../builder.js'
+ * @import { DomstackManifestRecord } from '../domstack-manifest/index.js'
  */
 import { copy } from 'cpx2'
+import { createCopiedDomstackManifestRecords } from '../helpers/cpx2-report.js'
 
 /**
- * @typedef {Awaited<ReturnType<typeof copy>>} StaticBuilderReport
+ * @typedef {{ outputs: DomstackManifestRecord[] }} StaticBuilderReport
  */
 
 /**
@@ -34,14 +36,19 @@ export async function buildStatic (src, dest, _siteData, opts) {
   /** @type {StaticBuildStepResult} */
   const results = {
     type: 'static',
-    report: {},
+    report: /** @type {StaticBuilderReport} */ ({ outputs: [] }),
     errors: [],
     warnings: [],
   }
 
   try {
     const report = await copy(getCopyGlob(src), dest, ...(opts?.ignore ? [{ ignore: opts.ignore }] : []))
-    results.report = report
+    results.report.outputs = createCopiedDomstackManifestRecords({
+      src,
+      dest,
+      report,
+      kind: 'static',
+    })
   } catch (err) {
     const buildError = new Error('Error copying static files', { cause: err })
     results.errors.push(buildError)
diff --git a/lib/builder.js b/lib/builder.js
index 76afd1d3..1d9a68b4 100644
--- a/lib/builder.js
+++ b/lib/builder.js
@@ -6,15 +6,27 @@
  * @import { PageBuildStepResult } from './build-pages/index.js'
  * @import { StaticBuildStepResult } from './build-static/index.js'
  * @import { CopyBuildStepResult } from './build-copy/index.js'
+ * @import { DomstackManifest } from './domstack-manifest/index.js'
+ * @import { DomstackManifestRecord } from './domstack-manifest/index.js'
+ * @import { DomstackManifestHooks } from './domstack-manifest/index.js'
+ * @import { DomstackManifestTransform } from './domstack-manifest/index.js'
 */
 
 import { buildPages } from './build-pages/index.js'
 import { identifyPages } from './identify-pages.js'
 import { buildStatic } from './build-static/index.js'
 import { buildCopy } from './build-copy/index.js'
-import { buildEsbuild } from './build-esbuild/index.js'
+import { buildEsbuild, buildServiceWorkerEsbuild } from './build-esbuild/index.js'
 import { DomStackAggregateError } from './helpers/domstack-aggregate-error.js'
 import { ensureDest } from './helpers/ensure-dest.js'
+import {
+  buildDomstackManifest,
+  isDomstackManifestEnabled,
+  resolveDomstackManifestOptions,
+  runDomstackManifestBuiltHooks,
+  shouldWriteDomstackManifest,
+  writeDomstackManifest,
+} from './domstack-manifest/index.js'
 
 /**
  * @typedef {Array<Error | EsbuildMessage>} BuildStepErrors
@@ -48,6 +60,7 @@ import { ensureDest } from './helpers/ensure-dest.js'
  * @typedef DomStackOpts
  * @property {boolean|undefined} [static=true] - Enable copying non-page, non-bundle static files from `src` into `dest`.
  * @property {boolean|undefined} [metafile=true] - Enable writing the esbuild metadata file.
+ * @property {boolean | { write?: boolean, exclude?: string[], manifestVars?: string[] | DomstackManifestTransform, policy?: Record<string, unknown> | Function, hooks?: DomstackManifestHooks } | undefined} [domstackManifest] - Configure the domstack manifest pipeline. Programmatic builds return it and hooks receive it; file writing is opt-in with `true` or `{ write: true }`.
  * @property {string[]|undefined} [ignore=[]] - Ignore patterns applied while discovering and copying source files.
  * @property {string[]|undefined} [target=[]] - Esbuild target values used for JavaScript and CSS bundling.
  * @property {boolean|undefined} [buildDrafts=false] - Build files marked with the `published: false` variable.
@@ -67,6 +80,7 @@ import { ensureDest } from './helpers/ensure-dest.js'
  * @property {StaticBuildStepResult} [staticResults]
  * @property {CopyBuildStepResult} [copyResults]
  * @property {PageBuildStepResult} [pageBuildResults]
+ * @property {DomstackManifest} [domstackManifest]
  * @property {BuildStepWarnings} warnings
  */
 
@@ -110,6 +124,16 @@ export async function builder (src, dest, opts) {
 
   await ensureDest(dest, siteData)
 
+  const domstackManifestSettingsPath = siteData?.domstackManifestSettings?.filepath
+  const domstackManifestEnabled = isDomstackManifestEnabled({
+    domstackManifestSettingsPath,
+    opts,
+  })
+  const domstackManifestOptions = await resolveDomstackManifestOptions({
+    domstackManifestSettingsPath,
+    opts,
+  })
+
   const [
     esbuildResults,
     staticResults,
@@ -118,7 +142,7 @@ export async function builder (src, dest, opts) {
     buildEsbuild(src, dest, siteData, opts),
     opts.static
       ? buildStatic(src, dest, siteData, opts)
-      : Promise.resolve(),
+      : Promise.resolve(null),
     buildCopy(src, dest, siteData, opts),
   ])
 
@@ -156,7 +180,55 @@ export async function builder (src, dest, opts) {
   if (errors.length > 0) {
     const buildError = new DomStackAggregateError(errors, 'Build finished but there were errors.', results)
     throw buildError
-  } else {
-    return results
   }
+
+  const baseOutputRecords = collectOutputRecords(
+    esbuildResults,
+    staticResults,
+    copyResults,
+    pageBuildResults
+  )
+
+  const domstackManifest = domstackManifestEnabled
+    ? await buildDomstackManifest({
+      dest,
+      records: baseOutputRecords,
+      options: domstackManifestOptions,
+    })
+    : undefined
+
+  const domstackManifestBuiltHookResult = domstackManifest
+    ? await runDomstackManifestBuiltHooks(dest, domstackManifest, domstackManifestOptions)
+    : { serviceWorkerDefines: {} }
+
+  const serviceWorkerBuildDefines = {
+    define: domstackManifestBuiltHookResult.serviceWorkerDefines,
+    ...(domstackManifest ? { manifestVersion: domstackManifest.version } : {}),
+  }
+
+  const serviceWorkerEsbuildResults = await buildServiceWorkerEsbuild(src, dest, siteData, opts, serviceWorkerBuildDefines)
+
+  errors.push(...serviceWorkerEsbuildResults.errors)
+  warnings.push(...serviceWorkerEsbuildResults.warnings)
+
+  if (errors.length > 0) {
+    const serviceWorkerBuildError = new DomStackAggregateError(errors, 'Service worker build finished but there were errors.', results)
+    throw serviceWorkerBuildError
+  }
+
+  if (domstackManifest) results.domstackManifest = domstackManifest
+
+  if (domstackManifest && shouldWriteDomstackManifest(opts)) {
+    await writeDomstackManifest(dest, domstackManifest)
+  }
+
+  return results
+}
+
+/**
+ * @param  {...{ report?: { outputs?: DomstackManifestRecord[] } } | null | undefined} results
+ * @returns {DomstackManifestRecord[]}
+ */
+function collectOutputRecords (...results) {
+  return results.flatMap(result => result?.report?.outputs ?? [])
 }
diff --git a/lib/domstack-manifest/index.js b/lib/domstack-manifest/index.js
new file mode 100644
index 00000000..255096d3
--- /dev/null
+++ b/lib/domstack-manifest/index.js
@@ -0,0 +1,990 @@
+/**
+ * @import { DomStackOpts } from '../builder.js'
+ * @import { FromSchema, JSONSchema } from 'json-schema-to-ts'
+ */
+
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
+import { dirname, relative, resolve } from 'node:path'
+import ignore from 'ignore'
+import { contentType } from 'mime-types'
+import { resolveVars } from '../build-pages/resolve-vars.js'
+import { assertInsideDest, toPosix } from '../helpers/path.js'
+import { stableJsonStringify } from '../helpers/stable-json-stringify.js'
+import { isFunction, isPlainObject } from '../helpers/type-guards.js'
+
+export const DEFAULT_DOMSTACK_MANIFEST_FILENAME = 'domstack-manifest.json'
+export const DOMSTACK_MANIFEST_SCHEMA_PATH = 'lib/domstack-manifest/schema.json'
+// The published JSON schema URL is versioned so manifest files keep pointing at the
+// schema contract they were generated against after future domstack releases.
+export const DOMSTACK_MANIFEST_SCHEMA_ID = getDomstackManifestSchemaId(readPackageVersion())
+
+// Manifest schema and public types
+
+// These schema objects are the source of truth for both runtime manifest validation and
+// the public TypeScript/JSDoc types derived below with json-schema-to-ts.
+export const domstackManifestKindSchema = /** @satisfies {JSONSchema} */ (/** @type {const} */ ({
+  description: 'Classifies the build pipeline step or artifact type that produced this output.',
+  enum: [
+    'page',
+    'template',
+    'script',
+    'style',
+    'chunk',
+    'service-worker',
+    'worker',
+    'worker-manifest',
+    'static',
+    'copy',
+    'sourcemap',
+    'metadata',
+  ],
+}))
+
+export const domstackManifestEntryPageMetaSchema = /** @satisfies {JSONSchema} */ (/** @type {const} */ ({
+  description: 'Page-specific metadata recorded for manifest entries whose kind is "page".',
+  type: 'object',
+  properties: {
+    path: {
+      description: 'Source-relative page path used by domstack routing, without a leading slash.',
+      type: 'string',
+    },
+    url: {
+      description: 'Canonical public URL for the page, such as "/" or "/docs/".',
+      type: 'string',
+    },
+    vars: {
+      description: 'Selected page variables that can affect offline or precache policy.',
+      type: 'object',
+      properties: {
+        precache: {
+          description: 'Application-defined page precache policy metadata. Domstack records this value but does not interpret it.',
+        },
+        offline: {
+          description: 'Application-defined page offline availability metadata. Domstack records this value but does not interpret it.',
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  required: ['path', 'url'],
+  additionalProperties: false,
+}))
+
+export const domstackManifestEntrySchema = /** @satisfies {JSONSchema} */ (/** @type {const} */ ({
+  description: 'One public output emitted by domstack and included in the reconciled domstack manifest.',
+  type: 'object',
+  properties: {
+    outputRelname: {
+      description: 'Destination-relative output path using POSIX separators, such as "index.html" or "chunks/js/chunk-ABC.js".',
+      type: 'string',
+    },
+    kind: domstackManifestKindSchema,
+    url: {
+      description: 'Public same-origin URL for the output, normalized with a leading slash.',
+      type: 'string',
+    },
+    revision: {
+      description: 'SHA-256 hex digest of the output file contents. Null is reserved for outputs without a content revision.',
+      type: ['string', 'null'],
+    },
+    bytes: {
+      description: 'Output file size in bytes. Null is reserved for outputs whose size is unavailable.',
+      type: ['integer', 'null'],
+    },
+    sourceRelname: {
+      description: 'Source-relative path that produced this output when a direct source file is known.',
+      type: 'string',
+    },
+    entryPoint: {
+      description: 'esbuild entry point path for script, style, worker, and service-worker outputs when available.',
+      type: 'string',
+    },
+    pagePath: {
+      description: 'Source-relative page path associated with this output when the output belongs to a page.',
+      type: 'string',
+    },
+    pageUrl: {
+      description: 'Canonical public page URL associated with this output when the output belongs to a page.',
+      type: 'string',
+    },
+    templatePath: {
+      description: 'Source-relative template path associated with this output when the output was emitted by a template.',
+      type: 'string',
+    },
+    contentType: {
+      description: 'Best-known MIME type for the emitted output. This is a build-time value and may differ from deployment HTTP headers.',
+      type: 'string',
+    },
+    integrity: {
+      description: 'SRI-formatted SHA-256 digest derived from the same content hash as revision, such as "sha256-AbCd...".',
+      type: 'string',
+    },
+    manifestVars: {
+      description: 'Explicitly selected page/app variables exposed for general manifest consumers.',
+      type: 'object',
+      additionalProperties: {
+        description: 'Application-defined manifest variable value copied from the resolved page variable cascade. Domstack records this value but does not interpret it.',
+      },
+    },
+    urlRevisioned: {
+      description: 'Whether the public URL already contains a content hash or equivalent revision token.',
+      type: 'boolean',
+    },
+    static: {
+      description: 'Whether this entry is part of domstack static browser-loadable output and can be considered by offline/cache/deploy tooling.',
+      type: 'boolean',
+    },
+    role: {
+      description: 'Normalized runtime purpose for the entry, such as "navigation", "subresource", "worker", or "metadata".',
+      type: 'string',
+    },
+    page: domstackManifestEntryPageMetaSchema,
+  },
+  required: ['outputRelname', 'kind', 'url', 'revision', 'bytes'],
+  additionalProperties: false,
+}))
+
+export const domstackManifestSchema = /** @satisfies {JSONSchema} */ (/** @type {const} */ ({
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  $id: DOMSTACK_MANIFEST_SCHEMA_ID,
+  title: 'Domstack manifest',
+  description: 'A normalized, revisioned manifest of public files emitted by a domstack build.',
+  type: 'object',
+  properties: {
+    $schema: {
+      description: 'Versioned URL of the JSON Schema that describes this manifest.',
+      const: DOMSTACK_MANIFEST_SCHEMA_ID,
+    },
+    version: {
+      description: 'SHA-256 hex digest derived from the final cache-relevant manifest entries.',
+      type: 'string',
+    },
+    generatedAt: {
+      description: 'ISO 8601 timestamp for when domstack generated this manifest.',
+      type: 'string',
+      format: 'date-time',
+    },
+    entries: {
+      description: 'Sorted public output entries included in the manifest after excludes and filters are applied.',
+      type: 'array',
+      items: domstackManifestEntrySchema,
+    },
+    policy: {
+      description: 'Freeform application or integration policy for the whole manifest, exposed for service workers, deployment tools, or other consumers.',
+      type: 'object',
+      additionalProperties: {
+        description: 'Application-defined manifest policy value. Domstack records this value once at the manifest root but does not interpret it.',
+      },
+    },
+  },
+  required: ['$schema', 'version', 'generatedAt', 'entries'],
+  additionalProperties: false,
+}))
+
+/**
+ * This helper is exported for release tooling and consumers that need to reconstruct
+ * the versioned unpkg schema URL without duplicating domstack's package path.
+ *
+ * @param {string} version
+ */
+export function getDomstackManifestSchemaId (version) {
+  return `https://unpkg.com/@domstack/static@${version}/${DOMSTACK_MANIFEST_SCHEMA_PATH}`
+}
+
+/**
+ * @typedef {FromSchema<typeof domstackManifestKindSchema>} DomstackManifestKind
+ */
+
+/**
+ * @typedef {FromSchema<typeof domstackManifestEntryPageMetaSchema>} DomstackManifestEntryPageMeta
+ */
+
+/**
+ * A build step writes these as it emits files. Reconciliation turns them into
+ * revisioned manifest entries.
+ *
+ * @typedef {object} DomstackManifestRecord
+ * @property {string} outputRelname - Destination-relative output path using POSIX separators.
+ * @property {string} filepath - Absolute filesystem path for the emitted output.
+ * @property {DomstackManifestKind} kind - Build artifact category for reconciliation and manifest consumers.
+ * @property {string} [url] - Public same-origin URL for the output.
+ * @property {string} [sourceRelname] - Source-relative path that produced the output when known.
+ * @property {string} [entryPoint] - esbuild entry point path for bundled outputs when available.
+ * @property {string} [pagePath] - Source-relative page path associated with page-owned output.
+ * @property {string} [pageUrl] - Canonical public URL for the page associated with this output.
+ * @property {string} [templatePath] - Source-relative template path associated with template output.
+ * @property {Record<string, unknown>} [pageVars] - Internal page variables available to manifest option transforms.
+ * @property {string} [manifestRole] - Explicit user-provided role for this output.
+ * @property {Record<string, unknown>} [manifestVars] - Explicit page/app variables to expose on this manifest entry.
+
+ * @property {string} [contentType] - Best-known MIME type for this output.
+ * @property {string} [integrity] - SRI-formatted digest for this output.
+ * @property {boolean} [urlRevisioned] - Whether the output URL already changes with content.
+ * @property {boolean} [static] - Whether this output is static browser-loadable output.
+ * @property {string} [role] - Normalized runtime purpose for this output.
+ * @property {DomstackManifestEntryPageMeta} [page] - Page metadata copied onto page manifest entries.
+ */
+
+/**
+ * @typedef {FromSchema<typeof domstackManifestEntrySchema>} DomstackManifestEntryShape
+ */
+
+/**
+ * @template [ManifestVars=Record<string, unknown>]
+ * @typedef {Omit<DomstackManifestEntryShape, 'manifestVars'> & { manifestVars?: ManifestVars }} DomstackManifestEntry
+ */
+
+/**
+ * @typedef {FromSchema<typeof domstackManifestSchema>} DomstackManifestShape
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @typedef {Omit<DomstackManifestShape, 'entries' | 'policy'> & { entries: DomstackManifestEntry<ManifestVars>[], policy?: Policy }} DomstackManifest
+ */
+
+/**
+ * @template [ManifestVars=Record<string, unknown>]
+ * @template [SourceVars=Record<string, unknown>]
+ * @typedef {object} DomstackManifestTransformContext
+ * @property {SourceVars} vars - Source variables associated with this entry, when available.
+ * @property {DomstackManifestEntry<ManifestVars>} entry - Public manifest entry before transformed fields are attached.
+ * @property {{ path?: string, url?: string } | undefined} [pageInfo] - Page identity for page-owned entries.
+ */
+
+/**
+ * @template [Value=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @template [SourceVars=Record<string, unknown>]
+ * @callback DomstackManifestTransform
+ * @param {DomstackManifestTransformContext<ManifestVars, SourceVars>} context
+ * @returns {Value | undefined | Promise<Value | undefined>}
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @typedef {object} DomstackManifestPolicyTransformContext
+ * @property {DomstackManifestEntry<ManifestVars>[]} entries - Final public manifest entries after excludes, filters, and entry-level manifestVars are applied.
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @callback DomstackManifestPolicyTransform
+ * @param {DomstackManifestPolicyTransformContext<Policy, ManifestVars>} context
+ * @returns {Policy | undefined | Promise<Policy | undefined>}
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @typedef {object} DomstackManifestBuiltHookContext
+ * @property {string} dest - Absolute output directory for the current build.
+ * @property {DomstackManifest<Policy, ManifestVars>} manifest - Final domstack manifest after entries and root policy are resolved.
+ * @property {(identifier: string, value: unknown) => void} defineServiceWorkerConstant - Define a JSON-serializable constant available only to the final service-worker bundle.
+ * @property {(outputRelname: string, contents: string | Uint8Array) => Promise<void>} writeFile - Write a generated file under `dest`.
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @callback DomstackManifestBuiltHook
+ * @param {DomstackManifestBuiltHookContext<Policy, ManifestVars>} context
+ * @returns {void | Promise<void>}
+ */
+
+/**
+ * @typedef {object} DomstackManifestBuiltHookResult
+ * @property {Record<string, string>} serviceWorkerDefines - Esbuild define expressions collected for the final service-worker build.
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @typedef {object} DomstackManifestHooks
+ * @property {DomstackManifestBuiltHook<Policy, ManifestVars>[]} [manifestBuilt] - Hooks that run after the manifest is built and before it is written.
+ */
+
+/**
+ * @template [Policy=Record<string, unknown>]
+ * @template [ManifestVars=Record<string, unknown>]
+ * @template [SourceVars=Record<string, unknown>]
+ * @typedef {object} DomstackManifestOptions
+ * @property {string[]} [exclude] - Glob patterns for manifest entries to exclude by URL path or output relname.
+ * @property {(entry: DomstackManifestEntry<ManifestVars>) => boolean | Promise<boolean>} [includeEntry] - Optional predicate that receives the public manifest entry before it is kept.
+ * @property {string[] | DomstackManifestTransform<ManifestVars, ManifestVars, SourceVars>} [manifestVars] - Variables to expose on `entry.manifestVars`, either by allowlist or transform.
+ * @property {Policy | DomstackManifestPolicyTransform<Policy, ManifestVars>} [policy] - Freeform policy to expose once at manifest root, either as an object or generated from final entries.
+ * @property {DomstackManifestHooks<Policy, ManifestVars>} [hooks] - Manifest lifecycle hooks for generated artifacts such as service-worker policies or Workbox manifests.
+ */
+
+/**
+ * A manifest record after its output file has been normalized and revisioned.
+ *
+ * @typedef {DomstackManifestRecord & {
+ *   url: string,
+ *   revision: string | null,
+ *   bytes: number | null
+ * }} DomstackManifestInternalEntry
+ */
+
+const KIND_PRIORITY = new Map([
+  ['page', 100],
+  ['service-worker', 95],
+  ['template', 90],
+  ['worker-manifest', 80],
+  ['worker', 70],
+  ['script', 60],
+  ['style', 50],
+  ['chunk', 40],
+  ['static', 30],
+  ['copy', 20],
+  ['sourcemap', 10],
+  ['metadata', 0],
+])
+
+// Manifest reconciliation
+
+/**
+ * Build a normalized, revisioned manifest from records emitted by build steps.
+ *
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {DomstackManifestRecord[]} [params.records]
+ * @param {DomstackManifestEntry[]} [params.entries]
+ * @param {DomstackManifestOptions} [params.options]
+ * @returns {Promise<DomstackManifest>}
+ */
+export async function buildDomstackManifest ({ dest, records = [], entries: existingEntries = [], options = {} }) {
+  const manifestOutputRelname = DEFAULT_DOMSTACK_MANIFEST_FILENAME
+  const excludeMatcher = createExcludeMatcher(options.exclude ?? [])
+  /** @type {Map<string, DomstackManifestInternalEntry>} */
+  const entryMap = new Map()
+
+  for (const entry of existingEntries) {
+    if (toPosix(entry.outputRelname) === manifestOutputRelname) continue
+    setEntry(entryMap, normalizeExistingEntry({ dest, entry }))
+  }
+
+  for (const record of records) {
+    if (toPosix(record.outputRelname) === manifestOutputRelname) continue
+    const entry = await createEntry({ dest, record })
+    setEntry(entryMap, entry)
+  }
+
+  const version = createHash('sha256')
+  /** @type {DomstackManifestEntry[]} */
+  const finalEntries = []
+  const sortedEntries = Array.from(entryMap.values()).sort((a, b) => a.url.localeCompare(b.url))
+
+  for (const entry of sortedEntries) {
+    if (!entry.revision || isExcludedEntry(entry, excludeMatcher)) continue
+
+    const publicEntry = await toPublicEntry(entry, options)
+    if (options.includeEntry && !(await options.includeEntry(publicEntry))) continue
+
+    updateManifestVersionHash(version, publicEntry)
+    finalEntries.push(publicEntry)
+  }
+
+  const policy = await resolveManifestPolicy(options, finalEntries)
+  updateManifestVersionValue(version, policy)
+
+  return {
+    $schema: DOMSTACK_MANIFEST_SCHEMA_ID,
+    version: version.digest('hex'),
+    generatedAt: new Date().toISOString(),
+    entries: finalEntries,
+    ...(policy ? { policy } : {}),
+  }
+}
+
+// Public build-step helpers
+
+/**
+ * Create a normalized record for a file inside dest.
+ *
+ * @param {object} params
+ * @param {string} params.dest - Destination directory that owns the output file.
+ * @param {string} [params.filepath] - Absolute or relative filesystem path to the emitted output.
+ * @param {string} [params.outputRelname] - Destination-relative output path when `filepath` should not be relativized.
+ * @param {DomstackManifestKind} params.kind - Build artifact category for this output.
+ * @param {string} [params.url] - Public same-origin URL when the default output path URL is not correct.
+ * @param {string} [params.sourceRelname] - Source-relative path that produced this output when known.
+ * @param {string} [params.entryPoint] - esbuild entry point path for bundled outputs when available.
+ * @param {string} [params.pagePath] - Source-relative page path for page-owned outputs.
+ * @param {string} [params.pageUrl] - Canonical public page URL for page-owned outputs.
+ * @param {string} [params.templatePath] - Source-relative template path for template outputs.
+ * @param {Record<string, unknown>} [params.pageVars] - Internal page variables available to manifest option transforms.
+ * @param {string} [params.manifestRole] - Explicit user-provided role for this output.
+ * @param {Record<string, unknown>} [params.manifestVars] - Explicit page/app variables to expose on this manifest entry.
+
+ * @param {DomstackManifestEntryPageMeta} [params.page] - Page metadata to copy onto page entries.
+ * @returns {DomstackManifestRecord}
+ */
+export function createDomstackManifestRecord ({
+  dest,
+  filepath,
+  outputRelname,
+  kind,
+  url,
+  sourceRelname,
+  entryPoint,
+  pagePath,
+  pageUrl,
+  templatePath,
+  pageVars,
+  manifestRole,
+  manifestVars,
+  page,
+}) {
+  const resolvedFilepath = filepath
+    ? resolve(filepath)
+    : resolve(dest, outputRelname ?? '')
+  assertInsideDest(dest, resolvedFilepath)
+
+  const normalizedOutputRelname = toPosix(outputRelname ?? relative(dest, resolvedFilepath))
+
+  return {
+    outputRelname: normalizedOutputRelname,
+    filepath: resolvedFilepath,
+    kind,
+    url: url ?? outputRelnameToUrl(normalizedOutputRelname),
+    ...(sourceRelname ? { sourceRelname: toPosix(sourceRelname) } : {}),
+    ...(entryPoint ? { entryPoint: normalizeEntryPoint(entryPoint) } : {}),
+    ...(pagePath ? { pagePath } : {}),
+    ...(pageUrl ? { pageUrl } : {}),
+    ...(templatePath ? { templatePath } : {}),
+    ...(pageVars ? { pageVars } : {}),
+    ...(manifestRole ? { manifestRole } : {}),
+    ...(manifestVars ? { manifestVars } : {}),
+    ...(page ? { page } : {}),
+  }
+}
+
+// Manifest writing and options
+
+/**
+ * @param {string} dest
+ * @param {DomstackManifest} domstackManifest
+ */
+export async function writeDomstackManifest (dest, domstackManifest) {
+  const manifestPath = resolve(dest, DEFAULT_DOMSTACK_MANIFEST_FILENAME)
+  assertInsideDest(dest, manifestPath)
+  await mkdir(dirname(manifestPath), { recursive: true })
+  await writeFile(manifestPath, JSON.stringify(domstackManifest, null, 2))
+}
+
+/**
+ * @param {object} params
+ * @param {string | undefined} params.domstackManifestSettingsPath
+ * @param {DomStackOpts | undefined} params.opts
+ * @returns {Promise<DomstackManifestOptions>}
+ */
+export async function resolveDomstackManifestOptions ({ domstackManifestSettingsPath, opts }) {
+  const domstackManifestOpts = typeof opts?.domstackManifest === 'object'
+    ? opts.domstackManifest
+    : {}
+  const domstackManifestSettings = /** @type {Partial<DomstackManifestOptions>} */ (await resolveVars({
+    varsPath: domstackManifestSettingsPath,
+  }))
+  const includeEntry = isFunction(domstackManifestSettings.includeEntry)
+    ? domstackManifestSettings.includeEntry
+    : undefined
+  const manifestVars = normalizeManifestFieldSetting(domstackManifestSettings.manifestVars ?? domstackManifestOpts.manifestVars)
+  const policy = normalizeManifestPolicySetting(domstackManifestSettings.policy ?? domstackManifestOpts.policy)
+  /** @type {DomstackManifestOptions} */
+  const options = {
+    exclude: [
+      ...toStringArray(domstackManifestOpts.exclude),
+      ...toStringArray(domstackManifestSettings.exclude),
+    ],
+  }
+
+  const hooks = mergeManifestHooks(domstackManifestOpts.hooks, domstackManifestSettings.hooks)
+
+  if (includeEntry) options.includeEntry = includeEntry
+  if (manifestVars) options.manifestVars = manifestVars
+  if (policy) options.policy = policy
+  if (hooks) options.hooks = hooks
+
+  return options
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string[]}
+ */
+function toStringArray (value) {
+  return Array.isArray(value)
+    ? value.filter(item => typeof item === 'string')
+    : []
+}
+
+/**
+ * @param {unknown} value
+ * @returns {DomstackManifestOptions['manifestVars'] | undefined}
+ */
+function normalizeManifestFieldSetting (value) {
+  if (isFunction(value)) return /** @type {DomstackManifestTransform} */ (value)
+  const allowlist = toStringArray(value)
+  return allowlist.length > 0 ? allowlist : undefined
+}
+
+/**
+ * @param {unknown} value
+ * @returns {DomstackManifestOptions['policy'] | undefined}
+ */
+function normalizeManifestPolicySetting (value) {
+  if (isFunction(value)) return /** @type {DomstackManifestPolicyTransform} */ (value)
+  return isPlainObject(value) ? value : undefined
+}
+
+/**
+ * @param {DomstackManifestOptions['hooks'] | undefined} first
+ * @param {DomstackManifestOptions['hooks'] | undefined} second
+ * @returns {DomstackManifestOptions['hooks'] | undefined}
+ */
+function mergeManifestHooks (first, second) {
+  const manifestBuilt = [
+    ...toFunctionArray(first?.manifestBuilt),
+    ...toFunctionArray(second?.manifestBuilt),
+  ]
+
+  return manifestBuilt.length > 0 ? { manifestBuilt } : undefined
+}
+
+/**
+ * @param {unknown} value
+ * @returns {DomstackManifestBuiltHook[]}
+ */
+function toFunctionArray (value) {
+  return Array.isArray(value)
+    ? /** @type {DomstackManifestBuiltHook[]} */ (value.filter(isFunction))
+    : []
+}
+
+/**
+ * @param {string} dest
+ * @param {string} outputRelname
+ * @param {string | Uint8Array} contents
+ */
+async function writeGeneratedManifestFile (dest, outputRelname, contents) {
+  const filepath = resolve(dest, outputRelname)
+  assertInsideDest(dest, filepath)
+  await mkdir(dirname(filepath), { recursive: true })
+  await writeFile(filepath, contents)
+}
+
+/**
+ * Run generated-artifact hooks after the domstack manifest has been built.
+ *
+ * @param {string} dest
+ * @param {DomstackManifest} manifest
+ * @param {DomstackManifestOptions} options
+ * @returns {Promise<DomstackManifestBuiltHookResult>}
+ */
+export async function runDomstackManifestBuiltHooks (dest, manifest, options) {
+  const serviceWorkerDefines = /** @type {Record<string, string>} */ ({})
+  const hooks = options.hooks?.manifestBuilt ?? []
+
+  for (const hook of hooks) {
+    await hook({
+      dest,
+      manifest,
+      defineServiceWorkerConstant: (identifier, value) => {
+        serviceWorkerDefines[identifier] = JSON.stringify(value)
+      },
+      writeFile: (outputRelname, contents) => writeGeneratedManifestFile(dest, outputRelname, contents),
+    })
+  }
+
+  return { serviceWorkerDefines }
+}
+
+/**
+ * @param {object} params
+ * @param {string | undefined} params.domstackManifestSettingsPath
+ * @param {DomStackOpts | undefined} params.opts
+ */
+export function isDomstackManifestEnabled ({ domstackManifestSettingsPath, opts }) {
+  return Boolean(domstackManifestSettingsPath || opts?.domstackManifest)
+}
+
+/**
+ * @param {DomStackOpts | undefined} opts
+ */
+export function shouldWriteDomstackManifest (opts) {
+  if (opts?.domstackManifest === true) return true
+  return typeof opts?.domstackManifest === 'object' && opts.domstackManifest.write === true
+}
+
+/**
+ * @param {string} relname
+ */
+export function outputRelnameToUrl (relname) {
+  const posixRelname = toPosix(relname)
+  return `/${posixRelname === 'index.html' ? '' : posixRelname.replace(/\/index\.html$/, '/')}`
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {DomstackManifestRecord} params.record
+ * @returns {Promise<DomstackManifestInternalEntry | null>}
+ */
+async function createEntry ({ dest, record }) {
+  const filepath = resolve(record.filepath)
+  assertInsideDest(dest, filepath)
+  let fileStat
+  try {
+    fileStat = await stat(filepath)
+  } catch {
+    return null
+  }
+  if (!fileStat.isFile()) return null
+
+  const digest = await hashFileDigest(filepath)
+  const outputRelname = toPosix(record.outputRelname)
+  const url = record.url ?? outputRelnameToUrl(record.outputRelname)
+
+  /** @type {DomstackManifestInternalEntry} */
+  const entry = {
+    ...record,
+    outputRelname,
+    filepath,
+    url,
+    revision: digest.hex,
+    integrity: record.integrity ?? digest.integrity,
+    bytes: fileStat.size,
+  }
+
+  applyDerivedEntryFields(entry)
+  return entry
+}
+
+/**
+ * @param {object} params
+ * @param {string} params.dest
+ * @param {DomstackManifestEntry} params.entry
+ * @returns {DomstackManifestInternalEntry}
+ */
+function normalizeExistingEntry ({ dest, entry }) {
+  const filepath = resolve(dest, entry.outputRelname)
+  assertInsideDest(dest, filepath)
+  const outputRelname = toPosix(entry.outputRelname)
+  const url = entry.url ?? outputRelnameToUrl(entry.outputRelname)
+
+  /** @type {DomstackManifestInternalEntry} */
+  const normalizedEntry = {
+    ...entry,
+    outputRelname,
+    filepath,
+    url,
+  }
+
+  if (!normalizedEntry.integrity) {
+    const integrity = revisionToIntegrity(normalizedEntry.revision)
+    if (integrity) normalizedEntry.integrity = integrity
+  }
+
+  applyDerivedEntryFields(normalizedEntry)
+  return normalizedEntry
+}
+
+/**
+ * @param {Map<string, DomstackManifestInternalEntry>} entries
+ * @param {DomstackManifestInternalEntry | null} entry
+ */
+function setEntry (entries, entry) {
+  if (!entry) return
+  const existing = entries.get(entry.outputRelname)
+  const entryPriority = KIND_PRIORITY.get(entry.kind) ?? -1
+  const existingPriority = existing ? KIND_PRIORITY.get(existing.kind) ?? -1 : -1
+  if (!existing || entryPriority >= existingPriority) entries.set(entry.outputRelname, entry)
+}
+
+/**
+ * Apply derived fields that can be computed from existing build output facts.
+ * This keeps record-created and existing-entry reconciliation behavior aligned.
+ *
+ * @param {DomstackManifestInternalEntry} entry
+ */
+function applyDerivedEntryFields (entry) {
+  if (!entry.contentType) {
+    const contentType = inferContentType(entry.outputRelname)
+    if (contentType) entry.contentType = contentType
+  }
+
+  entry.urlRevisioned = entry.urlRevisioned ?? inferUrlRevisioned(entry)
+  entry.static = entry.static ?? inferStatic(entry.kind)
+  entry.role = entry.manifestRole ?? entry.role ?? inferRole(entry)
+}
+
+/**
+ * @param {object} params
+ * @param {DomstackManifestInternalEntry} params.entry
+ * @param {DomstackManifestEntry} params.publicEntry
+ * @param {DomstackManifestOptions} params.options
+ * @param {'manifestVars'} params.field
+ * @returns {Promise<Record<string, unknown> | undefined>}
+ */
+async function resolveManifestField ({ entry, publicEntry, options, field }) {
+  const setting = options[field]
+  const existing = entry[field]
+  if (!setting) return existing
+
+  const vars = entry.pageVars ?? entry.page?.vars ?? {}
+
+  if (Array.isArray(setting)) {
+    const selected = pickManifestField(vars, setting)
+    return mergeManifestField(existing, selected)
+  }
+
+  const transformed = await setting({
+    vars,
+    entry: publicEntry,
+    pageInfo: entry.page ? { path: entry.page.path, url: entry.page.url } : undefined,
+  })
+
+  return mergeManifestField(existing, transformed)
+}
+
+/**
+ * @param {Record<string, unknown>} vars
+ * @param {string[]} keys
+ * @returns {Record<string, unknown> | undefined}
+ */
+function pickManifestField (vars, keys) {
+  const selected = /** @type {Record<string, unknown>} */ ({})
+  for (const key of keys) {
+    if (Object.hasOwn(vars, key)) selected[key] = vars[key]
+  }
+  return Object.keys(selected).length > 0 ? selected : undefined
+}
+
+/**
+ * @param {Record<string, unknown> | undefined} base
+ * @param {Record<string, unknown> | undefined} next
+ * @returns {Record<string, unknown> | undefined}
+ */
+function mergeManifestField (base, next) {
+  if (!base && !next) return undefined
+  return { ...(base ?? {}), ...(next ?? {}) }
+}
+
+/**
+ * @param {DomstackManifestOptions} options
+ * @param {DomstackManifestEntry[]} entries
+ * @returns {Promise<Record<string, unknown> | undefined>}
+ */
+async function resolveManifestPolicy (options, entries) {
+  if (!options.policy) return undefined
+  if (typeof options.policy === 'function') {
+    return await options.policy({ entries })
+  }
+  return options.policy
+}
+
+/**
+ * Project internal output records onto the serialized manifest contract. Keep this
+ * explicit so new internal fields cannot accidentally leak into public JSON.
+ *
+ * @param {DomstackManifestInternalEntry} entry
+ * @param {DomstackManifestOptions} options
+ * @returns {Promise<DomstackManifestEntry>}
+ */
+async function toPublicEntry (entry, options) {
+  const publicEntry = {
+    outputRelname: entry.outputRelname,
+    kind: entry.kind,
+    url: entry.url,
+    revision: entry.revision,
+    bytes: entry.bytes,
+    ...(entry.sourceRelname ? { sourceRelname: entry.sourceRelname } : {}),
+    ...(entry.entryPoint ? { entryPoint: entry.entryPoint } : {}),
+    ...(entry.pagePath ? { pagePath: entry.pagePath } : {}),
+    ...(entry.pageUrl ? { pageUrl: entry.pageUrl } : {}),
+    ...(entry.templatePath ? { templatePath: entry.templatePath } : {}),
+    ...(entry.contentType ? { contentType: entry.contentType } : {}),
+    ...(entry.integrity ? { integrity: entry.integrity } : {}),
+    ...(entry.manifestVars ? { manifestVars: entry.manifestVars } : {}),
+    ...(typeof entry.urlRevisioned === 'boolean' ? { urlRevisioned: entry.urlRevisioned } : {}),
+    ...(typeof entry.static === 'boolean' ? { static: entry.static } : {}),
+    ...(entry.role ? { role: entry.role } : {}),
+    ...(entry.page ? { page: entry.page } : {}),
+  }
+
+  const manifestVars = await resolveManifestField({ entry, publicEntry, options, field: 'manifestVars' })
+  return {
+    ...publicEntry,
+    ...(manifestVars ? { manifestVars } : {}),
+  }
+}
+
+/**
+ * Hash only the fields that affect static cache membership and content. Source
+ * metadata is intentionally ignored so debug/build-origin changes do not churn
+ * PWA cache names.
+ *
+ * @param {{ update: (value: string) => unknown }} hash
+ * @param {DomstackManifestEntry} entry
+ */
+function updateManifestVersionHash (hash, entry) {
+  hash.update(entry.url)
+  hash.update('\0')
+  hash.update(entry.revision ?? '')
+  hash.update('\0')
+  hash.update(entry.kind)
+  hash.update('\0')
+  updateManifestVersionValue(hash, entry.contentType)
+  updateManifestVersionValue(hash, entry.integrity)
+  updateManifestVersionValue(hash, entry.manifestVars)
+  updateManifestVersionValue(hash, entry.urlRevisioned)
+  updateManifestVersionValue(hash, entry.static)
+  updateManifestVersionValue(hash, entry.role)
+  updateManifestVersionPageVar(hash, entry.page?.vars, 'precache')
+  updateManifestVersionPageVar(hash, entry.page?.vars, 'offline')
+}
+
+/**
+ * @param {{ update: (value: string) => unknown }} hash
+ * @param {{ precache?: unknown, offline?: unknown } | undefined} vars
+ * @param {'precache'|'offline'} key
+ */
+function updateManifestVersionPageVar (hash, vars, key) {
+  if (!vars || !Object.hasOwn(vars, key)) {
+    hash.update('\0')
+    return
+  }
+
+  updateManifestVersionValue(hash, vars[key])
+}
+
+/**
+ * @param {{ update: (value: string) => unknown }} hash
+ * @param {unknown} value
+ */
+function updateManifestVersionValue (hash, value) {
+  const serializedValue = stableJsonStringify(value)
+  hash.update(serializedValue ?? '')
+  hash.update('\0')
+}
+
+/**
+ * @param {string[]} exclude
+ * @returns {ReturnType<typeof ignore> | null}
+ */
+function createExcludeMatcher (exclude) {
+  if (exclude.length === 0) return null
+
+  return ignore().add(exclude.map(pattern => pattern.startsWith('/') ? pattern.slice(1) : pattern))
+}
+
+/**
+ * @param {DomstackManifestInternalEntry} entry
+ * @param {ReturnType<typeof ignore> | null} excludeMatcher
+ */
+function isExcludedEntry (entry, excludeMatcher) {
+  if (!excludeMatcher) return false
+
+  const urlPath = entry.url.startsWith('/') ? entry.url.slice(1) : entry.url
+  return isIgnoredPath(excludeMatcher, urlPath) || isIgnoredPath(excludeMatcher, entry.outputRelname)
+}
+
+/**
+ * The ignore package rejects empty paths. The root page URL normalizes to an
+ * empty path, and should only be excluded by filtering its output filename.
+ *
+ * @param {ReturnType<typeof ignore>} ig
+ * @param {string} path
+ */
+function isIgnoredPath (ig, path) {
+  return path !== '' && ig.ignores(path)
+}
+
+// Filesystem helpers
+
+function readPackageVersion () {
+  const packageJson = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'))
+  const version = /** @type {{ version?: unknown }} */ (packageJson).version
+  if (typeof version !== 'string') throw new Error('Unable to resolve package version for domstack manifest schema')
+  return version
+}
+
+/**
+ * @param {string} filepath
+ */
+async function hashFileDigest (filepath) {
+  const contents = await readFile(filepath)
+  const digest = createHash('sha256').update(contents).digest()
+  return {
+    hex: digest.toString('hex'),
+    integrity: `sha256-${digest.toString('base64')}`,
+  }
+}
+
+/**
+ * @param {string} entryPoint
+ */
+function normalizeEntryPoint (entryPoint) {
+  return entryPoint.startsWith('file:')
+    ? new URL(entryPoint).pathname
+    : toPosix(entryPoint)
+}
+
+/**
+ * @param {string | null} revision
+ * @returns {string | undefined}
+ */
+function revisionToIntegrity (revision) {
+  if (!revision || !/^[a-f0-9]{64}$/i.test(revision)) return undefined
+  return `sha256-${Buffer.from(revision, 'hex').toString('base64')}`
+}
+
+/**
+ * @param {string} outputRelname
+ * @returns {string | undefined}
+ */
+function inferContentType (outputRelname) {
+  return contentType(outputRelname) || undefined
+}
+
+/**
+ * @param {object} params
+ * @param {DomstackManifestKind} params.kind
+ * @param {string} params.outputRelname
+ * @param {string} params.url
+ * @returns {boolean}
+ */
+function inferUrlRevisioned ({ kind, outputRelname, url }) {
+  if (kind === 'service-worker' || kind === 'metadata' || kind === 'sourcemap') return false
+
+  return HASHED_OUTPUT_RE.test(outputRelname) || HASHED_URL_RE.test(url)
+}
+
+/**
+ * @param {DomstackManifestKind} kind
+ * @returns {boolean}
+ */
+function inferStatic (kind) {
+  return !['metadata', 'service-worker', 'sourcemap'].includes(kind)
+}
+
+/**
+ * @param {{ kind: DomstackManifestKind, contentType?: string }} entry
+ * @returns {string}
+ */
+function inferRole (entry) {
+  if (entry.kind === 'page' || entry.kind === 'template') return 'navigation'
+  if (entry.kind === 'service-worker' || entry.kind === 'worker') return 'worker'
+  if (entry.kind === 'metadata' || entry.kind === 'sourcemap' || entry.kind === 'worker-manifest') return 'metadata'
+  if (entry.contentType?.startsWith('text/html')) return 'navigation'
+  return 'subresource'
+}
+
+const HASHED_OUTPUT_RE = /-[A-Z0-9]{8}(?:\.[^./]+)?\.[^./]+$/
+const HASHED_URL_RE = /-[A-Z0-9]{8}(?:\.[^/?#]+)?(?:[?#]|$)/
diff --git a/lib/domstack-manifest/schema.json b/lib/domstack-manifest/schema.json
new file mode 100644
index 00000000..009bf5e1
--- /dev/null
+++ b/lib/domstack-manifest/schema.json
@@ -0,0 +1,172 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://unpkg.com/@domstack/static@11.0.3/lib/domstack-manifest/schema.json",
+  "title": "Domstack manifest",
+  "description": "A normalized, revisioned manifest of public files emitted by a domstack build.",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "description": "Versioned URL of the JSON Schema that describes this manifest.",
+      "const": "https://unpkg.com/@domstack/static@11.0.3/lib/domstack-manifest/schema.json"
+    },
+    "version": {
+      "description": "SHA-256 hex digest derived from the final cache-relevant manifest entries.",
+      "type": "string"
+    },
+    "generatedAt": {
+      "description": "ISO 8601 timestamp for when domstack generated this manifest.",
+      "type": "string",
+      "format": "date-time"
+    },
+    "entries": {
+      "description": "Sorted public output entries included in the manifest after excludes and filters are applied.",
+      "type": "array",
+      "items": {
+        "description": "One public output emitted by domstack and included in the reconciled domstack manifest.",
+        "type": "object",
+        "properties": {
+          "outputRelname": {
+            "description": "Destination-relative output path using POSIX separators, such as \"index.html\" or \"chunks/js/chunk-ABC.js\".",
+            "type": "string"
+          },
+          "kind": {
+            "description": "Classifies the build pipeline step or artifact type that produced this output.",
+            "enum": [
+              "page",
+              "template",
+              "script",
+              "style",
+              "chunk",
+              "service-worker",
+              "worker",
+              "worker-manifest",
+              "static",
+              "copy",
+              "sourcemap",
+              "metadata"
+            ]
+          },
+          "url": {
+            "description": "Public same-origin URL for the output, normalized with a leading slash.",
+            "type": "string"
+          },
+          "revision": {
+            "description": "SHA-256 hex digest of the output file contents. Null is reserved for outputs without a content revision.",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "bytes": {
+            "description": "Output file size in bytes. Null is reserved for outputs whose size is unavailable.",
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
+          "sourceRelname": {
+            "description": "Source-relative path that produced this output when a direct source file is known.",
+            "type": "string"
+          },
+          "entryPoint": {
+            "description": "esbuild entry point path for script, style, worker, and service-worker outputs when available.",
+            "type": "string"
+          },
+          "pagePath": {
+            "description": "Source-relative page path associated with this output when the output belongs to a page.",
+            "type": "string"
+          },
+          "pageUrl": {
+            "description": "Canonical public page URL associated with this output when the output belongs to a page.",
+            "type": "string"
+          },
+          "templatePath": {
+            "description": "Source-relative template path associated with this output when the output was emitted by a template.",
+            "type": "string"
+          },
+          "contentType": {
+            "description": "Best-known MIME type for the emitted output. This is a build-time value and may differ from deployment HTTP headers.",
+            "type": "string"
+          },
+          "integrity": {
+            "description": "SRI-formatted SHA-256 digest derived from the same content hash as revision, such as \"sha256-AbCd...\".",
+            "type": "string"
+          },
+          "manifestVars": {
+            "description": "Explicitly selected page/app variables exposed for general manifest consumers.",
+            "type": "object",
+            "additionalProperties": {
+              "description": "Application-defined manifest variable value copied from the resolved page variable cascade. Domstack records this value but does not interpret it."
+            }
+          },
+          "urlRevisioned": {
+            "description": "Whether the public URL already contains a content hash or equivalent revision token.",
+            "type": "boolean"
+          },
+          "static": {
+            "description": "Whether this entry is part of domstack static browser-loadable output and can be considered by offline/cache/deploy tooling.",
+            "type": "boolean"
+          },
+          "role": {
+            "description": "Normalized runtime purpose for the entry, such as \"navigation\", \"subresource\", \"worker\", or \"metadata\".",
+            "type": "string"
+          },
+          "page": {
+            "description": "Page-specific metadata recorded for manifest entries whose kind is \"page\".",
+            "type": "object",
+            "properties": {
+              "path": {
+                "description": "Source-relative page path used by domstack routing, without a leading slash.",
+                "type": "string"
+              },
+              "url": {
+                "description": "Canonical public URL for the page, such as \"/\" or \"/docs/\".",
+                "type": "string"
+              },
+              "vars": {
+                "description": "Selected page variables that can affect offline or precache policy.",
+                "type": "object",
+                "properties": {
+                  "precache": {
+                    "description": "Application-defined page precache policy metadata. Domstack records this value but does not interpret it."
+                  },
+                  "offline": {
+                    "description": "Application-defined page offline availability metadata. Domstack records this value but does not interpret it."
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "required": [
+              "path",
+              "url"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "required": [
+          "outputRelname",
+          "kind",
+          "url",
+          "revision",
+          "bytes"
+        ],
+        "additionalProperties": false
+      }
+    },
+    "policy": {
+      "description": "Freeform application or integration policy for the whole manifest, exposed for service workers, deployment tools, or other consumers.",
+      "type": "object",
+      "additionalProperties": {
+        "description": "Application-defined manifest policy value. Domstack records this value once at the manifest root but does not interpret it."
+      }
+    }
+  },
+  "required": [
+    "$schema",
+    "version",
+    "generatedAt",
+    "entries"
+  ],
+  "additionalProperties": false
+}
diff --git a/lib/helpers/cpx2-report.js b/lib/helpers/cpx2-report.js
new file mode 100644
index 00000000..10e2a5b1
--- /dev/null
+++ b/lib/helpers/cpx2-report.js
@@ -0,0 +1,68 @@
+/**
+ * @import { DomstackManifestRecord } from '../domstack-manifest/index.js'
+ */
+
+import { relative, resolve } from 'node:path'
+import { createDomstackManifestRecord } from '../domstack-manifest/index.js'
+import { toPosix } from './path.js'
+
+/**
+ * Convert a cpx2 report into domstack manifest output records.
+ *
+ * @param {object} params
+ * @param {string} params.src - Source directory used to make copied source paths relative.
+ * @param {string} params.dest - Destination directory that received copied files.
+ * @param {unknown} params.report - Raw cpx2 report returned by `copy`.
+ * @param {'static'|'copy'} params.kind - Manifest kind to assign to copied outputs.
+ * @returns {DomstackManifestRecord[]}
+ */
+export function createCopiedDomstackManifestRecords ({ src, dest, report, kind }) {
+  const records = []
+
+  for (const copiedFile of extractCopiedFiles(report)) {
+    const filepath = resolve(copiedFile.output)
+    records.push(createDomstackManifestRecord({
+      dest,
+      filepath,
+      kind,
+      sourceRelname: copiedFile.source ? toPosix(relative(src, resolve(copiedFile.source))) : undefined,
+    }))
+  }
+
+  return records
+}
+
+/**
+ * @typedef {{ source?: string, output: string }} Cpx2CopiedFile
+ */
+
+/**
+ * @param {unknown} report
+ * @returns {Cpx2CopiedFile[]}
+ */
+function extractCopiedFiles (report) {
+  /** @type {Cpx2CopiedFile[]} */
+  const copied = []
+
+  const visit = (/** @type {unknown} */ value) => {
+    if (!value || typeof value !== 'object') return
+
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item)
+      return
+    }
+
+    const maybeCopied = /** @type {{ source?: unknown, output?: unknown }} */ (value)
+    if (typeof maybeCopied.output === 'string') {
+      /** @type {Cpx2CopiedFile} */
+      const copiedFile = { output: maybeCopied.output }
+      if (typeof maybeCopied.source === 'string') copiedFile.source = maybeCopied.source
+      copied.push(copiedFile)
+    }
+
+    for (const child of Object.values(value)) visit(child)
+  }
+
+  visit(report)
+  return copied
+}
diff --git a/lib/helpers/domstack-error.js b/lib/helpers/domstack-error.js
index bb8a6d3b..65765252 100644
--- a/lib/helpers/domstack-error.js
+++ b/lib/helpers/domstack-error.js
@@ -1,4 +1,4 @@
-/** @typedef { 'DOM_STACK_ERROR_DUPLICATE_PAGE' } DomStackErrorCode */
+/** @typedef { 'DOM_STACK_ERROR_DUPLICATE_PAGE' | 'DOM_STACK_ERROR_DUPLICATE_SERVICE_WORKER' } DomStackErrorCode */
 
 /**
  * Domstack Duplicate Page Error
@@ -31,6 +31,33 @@ export class DomStackDuplicatePageError extends Error {
   }
 }
 
+/**
+ * Domstack Duplicate Service Worker Error
+ * @extends {Error}
+ */
+export class DomStackDuplicateServiceWorkerError extends Error {
+  duplicates
+
+  /**
+   * Constructs a new DomStackDuplicateServiceWorkerError instance.
+   *
+   * @param {string} message - The error message
+   * @param {{ files: string[] }} duplicates - Extra params
+   * @param {ErrorOptions} [opts] - The opts object from the Error class
+   */
+  constructor (message, duplicates, opts) {
+    super(message, opts)
+    this.duplicates = duplicates
+  }
+
+  /**
+   * @returns {DomStackErrorCode}
+   */
+  get code () {
+    return 'DOM_STACK_ERROR_DUPLICATE_SERVICE_WORKER'
+  }
+}
+
 /** @typedef { 'DOM_STACK_WARNING_DUPLICATE_LAYOUT' } DomStackWarningCode */
 
 /**
diff --git a/lib/helpers/domstack-warning.js b/lib/helpers/domstack-warning.js
index b911549e..28ffb19a 100644
--- a/lib/helpers/domstack-warning.js
+++ b/lib/helpers/domstack-warning.js
@@ -10,6 +10,7 @@
  *  'DOM_STACK_WARNING_DUPLICATE_GLOBAL_CLIENT' |
  *  'DOM_STACK_WARNING_DUPLICATE_ESBUILD_SETTINGS' |
  *  'DOM_STACK_WARNING_DUPLICATE_MARKDOWN_IT_SETTINGS' |
+ *  'DOM_STACK_WARNING_DUPLICATE_DOMSTACK_MANIFEST_SETTINGS' |
  *  'DOM_STACK_WARNING_DUPLICATE_GLOBAL_VARS' |
  *  'DOM_STACK_WARNING_DUPLICATE_GLOBAL_DATA' |
  *  'DOM_STACK_WARNING_PAGE_MD_SHADOWS_README'
diff --git a/lib/helpers/generate-tree-data.js b/lib/helpers/generate-tree-data.js
index 12d4449b..f8f850f4 100644
--- a/lib/helpers/generate-tree-data.js
+++ b/lib/helpers/generate-tree-data.js
@@ -1,10 +1,21 @@
 /**
  * @import { Results } from '../builder.js'
+ * @import { DomstackManifestRecord } from '../domstack-manifest/index.js'
  */
 
-import { join, basename, sep, relative } from 'path'
+import { join, basename, posix, sep, relative } from 'path'
 import cleanDeep from 'clean-deep'
 
+/**
+ * @typedef {{
+ *  label: string,
+ *  nodes: TreeNode[],
+ *  leaf: {
+ *    [keyName: string]: string | undefined
+ *  }
+ * }} TreeNode
+ */
+
 /**
  * Generates a printable tree of what domstack did
  * @param  {string} cwd     cwd of the build
@@ -18,24 +29,17 @@ export function generateTreeData (cwd, src, dest, results) {
   const srcDir = basename(relative(cwd, src))
   const destDir = basename(relative(cwd, dest))
 
-  /**
-     * @typedef {{
-     *  label: string,
-     *  nodes: TreeNode[],
-     *  leaf: {
-     *    [keyName: string]: string | undefined
-     *  }
-     * }} TreeNode
-     */
   /** @type {TreeNode} */
   const treeStructure = {
     label: `${join(cwdDir, srcDir)} => ${join(cwdDir, destDir)}`,
     leaf: {
       globalStyle: results?.siteData?.globalStyle?.outputRelname,
       globalClient: results?.siteData?.globalClient?.outputRelname,
+      serviceWorker: results?.siteData?.serviceWorker?.outputRelname,
       globalVars: results?.siteData?.globalVars?.basename,
       esbuildSettings: results?.siteData?.esbuildSettings?.basename,
       markdownItSettings: results?.siteData?.markdownItSettings?.basename,
+      domstackManifestSettings: results?.siteData?.domstackManifestSettings?.basename,
       // rootLayout: results?.siteData?.layouts?.['root']?.basename
     },
     nodes: [],
@@ -77,32 +81,23 @@ export function generateTreeData (cwd, src, dest, results) {
     }
   }
 
-  if (results?.pageBuildResults?.report?.templates) {
-    for (const templateReport of results?.pageBuildResults?.report?.templates) {
-      const segments = templateReport.templateInfo.templateFile.relname.split(sep)
-      segments.pop()
-
-      let nodes = treeStructure.nodes
-      let targetNode = treeStructure
-
-      for (const segment of segments) {
-        const findResults = nodes.find(node => segment === node.label)
-        if (!findResults) {
-          targetNode = { label: segment, leaf: {}, nodes: [] }
-          nodes.push(targetNode)
-        } else {
-          targetNode = findResults
-        }
-        nodes = targetNode.nodes
-      }
-      if (templateReport.outputs.length > 0) {
-        templateReport.outputs.forEach((output, index) => {
-          targetNode.leaf[`${templateReport.templateInfo.templateFile.basename}${index > 0 ? `-${index}` : ''}`] = output
-        })
-      } else {
-        targetNode.leaf[templateReport.templateInfo.templateFile.basename] = 'NO TEMPLATE OUTPUT'
-      }
-    }
+  const templateOutputsBySource = groupOutputsBySource(
+    getReportOutputs(results?.pageBuildResults).filter(output => output.kind === 'template')
+  )
+  for (const [sourceRelname, outputs] of templateOutputsBySource) {
+    const targetNode = ensureOutputNode(treeStructure, sourceRelname)
+    const sourceBasename = posix.basename(sourceRelname)
+
+    outputs.forEach((output, index) => {
+      targetNode.leaf[`${sourceBasename}${index > 0 ? `-${index}` : ''}`] = templateOutputName(output)
+    })
+  }
+
+  const staticOutputs = getReportOutputs(results?.staticResults).filter(output => output.kind === 'static')
+  for (const output of staticOutputs) {
+    const sourceRelname = output.sourceRelname ?? output.outputRelname
+    const targetNode = ensureOutputNode(treeStructure, sourceRelname)
+    targetNode.leaf[posix.basename(sourceRelname)] = output.outputRelname
   }
 
   for (const [layoutName, layoutInfo] of Object.entries(results?.siteData?.layouts)) {
@@ -127,32 +122,73 @@ export function generateTreeData (cwd, src, dest, results) {
     if (layoutInfo.layoutStyle) targetNode.leaf[layoutInfo.layoutStyle.basename] = join(layoutInfo.parentName, layoutInfo.layoutStyle.outputName ?? layoutInfo.layoutStyle.basename)
     if (layoutInfo.layoutClient) targetNode.leaf[layoutInfo.layoutClient.basename] = join(layoutInfo.parentName, layoutInfo.layoutClient.outputName ?? layoutInfo.layoutClient.basename)
   }
+  // @ts-ignore
+  return cleanDeep(treeStructure)
+}
 
-  const staticReport = /** @type {{ copied?: Array<{ source: string, output: string }> }} */ (results?.staticResults?.report ?? {})
-  if (staticReport?.copied) {
-    for (const file of staticReport.copied) {
-      const srcFile = relative(srcDir, file.source)
-      const destFile = relative(destDir, file.output)
-      const segments = srcFile.split(sep)
-      segments.pop()
-
-      let nodes = treeStructure.nodes
-      let targetNode = treeStructure
-
-      for (const segment of segments) {
-        const findResults = nodes.find(node => segment === node.label)
-        if (!findResults) {
-          targetNode = { label: segment, leaf: {}, nodes: [] }
-          nodes.push(targetNode)
-        } else {
-          targetNode = findResults
-        }
-        nodes = targetNode.nodes
-      }
+/**
+ * @param {{ report?: { outputs?: DomstackManifestRecord[] } } | null | undefined} result
+ * @returns {DomstackManifestRecord[]}
+ */
+function getReportOutputs (result) {
+  return result?.report?.outputs ?? []
+}
 
-      targetNode.leaf[basename(srcFile)] = destFile
+/**
+ * @param {DomstackManifestRecord[]} outputs
+ * @returns {Map<string, DomstackManifestRecord[]>}
+ */
+function groupOutputsBySource (outputs) {
+  /** @type {Map<string, DomstackManifestRecord[]>} */
+  const outputMap = new Map()
+
+  for (const output of outputs) {
+    const key = output.sourceRelname ?? output.outputRelname
+    const existing = outputMap.get(key) ?? []
+    existing.push(output)
+    outputMap.set(key, existing)
+  }
+
+  return outputMap
+}
+
+/**
+ * @param {DomstackManifestRecord} output
+ */
+function templateOutputName (output) {
+  if (!output.templatePath) return output.outputRelname
+  const templatePrefix = `${output.templatePath}/`
+  return output.outputRelname.startsWith(templatePrefix)
+    ? output.outputRelname.slice(templatePrefix.length)
+    : output.outputRelname
+}
+
+/**
+ * @param {{
+ *   label: string,
+ *   nodes: TreeNode[],
+ *   leaf: { [keyName: string]: string | undefined }
+ * }} treeStructure
+ * @param {string} sourceRelname
+ * @returns {TreeNode}
+ */
+function ensureOutputNode (treeStructure, sourceRelname) {
+  const segments = sourceRelname.split('/')
+  segments.pop()
+
+  let nodes = treeStructure.nodes
+  let targetNode = treeStructure
+
+  for (const segment of segments) {
+    const findResults = nodes.find(node => segment === node.label)
+    if (!findResults) {
+      targetNode = { label: segment, leaf: {}, nodes: [] }
+      nodes.push(targetNode)
+    } else {
+      targetNode = findResults
     }
+    nodes = targetNode.nodes
   }
-  // @ts-ignore
-  return cleanDeep(treeStructure)
+
+  return targetNode
 }
diff --git a/lib/helpers/path.js b/lib/helpers/path.js
new file mode 100644
index 00000000..a042cdcd
--- /dev/null
+++ b/lib/helpers/path.js
@@ -0,0 +1,26 @@
+import { isAbsolute, relative, resolve, sep } from 'node:path'
+
+/**
+ * Convert a path-like string to POSIX separators for URLs and manifest relnames.
+ *
+ * @param {string} value
+ */
+export function toPosix (value) {
+  return value.split(sep).join('/')
+}
+
+/**
+ * Assert that a filepath resolves inside the build destination.
+ *
+ * @param {string} dest
+ * @param {string} filepath
+ * @param {string} [message]
+ */
+export function assertInsideDest (dest, filepath, message = `Output path escapes dest: ${filepath}`) {
+  const absDest = resolve(dest)
+  const absFilepath = resolve(filepath)
+  const rel = relative(absDest, absFilepath)
+  if (rel !== '' && (rel.startsWith('..') || isAbsolute(rel))) {
+    throw new Error(message)
+  }
+}
diff --git a/lib/helpers/stable-json-stringify.js b/lib/helpers/stable-json-stringify.js
new file mode 100644
index 00000000..259786a0
--- /dev/null
+++ b/lib/helpers/stable-json-stringify.js
@@ -0,0 +1,38 @@
+/**
+ * Stable JSON serialization for cache keys, hashes, and generated metadata.
+ *
+ * Applies JSON's normal serialization rules first, then sorts object keys so
+ * semantically equivalent objects produce the same string regardless of property
+ * insertion order.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+export function stableJsonStringify (value) {
+  const serializedValue = JSON.stringify(value)
+  return serializedValue === undefined
+    ? undefined
+    : stableJsonStringifyValue(JSON.parse(serializedValue))
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function stableJsonStringifyValue (value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value)
+
+  if (Array.isArray(value)) {
+    return `[${value.map(item => stableJsonStringifyValue(item) ?? 'null').join(',')}]`
+  }
+
+  const serializedProperties = []
+  for (const [key, item] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+    const serializedItem = stableJsonStringifyValue(item)
+    if (serializedItem !== undefined) {
+      serializedProperties.push(`${JSON.stringify(key)}:${serializedItem}`)
+    }
+  }
+
+  return `{${serializedProperties.join(',')}}`
+}
diff --git a/lib/helpers/type-guards.js b/lib/helpers/type-guards.js
new file mode 100644
index 00000000..d9f193b9
--- /dev/null
+++ b/lib/helpers/type-guards.js
@@ -0,0 +1,23 @@
+/**
+ * @param {unknown} value
+ * @returns {value is object}
+ */
+export function isObject (value) {
+  return value !== null && typeof value === 'object'
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+export function isPlainObject (value) {
+  return isObject(value) && !Array.isArray(value)
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is function}
+ */
+export function isFunction (value) {
+  return value !== null && typeof value === 'function'
+}
diff --git a/lib/identify-pages.js b/lib/identify-pages.js
index cec555ae..4677d125 100644
--- a/lib/identify-pages.js
+++ b/lib/identify-pages.js
@@ -6,7 +6,7 @@ import { asyncFolderWalker } from 'async-folder-walker'
 import assert from 'node:assert'
 import { resolve, relative, join, basename } from 'path'
 import { pageBuilders } from './build-pages/index.js'
-import { DomStackDuplicatePageError } from './helpers/domstack-error.js'
+import { DomStackDuplicatePageError, DomStackDuplicateServiceWorkerError } from './helpers/domstack-error.js'
 import { nodeHasTS } from './helpers/has-ts.js'
 import { computePageUrl } from './build-pages/compute-page-url.js'
 
@@ -74,6 +74,13 @@ export const globalClientNames = [
   'global.client.mjs', 'global.client.cjs'
 ]
 
+export const serviceWorkerNames = nodeHasTS
+  ? [
+      'service-worker.ts', 'service-worker.mts', 'service-worker.cts',
+      'service-worker.js', 'service-worker.mjs', 'service-worker.cjs'
+    ]
+  : ['service-worker.js', 'service-worker.mjs', 'service-worker.cjs']
+
 export const globalVarsNames = nodeHasTS
   ? [
       'global.vars.ts', 'global.vars.mts', 'global.vars.cts',
@@ -102,6 +109,13 @@ export const markdownItSettingsNames = nodeHasTS
     ]
   : ['markdown-it.settings.js', 'markdown-it.settings.mjs', 'markdown-it.settings.cjs']
 
+export const domstackManifestSettingsNames = nodeHasTS
+  ? [
+      'domstack-manifest.settings.ts', 'domstack-manifest.settings.mts', 'domstack-manifest.settings.cts',
+      'domstack-manifest.settings.js', 'domstack-manifest.settings.mjs', 'domstack-manifest.settings.cjs'
+    ]
+  : ['domstack-manifest.settings.js', 'domstack-manifest.settings.mjs', 'domstack-manifest.settings.cjs']
+
 /**
  * Shape the file walker object
  *
@@ -171,6 +185,10 @@ const shaper = ({
  * @property {string} outputName - The derived output name of the template file. Might be overridden.
  */
 
+/**
+ * @typedef {PageFileAsset} ServiceWorkerInfo
+ */
+
 /**
  * Identifies the pages, layouts, templates, and other relevant data from a given source directory.
  *
@@ -234,12 +252,36 @@ export async function identifyPages (src, opts = {}) {
   /** @type {PageFileAsset | undefined } */
   let markdownItSettings
 
+  /** @type {PageFileAsset | undefined } */
+  let domstackManifestSettings
+
   /** @type {DomStackWarning[]} */
   const warnings = []
 
   /** @type {Error[]} */
   const errors = []
 
+  /** @type {PageFileAsset[]} */
+  const serviceWorkerMatches = []
+  for (const files of Object.values(dirs)) {
+    for (const serviceWorkerName of serviceWorkerNames) {
+      const file = files[serviceWorkerName]
+      if (file) serviceWorkerMatches.push(file)
+    }
+  }
+
+  /** @type {PageFileAsset | undefined } */
+  const serviceWorker = serviceWorkerMatches[0]
+
+  if (serviceWorkerMatches.length > 1) {
+    errors.push(new DomStackDuplicateServiceWorkerError(
+      'Conflicting service worker sources: Only one site service-worker file is supported.',
+      {
+        files: serviceWorkerMatches.map(file => file.relname),
+      }
+    ))
+  }
+
   /** @type {string[]} */
   // const nonPageFolders = []
 
@@ -492,11 +534,20 @@ export async function identifyPages (src, opts = {}) {
           markdownItSettings = fileInfo
         }
       }
+
+      if (domstackManifestSettingsNames.some(name => basename(fileName) === name)) {
+        if (domstackManifestSettings) {
+          warnings.push({
+            code: 'DOM_STACK_WARNING_DUPLICATE_DOMSTACK_MANIFEST_SETTINGS',
+            message: `Skipping ${fileInfo.relname}. Duplicate domstack manifest settings ${fileName} to ${domstackManifestSettings.filepath}`,
+          })
+        } else {
+          domstackManifestSettings = fileInfo
+        }
+      }
     }
   }
 
-  // const rootFiles = dirs[''] ?? {}
-
   let defaultLayout = false
 
   if (!layouts['root']) {
@@ -534,10 +585,12 @@ export async function identifyPages (src, opts = {}) {
   const results = {
     globalStyle,
     globalClient,
+    serviceWorker,
     globalVars,
     globalData,
     esbuildSettings,
     markdownItSettings,
+    domstackManifestSettings,
     /** @type {string?} Path to a default style */
     defaultStyle: null,
     /** @type {string?} Path to a default client */
diff --git a/lib/identify-pages.test.js b/lib/identify-pages.test.js
index 3bfb45c7..f5bd94f8 100644
--- a/lib/identify-pages.test.js
+++ b/lib/identify-pages.test.js
@@ -1,8 +1,10 @@
 import { test } from 'node:test'
 import assert from 'node:assert'
-import { resolve } from 'path'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'path'
 
-import { identifyPages } from './identify-pages.js'
+import { identifyPages, domstackManifestSettingsNames, serviceWorkerNames } from './identify-pages.js'
 
 const __dirname = import.meta.dirname
 
@@ -12,6 +14,7 @@ test.describe('identify-pages', () => {
     // console.log(results)
     assert.ok(results.globalStyle, 'Global style is found')
     assert.ok(results.globalVars, 'Global variabls are found')
+    assert.ok(results.domstackManifestSettings, 'Domstack manifest settings are found')
     assert.ok(results.layouts, 'Layouts are found')
 
     assert.ok(results.layouts['root'], 'A root layouts is found')
@@ -26,5 +29,74 @@ test.describe('identify-pages', () => {
     assert.equal(results.pages.find(p => p.path === 'page-md-page')?.pageFile?.type, 'md', 'page-md-page is type md')
     assert.equal(results.pages.find(p => p.path === 'page-md-page')?.pageFile?.basename, 'page.md', 'page-md-page uses page.md')
     assert.equal(results.pages.find(p => p.path === 'page-md-precedence')?.pageFile?.basename, 'page.md', 'page.md takes precedence over README.md')
+    assert.equal(results.serviceWorker?.relname, 'globals/service-worker.mts', 'site service worker is found')
+    assert.equal(results.domstackManifestSettings?.relname, 'domstack-manifest.settings.js', 'domstack manifest settings are found')
+  })
+
+  test('identifies supported domstack manifest settings filenames', async (t) => {
+    assert.ok(domstackManifestSettingsNames.includes('domstack-manifest.settings.mjs'), 'mjs domstack manifest settings names are supported')
+    assert.ok(domstackManifestSettingsNames.includes('domstack-manifest.settings.cjs'), 'cjs domstack manifest settings names are supported')
+    assert.ok(domstackManifestSettingsNames.includes('domstack-manifest.settings.mts'), 'mts domstack manifest settings names are supported')
+    assert.ok(domstackManifestSettingsNames.includes('domstack-manifest.settings.cts'), 'cts domstack manifest settings names are supported')
+
+    const tmp = await mkdtemp(join(tmpdir(), 'domstack-manifest-settings-'))
+    t.after(async () => {
+      await rm(tmp, { recursive: true, force: true })
+    })
+
+    for (const domstackManifestSettingsName of domstackManifestSettingsNames) {
+      const src = join(tmp, domstackManifestSettingsName)
+      const assets = join(src, 'global-assets')
+      await rm(src, { recursive: true, force: true })
+      await mkdir(assets, { recursive: true })
+      await writeFile(join(assets, domstackManifestSettingsName), 'export default {}\n')
+
+      const results = await identifyPages(src)
+
+      assert.equal(results.domstackManifestSettings?.basename, domstackManifestSettingsName, `${domstackManifestSettingsName} is detected`)
+      assert.equal(results.domstackManifestSettings?.relname, `global-assets/${domstackManifestSettingsName}`, `${domstackManifestSettingsName} can live below src`)
+    }
+  })
+
+  test('identifies supported site service worker entry filenames', async (t) => {
+    assert.ok(serviceWorkerNames.includes('service-worker.mjs'), 'mjs service worker names are supported')
+    assert.ok(serviceWorkerNames.includes('service-worker.cjs'), 'cjs service worker names are supported')
+    assert.ok(serviceWorkerNames.includes('service-worker.mts'), 'mts service worker names are supported')
+    assert.ok(serviceWorkerNames.includes('service-worker.cts'), 'cts service worker names are supported')
+
+    const tmp = await mkdtemp(join(tmpdir(), 'domstack-service-worker-'))
+    t.after(async () => {
+      await rm(tmp, { recursive: true, force: true })
+    })
+
+    for (const serviceWorkerName of serviceWorkerNames) {
+      const src = join(tmp, serviceWorkerName)
+      const assets = join(src, 'global-assets')
+      await rm(src, { recursive: true, force: true })
+      await mkdir(assets, { recursive: true })
+      await writeFile(join(assets, serviceWorkerName), 'self.addEventListener("install", () => {})\n')
+
+      const results = await identifyPages(src)
+
+      assert.equal(results.serviceWorker?.basename, serviceWorkerName, `${serviceWorkerName} is detected`)
+      assert.equal(results.serviceWorker?.relname, `global-assets/${serviceWorkerName}`, `${serviceWorkerName} can live below src`)
+      assert.equal(results.errors.length, 0, `${serviceWorkerName} does not produce errors`)
+    }
+  })
+
+  test('errors on duplicate site service worker entries', async (t) => {
+    const src = await mkdtemp(join(tmpdir(), 'domstack-service-worker-dupe-'))
+    t.after(async () => {
+      await rm(src, { recursive: true, force: true })
+    })
+
+    await mkdir(join(src, 'global-assets'), { recursive: true })
+    await writeFile(join(src, 'global-assets/service-worker.mjs'), 'self.addEventListener("install", () => {})\n')
+    await writeFile(join(src, 'service-worker.cjs'), 'self.addEventListener("install", () => {})\n')
+
+    const results = await identifyPages(src)
+    const error = results.errors.find(error => 'code' in error && error.code === 'DOM_STACK_ERROR_DUPLICATE_SERVICE_WORKER')
+
+    assert.ok(error, 'duplicate site service worker sources produce a clear error')
   })
 })
diff --git a/package.json b/package.json
index 14bc9cea..1dc61b1f 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,30 @@
     "domstack": "./bin.js",
     "dom": "./bin.js"
   },
+  "files": [
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "bin.js",
+    "bin.d.ts",
+    "bin.d.ts.map",
+    "docs/**/*.md",
+    "global.css",
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map",
+    "lib/**/*.css",
+    "lib/**/*.d.ts",
+    "lib/**/*.d.ts.map",
+    "lib/**/*.js",
+    "lib/**/*.json",
+    "!lib/**/*.test.js",
+    "!lib/**/fixtures/**",
+    "page.vars.js",
+    "scripts/domstack-manifest-schema.js",
+    "style.css",
+    "types.d.ts",
+    "types.d.ts.map"
+  ],
   "author": "Bret Comnes <bcomnes@gmail.com> (https://bret.io)",
   "bugs": {
     "url": "https://github.com/bcomnes/domstack/issues"
@@ -30,16 +54,17 @@
     "chokidar": "^5.0.0",
     "clean-deep": "^3.4.0",
     "cpx2": "^9.0.0",
-    "esbuild": "^0.28.0",
+    "esbuild": "^0.28.1",
     "fragtml": "^0.0.9",
     "handlebars": "^4.7.8",
     "highlight.js": "^11.9.0",
     "ignore": "^7.0.0",
     "js-yaml": "^5.1.0",
+    "json-schema-to-ts": "^3.1.1",
     "make-array": "^1.0.5",
-    "markdown-it": "^14.1.0",
+    "markdown-it": "^14.3.0",
     "markdown-it-abbr": "^2.0.0",
-    "markdown-it-anchor": "^9.0.1",
+    "markdown-it-anchor": "^9.2.1",
     "markdown-it-attrs": "^5.0.0",
     "markdown-it-deflist": "^3.0.0",
     "markdown-it-emoji": "^3.0.0",
@@ -51,8 +76,9 @@
     "markdown-it-sup": "^2.0.0",
     "markdown-it-table-of-contents": "^1.1.0",
     "markdown-it-task-lists": "^2.1.1",
-    "mine.css": "^10.0.0",
-    "p-map": "^7.0.2",
+    "mime-types": "^3.0.2",
+    "mine.css": "^10.0.3",
+    "p-map": "^7.0.5",
     "package-directory": "^8.1.0",
     "package-json": "^10.0.0",
     "pino": "^10.3.1",
@@ -65,15 +91,16 @@
   "devDependencies": {
     "@types/markdown-it": "^14.1.1",
     "@types/markdown-it-footnote": "^3.0.4",
+    "@types/mime-types": "^3.0.1",
     "@types/node": "^26.0.1",
     "@types/pretty": "^2.0.3",
-    "@voxpelli/tsconfig": "^16.0.0",
+    "@voxpelli/tsconfig": "^16.2.1",
     "cheerio": "^1.0.0-rc.10",
     "installed-check": "^10.0.1",
     "jsonfeed-to-atom": "^1.2.5",
     "neostandard": "^0.13.0",
-    "npm-run-all2": "^9.0.0",
-    "preact": "^10.29.2",
+    "npm-run-all2": "^9.0.2",
+    "preact": "^10.29.6",
     "releasearoni": "^0.2.0",
     "typescript": "~6.0.3"
   },
@@ -102,13 +129,16 @@
     "build": "npm run clean && run-p build:*",
     "build:domstack": "./bin.js --src . --ignore examples,test-cases,coverage,*.tsconfig.json,fonts",
     "build:declaration": "tsc -p declaration.tsconfig.json",
+    "build:schema": "node scripts/domstack-manifest-schema.js",
     "watch": "npm run clean && run-p watch:*",
     "watch:domstack": "npm run build:domstack -- --watch",
-    "example:basic": "cd examples/basic && npm i && npm run build",
-    "example:string-layouts": "cd examples/string-layouts && npm i --production && npm run build",
-    "example:default-layout": "cd examples/default-layout && npm i --production && npm run build",
-    "example:nested-dest": "cd examples/nested-dest && npm i --production && npm run build",
-    "example:uhtml-isomorphic": "cd examples/uhtml-isomorphic && npm i --production && npm run build",
+    "example:basic": "npm --workspace @domstack/basic-example run build",
+    "example:string-layouts": "npm --workspace @domstack/string-layouts-example run build",
+    "example:default-layout": "npm --workspace @domstack/default-layout-example run build",
+    "example:nested-dest": "npm --workspace @domstack/nested-dest-example run build",
+    "example:static-mpa-offline": "npm --workspace @domstack/static-mpa-offline-example run build",
+    "example:static-mpa-workbox-offline": "npm --workspace @domstack/static-mpa-workbox-offline-example run build",
+    "example:uhtml-isomorphic": "npm --workspace @domstack/uhtml-isomorphic-example run build",
     "start": "npm run watch"
   },
   "funding": {
@@ -117,5 +147,8 @@
   },
   "allowScripts": {
     "esbuild@0.28.1": true
-  }
+  },
+  "workspaces": [
+    "examples/*"
+  ]
 }
diff --git a/plans/domstack-manifest.md b/plans/domstack-manifest.md
new file mode 100644
index 00000000..b59c2882
--- /dev/null
+++ b/plans/domstack-manifest.md
@@ -0,0 +1,205 @@
+# Build Output Manifest
+
+## Status: Implemented unstable preview
+
+Domstack has an implemented build-output manifest preview.
+
+The manifest pipeline is build-time first.
+
+It exists primarily for `domstack-manifest.settings.*`, `hooks.manifestBuilt`, deployment metadata, auditing, and optional public `domstack-manifest.json` output.
+
+Service-worker integrations now prefer injected constants from `manifestBuilt` hooks instead of runtime-fetching a generated manifest or policy file.
+
+The API is still documented as preview-quality because service-worker and PWA use cases are actively shaping the final ergonomics.
+
+## Current implementation
+
+The implemented pipeline is:
+
+```txt
+builder()
+  identifyPages()
+  ensureDest()
+  Promise.all(
+    buildEsbuild()  -> output records for app bundles, excluding final /service-worker.js
+    buildStatic()   -> output records
+    buildCopy()     -> output records
+  )
+  buildPages()      -> output records for pages/templates
+  buildDomstackManifest(records) when a manifest consumer exists
+  run manifestBuilt hooks
+  build /service-worker.js with finalized manifest version and hook-defined constants
+  optionally write domstack-manifest.json
+```
+
+A manifest consumer exists when either:
+
+- a `domstack-manifest.settings.*` file is present
+- explicit programmatic `domstackManifest` configuration is provided
+- `--domstackManifest` is passed to the CLI
+
+`domstack-manifest.json` is not written by default.
+
+The CLI writes it only when `--domstackManifest` is passed.
+
+Programmatic builds return `results.domstackManifest` when a manifest consumer exists.
+
+## Service worker relationship
+
+Production service workers are built after the manifest is finalized.
+
+They are intentionally omitted from the manifest version hash.
+
+This avoids a circular dependency where `/service-worker.js` would depend on `manifest.version` while also changing `manifest.version`.
+
+Instead, service workers receive:
+
+- `process.env.DOMSTACK_MANIFEST_VERSION`
+- hook-defined constants from `context.defineServiceWorkerConstant()`
+
+When manifest-driven service-worker policy changes, the final `/service-worker.js` bytes change, and the browser's normal service-worker update lifecycle runs.
+
+Watch mode does not build a manifest.
+
+Watch mode builds a self-contained no-policy `/service-worker.js` that can unregister itself and clear owned caches.
+
+Watch mode also disables esbuild splitting so `/service-worker.js` remains parseable during production-to-watch cleanup, even for older classic-worker registrations.
+
+## Manifest built hook API
+
+Status: implemented.
+
+`domstack-manifest.settings.*` and programmatic `domstackManifest.hooks` can register `manifestBuilt` hooks.
+
+Hooks receive the finalized manifest after entry reconciliation, filtering, manifest variables, root policy, and `manifest.version` are resolved.
+
+```ts
+type DomstackManifestBuiltHookContext<Policy, ManifestVars> = {
+  dest: string
+  manifest: DomstackManifest<Policy, ManifestVars>
+  defineServiceWorkerConstant: (identifier: string, value: unknown) => void
+  writeFile: (outputRelname: string, contents: string | Uint8Array) => Promise<void>
+}
+```
+
+`defineServiceWorkerConstant()` serializes `value` with `JSON.stringify()` and passes it to esbuild's `define` option for the final service-worker build.
+
+Use it for service-worker policy, Workbox precache data, or any other build-time data that should not require a runtime fetch.
+
+`writeFile()` writes custom generated artifacts into `dest`.
+
+Use it for deployment metadata or public files that intentionally need their own URL.
+
+## Current manifest shape
+
+Relevant public entry fields include:
+
+```ts
+type DomstackManifestEntry<ManifestVars = Record<string, unknown>> = {
+  outputRelname: string
+  kind: DomstackManifestKind
+  url: string
+  revision: string | null
+  bytes: number | null
+  sourceRelname?: string
+  entryPoint?: string
+  pagePath?: string
+  pageUrl?: string
+  templatePath?: string
+  contentType?: string
+  integrity?: string
+  manifestVars?: ManifestVars
+  urlRevisioned?: boolean
+  static?: boolean
+  role?: string
+  page?: {
+    path: string
+    url: string
+    vars?: {
+      precache?: unknown
+      offline?: unknown
+    }
+  }
+}
+```
+
+Relevant root fields include:
+
+```ts
+type DomstackManifest<Policy, ManifestVars> = {
+  $schema: typeof DOMSTACK_MANIFEST_SCHEMA_ID
+  version: string
+  generatedAt: string
+  entries: DomstackManifestEntry<ManifestVars>[]
+  policy?: Policy
+}
+```
+
+`version` is a SHA-256 hex digest derived from stable cache-relevant manifest data.
+
+It excludes `generatedAt` and excludes the final `/service-worker.js` output.
+
+## Manifest variables and policy
+
+`manifestVars` are selected from the resolved page variable cascade.
+
+The current cascade is:
+
+```txt
+page vars -> layout vars -> global vars -> defaults
+```
+
+Layouts can export `vars` with the same async/sync contract as page/global vars.
+
+`manifestVars` can be configured as an array of variable names or a transform function.
+
+Root `policy` is a single freeform object for the whole manifest.
+
+Per-entry policy is represented through selected `manifestVars`, not a separate per-entry policy object.
+
+## Examples validating the preview
+
+`examples/static-mpa-offline` demonstrates a domstack-native service worker.
+
+It injects manifest-shaped service-worker policy directly into `/service-worker.js` with `defineServiceWorkerConstant()`.
+
+The service worker consumes Domstack manifest entries directly and derives cache behavior from:
+
+- `entry.manifestVars`
+- `entry.role`
+- `entry.kind`
+- `entry.revision`
+- `entry.urlRevisioned`
+- `entry.bytes`
+- `entry.static`
+
+`examples/static-mpa-workbox-offline` demonstrates a Workbox service worker.
+
+It injects a Workbox-oriented policy constant into `/service-worker.js`.
+
+The service worker passes `policy.precacheManifest` to Workbox and maps app-specific runtime/network-only/fallback policy to Workbox routing and strategies.
+
+## Public schema artifact
+
+`lib/domstack-manifest/schema.json` is currently kept as a public validation/documentation artifact.
+
+Runtime/build behavior does not require loading this file.
+
+It is useful for users who opt into writing `domstack-manifest.json` and want editor or deployment validation.
+
+If the written manifest is de-emphasized further, this schema file could become optional or be replaced by docs-only schema publication.
+
+## Current non-goals
+
+- Do not auto-register service workers.
+- Do not require Workbox.
+- Do not require writing `domstack-manifest.json` for service-worker use.
+- Do not encode app-specific API/data caching semantics in core manifest fields.
+- Do not include final `/service-worker.js` in the manifest hash.
+
+## Potential follow-ups
+
+- Decide whether the external schema JSON remains a packaged artifact long term.
+- Consider helper utilities for common service-worker policy derivations without making them mandatory.
+- Consider a small registration helper that uses Domstack's service-worker URL/scope defines but leaves UI policy to the app.
+- Continue validating downstream PWA use cases before stabilizing the preview API.
diff --git a/plans/global-data.md b/plans/global-data.md
deleted file mode 100644
index be2478dc..00000000
--- a/plans/global-data.md
+++ /dev/null
@@ -1,189 +0,0 @@
-# Global Data Pipeline
-
-## Status: Implemented ✅
-
-All core features implemented. Watch mode integration (decision tree entry for `global.data.*`)
-is deferred to the progressive-rebuild work.
-
----
-
-## Problem with postVars
-
-`postVars` is a named export from a `page.vars.*` file that receives the full `pages` array
-at render time. It was designed to let pages aggregate data from other pages (blog indexes,
-RSS feeds, etc.) but has several problems:
-
-- **Implicit**: any page.vars file might export postVars — there's no way to know without
-  importing the file. The main process discovers which pages use postVars only *after* a
-  full build completes, by reading the `postVarsPagePaths` array returned by the worker.
-- **Coupled to page rendering**: data aggregation is entangled with page output, making
-  both harder to reason about.
-- **Mis-scoped**: a blog index page shouldn't need a special callback just to list its
-  sibling pages — that's a data pipeline concern, not a page concern.
-- **Watch mode contagion is blunt**: because postVars pages aggregate other pages' data,
-  whenever any page file or vars file changes the main process must re-render the changed
-  page *plus* every page that was detected as a postVars consumer last time.
-
-## Replacement: `global.data.js`
-
-A single optional file anywhere in the `src` tree: `global.data.js` (or `.ts`). Like all global assets, the first one found wins and duplicates produce a warning.
-
-It runs once per build, inside the worker, after all pages are initialized but before
-rendering begins. It receives the fully resolved `PageData[]` array and returns an object
-that is stamped onto every page's vars — available to every page, layout, and template.
-
-### API
-
-```ts
-// global.data.ts
-import type { AsyncGlobalDataFunction } from 'domstack'
-
-export default (async ({ pages }) => {
-  const blogPosts = pages
-    .filter(p => p.vars?.layout === 'blog' && p.vars?.publishDate)
-    .sort((a, b) => new Date(b.vars.publishDate) - new Date(a.vars.publishDate))
-
-  return {
-    blogPosts,
-    recentPosts: blogPosts.slice(0, 5),
-  }
-}) satisfies AsyncGlobalDataFunction
-```
-
-The returned object is stamped onto every page's `globalDataVars` field, which the `vars`
-getter merges in after `globalVars` but before `pageVars`:
-
-```
-vars = { ...globalVars, ...globalDataVars, ...pageVars, ...builderVars }
-```
-
-### Why resolved PageData, not raw PageInfo
-
-`global.data.js` runs after `pageData.init()` for all pages. This means it receives
-fully resolved `PageData[]` — every page has `.vars` (merged global + page + builder
-vars), `.pageInfo`, `.styles`, `.scripts`, etc. This is strictly richer than raw
-`PageInfo[]`, and avoids needing a separate `parseFrontmatter()` step in `identifyPages`.
-
-The tradeoff is an explicit coordination barrier: all pages must finish `init()` before
-`global.data.js` can run, and all pages must have `globalDataVars` stamped before
-rendering begins. This is inherent to the design — there's no way to pipeline init→render
-per-page while also running `global.data.js` in between without making `vars` async.
-
-### Migration: postVars → global.data.js
-
-**Before** (`blog/page.vars.js`):
-```js
-export default {
-  layout: 'blog',
-  title: 'Blog',
-}
-
-export async function postVars ({ pages }) {
-  const posts = pages
-    .filter(p => p.pageInfo.pageFile.relname.startsWith('blog/'))
-    .sort((a, b) => new Date(b.vars.date) - new Date(a.vars.date))
-
-  return { posts }
-}
-```
-
-**After** — remove postVars from `blog/page.vars.js`:
-```js
-export default {
-  layout: 'blog',
-  title: 'Blog',
-}
-```
-
-Add `global.data.js` anywhere in the src tree:
-```js
-export default async function ({ pages }) {
-  const blogPosts = pages
-    .filter(p => p.vars?.layout === 'blog')
-    .sort((a, b) => new Date(b.vars.date) - new Date(a.vars.date))
-
-  return { blogPosts }
-}
-```
-
-The blog index page's layout or page function reads `vars.blogPosts` directly.
-
-## Build Pipeline Integration
-
-`global.data.js` runs **inside the worker**, between page initialization and page rendering.
-It must not run in the main process because it uses `import()` which is subject to ESM
-caching — the same reason all layout, vars, and page imports happen in the worker.
-
-```
-Worker process:
-  resolveVars(globalVars)           → bareGlobalVars
-  globalVars = { ...defaultVars, ...bareGlobalVars }
-  pMap(pages, pageData.init)        → all pages initialized (vars resolved, layout bound)
-  resolveGlobalData({ pages })      → globalDataVars        ← runs after init
-  stamp globalDataVars onto pages   → page.globalDataVars = globalDataVars
-  pMap(pages, pageWriter)           → pages rendered with stamped globalDataVars in vars
-```
-
-The step is **lazy**: if `siteData.globalData` is undefined (no file found), `resolveGlobalData`
-returns `{}` immediately with no overhead.
-
-## Incremental Rebuild in Watch Mode
-
-`global.data.js` changes should trigger a full page rebuild, same as `global.vars.*`. Since
-`global.data` output is stamped onto every page's vars, there is no safe way to know which
-pages are affected without re-rendering all of them.
-
-### Watch mode decision tree additions (deferred to progressive-rebuild)
-
-| File pattern | Action |
-|---|---|
-| `global.vars.*` | Full page rebuild (all pages) |
-| `global.data.*` | Full page rebuild (all pages) |  ← to be wired up in progressive-rebuild
-| `esbuild.settings.*` | Restart esbuild context + full page rebuild |
-
-Currently, `global.data.*` changes are not watched specially — any watched file change
-triggers a full `builder()` call which re-runs `identifyPages()` and the full build, so the
-behavior is correct but not yet optimally wired.
-
-## Identifying `global.data.*` in identifyPages ✅
-
-Similar to `global.vars.*`, looks for (respecting whether Node has TS support):
-
-```
-global.data.ts / global.data.mts / global.data.cts
-global.data.js / global.data.mjs / global.data.cjs
-```
-
-Stored in `siteData.globalData` (a `FileInfo` object) alongside `siteData.globalVars`.
-Duplicate detection follows the same warning pattern as globalVars
-(`DOM_STACK_WARNING_DUPLICATE_GLOBAL_DATA`).
-
-## Removal of postVars ✅
-
-`postVars` has been fully removed:
-
-- `resolvePostVars()` in `resolve-vars.js` throws a hard error with a migration message if
-  any `page.vars.*` file exports `postVars`
-- `PageData.postVars`, `PageData.#renderedPostVars`, and `PageData.#renderPostVars()` removed
-- `PostVarsFunction` / `AsyncPostVarsFunction` typedefs removed from `page-data.js` and
-  `index.js`
-- `renderInnerPage` and `renderFullPage` now use `this.vars` directly (no postVars merge)
-
-## `GlobalDataFunction` type ✅
-
-- Defined as a `@callback` typedef in `lib/build-pages/index.js`
-- Re-exported from `index.js` as `GlobalDataFunction` / `AsyncGlobalDataFunction`
-- Used in the test case: `test-cases/general-features/src/global.data.js`
-
-## Files Changed
-
-| File | Change |
-|---|---|
-| `lib/identify-pages.js` | Added `globalDataNames`, `globalData` detection, `DOM_STACK_WARNING_DUPLICATE_GLOBAL_DATA` |
-| `lib/helpers/domstack-warning.js` | Added `DOM_STACK_WARNING_DUPLICATE_GLOBAL_DATA` to `DomStackWarningCode` union |
-| `lib/build-pages/resolve-vars.js` | Added `resolveGlobalData()`; replaced `checkForPostVars` with `resolvePostVars` (throws on detection) |
-| `lib/build-pages/page-data.js` | Added `globalDataVars` field; updated `vars` getter to merge it; calls `resolvePostVars` in `init()` |
-| `lib/build-pages/index.js` | Added `GlobalDataFunction`/`AsyncGlobalDataFunction` typedefs; post-init `resolveGlobalData` call + stamp loop |
-| `index.js` | Replaced `PostVarsFunction`/`AsyncPostVarsFunction` re-exports with `GlobalDataFunction`/`AsyncGlobalDataFunction` |
-| `test-cases/general-features/src/global.data.js` | New — blog index using resolved `PageData[]` API |
-| `test-cases/general-features/index.test.js` | Added assertion for `ul.blog-index-list` / `li.blog-entry` in root index.html |
diff --git a/plans/progressive-rebuild.md b/plans/progressive-rebuild.md
deleted file mode 100644
index 0fbb39dc..00000000
--- a/plans/progressive-rebuild.md
+++ /dev/null
@@ -1,323 +0,0 @@
-# Progressive Rebuild in Watch Mode
-
-## Status: Implemented ✅
-
-All features implemented. Tests pass, linter clean.
-
----
-
-## Goal
-
-Instead of a full rebuild on every file change, rebuild only the pages affected by the changed file.
-
-## Non-Watch Architecture
-
-```
-builder()
-  identifyPages()         → siteData
-  buildEsbuild()          → bundles all JS/CSS, mutates siteData with hashed output paths
-  buildPages() [worker]   → renders all pages and templates
-```
-
-## Watch Architecture
-
-Two separate, parallel watch loops:
-
-### Loop 1: esbuild context (JS/CSS)
-
-- `buildEsbuildWatch()` in `lib/build-esbuild/index.js` creates an `esbuild.context()` + calls `.watch()`
-- Stable (unhashed) output filenames in watch mode:
-  - `entryNames: '[dir]/[name]'` instead of `'[dir]/[name]-[hash]'`
-  - `chunkNames: 'chunks/[ext]/[name]'`
-  - `outputMap` only needs to be computed once at startup — stable across rebuilds
-- A `domstack-on-end` esbuild plugin logs errors after each bundle rebuild
-- Since watch mode uses stable filenames, page HTML never changes when bundles rebuild — no
-  page rebuild triggered. `@domstack/sync` reloads the browser directly.
-- esbuild's `context()` API does NOT support modifying entry points after creation. Adding or
-  removing an esbuild entry point requires `dispose()` + recreating the context.
-
-### Loop 2: chokidar (page files)
-
-Chokidar watches for `.js`, `.mjs`, `.cjs`, `.ts`, `.mts`, `.cts`, `.css`, `.html`, `.md`
-changes (extension whitelist). Uses `atomic: 300` to handle editors that do atomic saves
-(temp file + rename), preventing spurious `unlink` + `add` pairs.
-
-On `change`, the decision tree in `#handleChange()` determines the minimal page rebuild set.
-On `add`/`unlink`, `#handleAddUnlink()` categorizes the file for targeted rebuild scope.
-
-All chokidar events are serialized through a `#buildLock` promise chain so rapid saves don't
-cause overlapping rebuilds.
-
-## Data Structures Built at Startup
-
-After the initial full build, `#rebuildMaps()` builds and maintains these in `DomStack`
-private fields:
-
-### 1. `#layoutDepMap: Map<depFilepath, Set<layoutName>>`
-
-Built using `@11ty/dependency-tree-typescript`.
-Values are layout *names* (not filepaths) so they can be fed directly into `#layoutPageMap`.
-
-Answers: "which layout names import this changed file?"
-
-### 2. `#layoutPageMap: Map<layoutName, Set<PageInfo>>`
-
-Built by re-resolving each page's `layout` var from its vars files. Lightweight —
-just reads `page.vars.*` exports without running a full page render. Falls back to
-the default layout name resolved from `default.vars.js` → `global.vars.*` → `'root'`.
-
-Answers: "which pages use this layout?"
-
-### 3. `#pageFileMap: Map<filepath, PageInfo>`
-
-Simple lookup from any page-related file to its PageInfo. Covers both `pageFile` and `pageVars`.
-
-Answers: "is this changed file a page or page vars file, and which page?"
-
-### 4. `#layoutFileMap: Map<filepath, layoutName>`
-
-Direct lookup from a layout's filepath to its name.
-
-Answers: "is this changed file a layout, and what is its name?"
-
-### 5. `#pageDepMap: Map<depFilepath, Set<PageInfo>>`
-
-Built using `@11ty/dependency-tree-typescript` on each `page.js` **and** `page.vars.*` file.
-Tracks transitive ESM deps so changes to shared modules trigger the correct page rebuilds.
-
-Answers: "which pages import this changed shared module (via page.js or page.vars)?"
-
-### 6. `#templateDepMap: Map<depFilepath, Set<TemplateInfo>>`
-
-Built using `@11ty/dependency-tree-typescript` on each template file.
-
-Answers: "which templates import this changed shared module?"
-
-### 7. `#esbuildEntryPoints: Set<filepath>`
-
-Built from actual `siteData` properties — the concrete set of absolute filepaths that are
-esbuild entry points (globalClient, globalStyle, per-page clientBundle/pageStyle/workers,
-per-layout layoutClient/layoutStyle).
-
-Checked **early** in the change decision tree (Rule 6, before dep map lookups) to prevent
-esbuild-owned files from accidentally matching dep map rules and triggering unnecessary
-page rebuilds.
-
-### Notes on path handling
-
-`@11ty/dependency-tree-typescript`'s `find()` returns CWD-relative paths with a `./` prefix
-(e.g. `./lib/build-pages/resolve-vars.js`). `siteData` filepaths are absolute. All dep paths
-are `resolve()`d to absolute before being stored as map keys.
-
-## Rebuild Decision Tree (change events)
-
-On a chokidar `change` event for `changedPath`, `#handleChange()` evaluates rules top-down
-with early returns:
-
-```
-2. global.vars.*
-   → Full rebuild (dispose esbuild context, re-run identifyPages, restart esbuild,
-     rebuild all pages, rebuild maps)
-   → Rationale: the `browser` key is read by buildEsbuild() in the main process and
-     passed to esbuild as `define` substitutions. esbuild's own watcher does NOT track
-     global.vars as an input, so any change could affect bundle output and requires
-     restarting esbuild with fresh `define` values.
-
-3. global.data.*
-   → Full page rebuild (all pages, all templates). No esbuild restart.
-   → Rationale: global.data.js output is stamped onto every page's vars. There is no
-     safe way to know which pages are affected without re-rendering all of them.
-
-4. esbuild.settings.*
-   → Full rebuild (dispose esbuild context, re-create, rebuild all pages)
-
-5. markdown-it.settings.*
-   → Rebuild all .md pages only (pageFilterPaths = md pages, templateFilterPaths = [])
-
-6. esbuild entry point (#esbuildEntryPoints.has(changedPath))
-   → Log "esbuild will handle rebundling" and return. No page rebuild needed.
-   → Uses concrete filepath Set from siteData, checked BEFORE dep map rules.
-
-7. Layout file (matches layoutSuffixs + registered in #layoutFileMap)
-   → affectedPages = layoutPageMap.get(layoutName)
-   → Rebuild affectedPages only
-
-8. Dep of a layout (layoutDepMap.has(changedPath))
-   → affectedLayouts = layoutDepMap.get(changedPath)  // Set<layoutName>
-   → affectedPages = union of layoutPageMap.get(name) for each layout
-   → Rebuild affectedPages only
-
-9. Page file or page.vars file (pageFileMap.has(changedPath))
-   → affectedPage = pageFileMap.get(changedPath)
-   → Rebuild [affectedPage] only
-
-10. Template file (matches templateSuffixs + registered in siteData.templates)
-    → Rebuild just that template
-
-11. Dep of a page.js or page.vars (pageDepMap.has(changedPath))
-    → affectedPages = pageDepMap.get(changedPath)
-    → Rebuild affectedPages only
-
-12. Dep of a template file (templateDepMap.has(changedPath))
-    → affectedTemplates = templateDepMap.get(changedPath)
-    → Rebuild affectedTemplates only
-
-13. Otherwise
-    → Log "did not match any rebuild rule, skipping"
-```
-
-## Add/Unlink Handling
-
-On a chokidar `add` or `unlink` event, `#handleAddUnlink(changedPath, event)` categorizes
-the file by basename pattern to determine the minimal rebuild scope:
-
-### esbuild entry point added/removed
-
-Detected by basename pattern matching against known name lists (pageClientNames,
-layoutClientSuffixs, layoutStyleSuffix, pageWorkerSuffixs, globalClientNames,
-globalStyleNames, pageStyleName).
-
-Steps:
-1. Re-identify pages (`identifyPages()`) to discover the new/removed entry point
-2. Dispose and recreate esbuild context (entry points changed; esbuild API does not
-   support modifying entry points on an existing context)
-3. Determine affected pages by entry point scope:
-   - **Global assets** (global.client.*, global.css): rebuild all pages
-   - **Layout assets** (*.layout.css, *.layout.client.*): rebuild maps first, then
-     rebuild only pages using that layout
-   - **Page-level assets** (client.*, style.css, *.worker.*): rebuild only the page
-     in the same directory (matched via `page.path`)
-4. Rebuild maps
-
-### Non-esbuild file added/removed
-
-Any other file (new page, layout, template, config, etc.) is a structural change.
-Falls through to `#fullRebuild()` which re-identifies all pages, restarts esbuild,
-rebuilds all pages, and rebuilds all maps.
-
-## Logging
-
-### `logRebuildTree(trigger, pages?, templates?)`
-Prints BEFORE the build — the trigger filename and an indented tree of affected outputs:
-```
-"page.js" changed:
-  → about/index.html
-```
-
-### `buildLogger(results, dest?)`
-Prints AFTER the build:
-- **Full builds**: Site totals (`Pages: N Layouts: N Templates: N`) + build counts + `Build Success!`
-- **Filtered builds**: Each built output file (`Built about/index.html`), then summary
-  counts (`Pages built: 1 Templates built: 0`) + `Build Success!`. Requires `dest` to
-  relativize absolute output paths from the worker report.
-
-### `errorLogger(err)`
-Prints `inspect(err, { depth: 999, colors: true })` + `Build Failed!`
-
-## Testing
-
-### `settled()` method
-
-Public method on `DomStack` that returns `this.#buildLock`. Lets tests await all queued
-rebuilds without exposing the private field.
-
-### `test-cases/watch/index.test.js`
-
-Watch mode test suite using `node:test` with `mock.method(console, 'log')` for log capture.
-Copies the general-features fixture to a temp directory inside the project tree (so
-node_modules resolution works for esbuild bare specifiers). 60-second timeout.
-
-Test cases:
-1. Initial build completes with siteData and output files
-2. Page file change → only that page rebuilds (content verified in output)
-3. Layout change → only pages using that layout rebuild (no full rebuild)
-4. esbuild entry point change → no page rebuild (esbuild handles it)
-5. Adding client.js → esbuild restart + only that page rebuilds
-6. Removing client.js → esbuild restart + only that page rebuilds
-7. global.data.js change → all pages rebuild
-8. stopWatching completes without error
-
-Uses `t.after()` hooks for cleanup (stopWatching, mock restore, temp dir removal).
-
-## Files Changed
-
-### `lib/build-esbuild/index.js` ✅
-
-- Extracted `extractOutputMap()` and `updateSiteDataOutputPaths()` as shared helpers
-- Extracted `assembleBuildOpts()` shared between one-shot and watch builds
-- `buildEsbuild()` refactored to use helpers (behavior unchanged for non-watch mode)
-- New `buildEsbuildWatch(src, dest, siteData, opts, watchOpts?)`:
-  - Uses stable (unhashed) `entryNames`/`chunkNames`
-  - Creates `esbuild.context()`, triggers initial `rebuild()` to populate `outputMap`
-  - Attaches a `domstack-on-end` plugin that logs errors after each rebuild
-  - Calls `.watch()` and returns `{ context, outputMap }` for the caller to manage
-
-### `lib/build-pages/index.js` ✅
-
-- Added `BuildPagesOpts` typedef with `pageFilterPaths` and `templateFilterPaths`
-  (filepath arrays, not Sets, for structured-clone serialization over the worker boundary)
-- `buildPagesDirect` converts filter arrays to Sets, then:
-  - Still inits ALL pages and stamps `globalDataVars` onto all of them (required for correct rendering)
-  - Only the write step (pageWriter / templateBuilder) is filtered to the requested subset
-
-### `lib/build-pages/worker.js` ✅
-
-- Passes `opts` from `workerData` through to `buildPagesDirect` so filter arrays reach the worker
-
-### `index.js` ✅
-
-- `watch()` does an inline initial build (not via `builder()`), starting esbuild in watch
-  mode immediately to avoid a double build
-- After initial build, `#rebuildMaps()` constructs all seven data structures (6 maps + 1 set)
-- Chokidar events serialized through a `#buildLock` promise chain (prevents pile-up)
-- Chokidar uses `atomic: 300` to handle atomic-save editors gracefully
-- `#handleChange(changedPath)` implements the decision tree with esbuild entry check (Rule 6)
-  before dep map lookups to prevent false matches
-- `#handleAddUnlink(changedPath, event)` categorizes add/unlink by file type for targeted
-  rebuilds (esbuild entries get esbuild restart + targeted page rebuild; everything else
-  gets full rebuild)
-- `#fullRebuild()`: disposes esbuild context, re-identifies pages, restarts in watch mode,
-  rebuilds all pages, rebuilds maps
-- `#runPageBuild(siteData, pageFilterPaths?, templateFilterPaths?)`: filtered or full page
-  rebuild, passes dest to buildLogger for filtered builds
-- `stopWatching()` properly disposes the esbuild context
-- `settled()`: public method returning `#buildLock` for test synchronization
-- `buildLogger(results, dest?)`: shows per-file output for filtered builds
-
-### `test-cases/watch/index.test.js` ✅ (new)
-
-- Watch mode test suite with 8 test cases covering progressive rebuild behavior
-
-## Dependencies Added
-
-- `@11ty/dependency-tree-typescript` — static ESM dep analysis for layout and page dep tracking.
-  Handles `.ts` files natively. MIT licensed. Added to `package.json` dependencies.
-
-## Resolved Decisions
-
-- **Worker per render**: Keep spawning a fresh worker per `buildPages()` call. Node's ESM module
-  cache means `import()` always returns the cached version within the same process — a fresh
-  worker is required to re-import changed modules.
-- **layoutDepMap values**: Use `layoutName` (not `layoutFilepath`) as the value so it feeds
-  directly into `layoutPageMap` without extra indirection.
-- **layoutPageMap source**: Built in `#rebuildMaps()` by calling `resolveVars()` on each page's
-  `page.vars.*` file directly — lightweight, no worker needed.
-- **global.data.js trigger rule**: Always full page rebuild. Since `global.data.js` output is
-  stamped onto every page's vars, there's no safe subset to rebuild. No esbuild restart needed.
-- **esbuild onEnd**: No page rebuild triggered. Watch mode uses stable filenames so page HTML
-  never references changed bundle paths. `@domstack/sync` reloads the browser directly.
-- **esbuild entry point detection**: Uses a concrete `Set<filepath>` built from siteData
-  properties, checked BEFORE dep map rules in the decision tree. This prevents dep maps
-  (which may contain esbuild entry files as transitive dependencies) from triggering
-  unnecessary page rebuilds.
-- **Add/unlink granularity**: esbuild entry point add/remove triggers esbuild restart +
-  targeted page rebuild (not full site rebuild). esbuild's context API does not support
-  modifying entry points, so dispose + recreate is required. Non-esbuild file add/remove
-  still triggers full rebuild (structural change to the page set).
-- **Path normalization**: `find()` returns CWD-relative `./…` paths; `siteData` uses absolute
-  paths. All dep paths are `resolve()`d to absolute before being stored as map keys.
-- **Concurrency**: Chokidar events are serialized through `#buildLock` so rapid saves don't
-  cause overlapping rebuilds.
-- **Filter init vs render split**: All pages are always initialized and have `globalDataVars`
-  stamped before the filter is applied to the write step. This ensures filtered pages still
-  receive correct global data context from their peers.
diff --git a/plans/standard-static-mpa-service-worker.md b/plans/standard-static-mpa-service-worker.md
new file mode 100644
index 00000000..edfee616
--- /dev/null
+++ b/plans/standard-static-mpa-service-worker.md
@@ -0,0 +1,199 @@
+# Optional Standard Static MPA Service Worker
+
+## Status: Proposal validated by example
+
+`examples/static-mpa-offline` is the current domstack-native prototype for a possible optional standard static MPA service-worker preset.
+
+It no longer runtime-fetches `domstack-manifest.json` or a generated policy JSON file.
+
+Instead, `hooks.manifestBuilt` injects the finalized manifest-shaped policy into `/service-worker.js` with `defineServiceWorkerConstant()`.
+
+The service worker consumes Domstack manifest entries directly and derives cache behavior from the manifest fields and selected offline vars.
+
+## Goals
+
+- Provide a simple, robust, production-ready static MPA offline preset.
+- Keep service workers explicit opt-in.
+- Avoid forcing Workbox on sites that only need static MPA offline behavior.
+- Use Domstack's finalized build graph instead of hand-maintained asset lists.
+- Keep watch mode safe by disabling caches and unregistering old workers.
+- Include recovery paths from the start.
+
+## Non-goals
+
+- Do not auto-enable service workers for all domstack sites.
+- Do not cache API/data endpoints by default.
+- Do not implement app-specific offline mutations, background sync, push subscriptions, or data models.
+- Do not force a domstack-provided update UI into user layouts.
+- Do not replace Workbox for apps that need Workbox plugins and recipes.
+
+## Current example behavior
+
+The vanilla example has these moving parts:
+
+- `src/globals/domstack-manifest/domstack-manifest.settings.ts` selects `offline` and `precache` manifest vars and registers the build hook.
+- `src/globals/domstack-manifest/policy-build.ts` injects `{ version, entries, offlineFallbackUrl }` into `/service-worker.js`.
+- `src/globals/service-worker/service-worker.ts` chooses production vs watch behavior by detecting whether the injected policy constant exists.
+- `src/globals/service-worker/precache.ts` derives precache keys and runtime strategy from Domstack manifest entries.
+- `src/globals/global-client/*` owns registration, update UI, watch cleanup, reset query params, and connection status.
+
+The service worker uses:
+
+- stable `/service-worker.js`
+- stable cache names
+- revisioned cache keys for non-hashed URLs
+- cache-first handling for precached static outputs
+- network-first handling for progressive/runtime routes
+- network-only behavior for offline-disabled routes
+- navigation fallback to the offline page
+- watch-mode no-policy self-disable
+- `SKIP_WAITING` and `RESET_SERVICE_WORKER` messages
+
+## Offline vars convention
+
+The example intentionally keeps user-facing vars small:
+
+```ts
+type StaticMpaOfflineManifestVars = {
+  offline?: boolean
+  precache?: boolean
+}
+```
+
+`offline: true` means the page/route is allowed to become available offline.
+
+`offline: false` makes the route network-only with offline fallback behavior for navigations.
+
+`precache: true` means the navigation page is cached during install.
+
+`precache: false` means the navigation page is runtime-cached after the first successful visit.
+
+Layout vars set section defaults.
+
+Page vars/frontmatter can override layout vars through the normal cascade.
+
+The cascade is:
+
+```txt
+page vars -> layout vars -> global vars -> defaults
+```
+
+## Build-time injection model
+
+The current build model is:
+
+```txt
+final Domstack manifest
+  -> manifestBuilt hook
+  -> context.defineServiceWorkerConstant('__DOMSTACK_SERVICE_WORKER_POLICY__', policy)
+  -> final /service-worker.js bundle
+```
+
+This is preferred over:
+
+- fetching `/domstack-manifest.json` at runtime
+- fetching `/domstack-service-worker-policy.json` at runtime
+- generating JavaScript globals with `importScripts()`
+- using top-level await in service workers
+
+Policy changes change `/service-worker.js` bytes and trigger the browser update lifecycle.
+
+## Watch mode
+
+Watch mode does not produce a manifest policy.
+
+The service worker detects that the injected policy constant is missing and installs as a no-op cleanup worker.
+
+The watch worker:
+
+- calls `skipWaiting()` during install
+- deletes owned caches during activation
+- unregisters itself
+- registers no fetch handler
+
+The browser client also unregisters workers and clears known caches in watch mode.
+
+This double layer matters because a previous production worker can serve cached HTML/JS before the watch-mode client code runs.
+
+Watch builds disable esbuild splitting so `/service-worker.js` stays self-contained during cleanup.
+
+## Client registration helper behavior
+
+A future reusable client helper should:
+
+1. No-op when `navigator.serviceWorker` is unavailable.
+2. Clean up when `DOMSTACK_MANIFEST_ENABLED` is false.
+3. Register after `window.load` by default.
+4. Register with the stable service-worker URL/scope from Domstack defines.
+5. Use `{ type: 'module', updateViaCache: 'none' }`.
+6. Detect `installing`, `waiting`, and `active` states immediately after registration.
+7. Expose callbacks/events for ready, update available, updating, reset, error, and online/offline state.
+8. Avoid hard-coded blocking dialogs.
+9. Provide a default reset query param such as `?reset-sw`.
+10. Reload once on `controllerchange` after an accepted update.
+
+## Possible reusable API
+
+Start with reusable imports rather than generated service-worker source:
+
+```ts
+// src/service-worker.ts
+import '@domstack/static/service-worker/static-mpa'
+```
+
+```ts
+// src/global.client.ts
+import { registerDomstackServiceWorker } from '@domstack/static/client/service-worker'
+
+registerDomstackServiceWorker()
+```
+
+This keeps service workers inspectable and customizable.
+
+A higher-level preset can come later if the helper API stabilizes.
+
+## Recovery design
+
+Every standard path should include two recovery tiers.
+
+### Recoverable reset
+
+If page JS still loads, a query param should reset worker state:
+
+```txt
+/?reset-sw
+```
+
+Behavior:
+
+1. Post `RESET_SERVICE_WORKER` to active/waiting/installing workers.
+2. Unregister matching registrations.
+3. Delete known domstack cache prefixes.
+4. Remove the reset query param.
+5. Reload from the network.
+
+### Emergency replacement worker
+
+A rescue worker can be deployed at the exact production service-worker URL:
+
+```txt
+/service-worker.js
+```
+
+It should:
+
+- call `skipWaiting()` during install
+- have no `fetch` handler
+- delete known domstack caches during activate
+- reload or let clients reload after control changes
+
+The exact URL requirement is important.
+
+Deploying a rescue worker at a different URL leaves the broken worker active.
+
+## Open questions
+
+- Should domstack ship reusable static-MPA service-worker modules, or keep examples as copyable recipes?
+- Should core expose helper utilities for deriving runtime strategy and precache keys from manifest entries?
+- Should the public `domstack-manifest.json` schema remain a packaged artifact if service-worker use mostly relies on injected constants?
+- How much default update UI should a helper provide versus only dispatching events?
diff --git a/plans/workbox-workflow-integration.md b/plans/workbox-workflow-integration.md
new file mode 100644
index 00000000..b4a6c3fb
--- /dev/null
+++ b/plans/workbox-workflow-integration.md
@@ -0,0 +1,227 @@
+# Workbox Workflow Integration Plan
+
+## Status: Example implemented with injected policy
+
+`examples/static-mpa-workbox-offline` demonstrates the current preferred Workbox integration model.
+
+Domstack does not run Workbox `injectManifest` and does not generate a JavaScript global loaded with `importScripts()`.
+
+Instead, `hooks.manifestBuilt` computes a Workbox-oriented policy from the finalized Domstack manifest and injects it into the final `/service-worker.js` bundle with `context.defineServiceWorkerConstant()`.
+
+The authored service worker remains normal user code.
+
+It imports Workbox packages directly and passes the generated `precacheManifest` field to Workbox APIs.
+
+## Goals
+
+- Support Workbox without forcing it into domstack core.
+- Generate correct Workbox precache data from Domstack's real emitted outputs.
+- Keep user-authored service-worker code inspectable and customizable.
+- Use Workbox for mature precaching, routing, strategies, plugins, and update helpers.
+- Avoid runtime policy fetches and generated global scripts.
+- Keep watch mode safe when no manifest policy exists.
+
+## Non-goals
+
+- Do not make service workers automatic for every domstack build.
+- Do not require Workbox as a core dependency for sites that do not opt into it.
+- Do not cache API/data endpoints by default.
+- Do not hide service-worker stickiness or recovery requirements.
+- Do not replace custom user-authored service workers.
+
+## Current example architecture
+
+The Workbox example uses:
+
+- `src/globals/domstack-manifest/domstack-manifest.settings.ts`
+- `src/globals/domstack-manifest/policy-build.ts`
+- `src/globals/service-worker/service-worker.ts`
+- `src/globals/global-client/*`
+
+The manifest settings hook injects a policy constant:
+
+```ts
+context.defineServiceWorkerConstant('__DOMSTACK_WORKBOX_POLICY__', {
+  version: manifest.version,
+  offlineFallbackUrl: '/offline/',
+  precacheManifest: [
+    { url: '/', revision: 'sha256hex...' },
+    { url: '/about/', revision: 'sha256hex...' },
+    { url: '/global-ABC123.css', revision: null, integrity: 'sha256-...' },
+  ],
+  runtimeUrls: ['/progressive-cache/'],
+  networkOnlyUrls: ['/admin/'],
+})
+```
+
+The service worker reads the injected policy inside the manifest-enabled branch:
+
+```ts
+declare const __DOMSTACK_WORKBOX_POLICY__: StaticMpaWorkboxServiceWorkerPolicy
+
+if (manifestEnabled) {
+  const policy = __DOMSTACK_WORKBOX_POLICY__
+  precacheAndRoute(policy.precacheManifest)
+}
+```
+
+The policy constant must not be read at module top level in watch mode.
+
+Watch mode builds do not define it.
+
+## Workbox APIs currently used
+
+The example uses:
+
+- `workbox-precaching`
+  - `precacheAndRoute()`
+  - `cleanupOutdatedCaches()`
+  - `matchPrecache()` where needed by fallback behavior
+- `workbox-routing`
+  - `registerRoute()`
+  - `setCatchHandler()`
+- `workbox-strategies`
+  - `NetworkFirst`
+  - `NetworkOnly`
+- `workbox-cacheable-response`
+  - `CacheableResponsePlugin`
+- `workbox-expiration`
+  - `ExpirationPlugin`
+- `workbox-recipes`
+  - `offlineFallback()`
+- `workbox-window`
+  - registration lifecycle events
+  - `messageSkipWaiting()`
+
+## Policy shape
+
+Workbox's native precache input is:
+
+```ts
+type WorkboxPrecacheEntry = {
+  url: string
+  revision: string | null
+  integrity?: string
+}
+```
+
+The example policy includes that native shape plus app-specific route policy:
+
+```ts
+type StaticMpaWorkboxServiceWorkerPolicy = {
+  version: string
+  offlineFallbackUrl: string
+  precacheManifest: WorkboxPrecacheEntry[]
+  runtimeUrls: string[]
+  networkOnlyUrls: string[]
+}
+```
+
+Only `precacheManifest` is passed directly to Workbox precaching.
+
+`runtimeUrls`, `networkOnlyUrls`, and `offlineFallbackUrl` are app policy and are mapped explicitly to Workbox routing/strategy APIs.
+
+## Why injected policy is preferred
+
+Injected policy has these advantages:
+
+- no runtime fetch for a policy JSON file
+- no generated JS file imported by the service worker
+- no `importScripts()` convention
+- no Workbox `self.__WB_MANIFEST` source transform
+- policy changes alter `/service-worker.js` bytes
+- browser update lifecycle is triggered naturally
+- the authored service worker remains regular bundled module code
+
+This means Domstack only needs the general `manifestBuilt` hook and final service-worker build step.
+
+It does not need Workbox-specific source transformation in core.
+
+## Watch mode
+
+Workbox precaching is disabled in watch mode.
+
+Watch mode sets `DOMSTACK_MANIFEST_ENABLED=false` and does not run the manifest/policy injection path.
+
+The service worker branch for watch mode:
+
+- installs immediately
+- deletes owned caches
+- unregisters itself
+- registers no Workbox routes
+- does not touch the injected policy constant
+
+The client also unregisters existing workers and clears known caches in watch mode.
+
+Watch builds disable esbuild splitting so `/service-worker.js` stays self-contained during cleanup.
+
+## Client lifecycle
+
+The Workbox example uses `workbox-window` because it provides cleaner lifecycle events than hand-rolled registration logic.
+
+Current behavior:
+
+- `installing` shows “Installing offline cache…”
+- `activated` shows ready state for first install
+- `waiting` prompts for update or applies a previously waiting update
+- `controlling` reloads after accepted updates
+- `redundant` logs to the console only
+
+Watch-mode cleanup happens before normal registration and does not wait for `window.load`.
+
+Production registration waits for `window.load`.
+
+## Runtime caching policy
+
+The example only runtime-caches routes selected by manifest vars.
+
+It uses Workbox plugins to keep runtime cache behavior bounded:
+
+- `CacheableResponsePlugin` limits which responses can enter the cache.
+- `ExpirationPlugin` limits cache age/count.
+
+The example does not cache arbitrary API/data requests by default.
+
+## Potential package helper
+
+A future helper could live outside core or as an optional export:
+
+```ts
+import { createWorkboxPolicy } from '@domstack/static/workbox'
+
+export default {
+  hooks: {
+    manifestBuilt: [context => {
+      context.defineServiceWorkerConstant(
+        '__APP_WORKBOX_POLICY__',
+        createWorkboxPolicy(context.manifest, options),
+      )
+    }],
+  },
+}
+```
+
+The helper could cover:
+
+- max precache size
+- include/exclude filters
+- revision/null handling for hashed URLs
+- optional integrity inclusion
+- route-policy derivation from selected `manifestVars`
+- warnings for skipped entries
+
+This should remain optional.
+
+Domstack core should continue exposing generic manifest hooks rather than hard-coding Workbox behavior.
+
+## Deprecated ideas
+
+These ideas were considered but are not the current direction:
+
+- generating a public Workbox manifest module and importing it from the service worker
+- fetching a policy JSON file during service-worker install
+- using `importScripts()` to load generated globals
+- transforming `self.__WB_MANIFEST` like Workbox `injectManifest`
+- generating the entire Workbox service worker from core config
+
+They remain possible for external integrations, but the example and current plan prefer injected constants.
diff --git a/scripts/domstack-manifest-schema.js b/scripts/domstack-manifest-schema.js
new file mode 100644
index 00000000..c11ef855
--- /dev/null
+++ b/scripts/domstack-manifest-schema.js
@@ -0,0 +1,13 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import {
+  DOMSTACK_MANIFEST_SCHEMA_PATH,
+  domstackManifestSchema,
+} from '../lib/domstack-manifest/index.js'
+
+// Keep the checked-in schema.json generated from the JS schema source so the
+// published $schema URL, runtime manifest shape, and exported types stay aligned.
+const outputPath = resolve(import.meta.dirname, '..', DOMSTACK_MANIFEST_SCHEMA_PATH)
+
+await mkdir(dirname(outputPath), { recursive: true })
+await writeFile(outputPath, `${JSON.stringify(domstackManifestSchema, null, 2)}\n`)
diff --git a/test-cases/general-features/index.test.js b/test-cases/general-features/index.test.js
index 55d6dd9f..1ad7c3a3 100644
--- a/test-cases/general-features/index.test.js
+++ b/test-cases/general-features/index.test.js
@@ -1,8 +1,13 @@
+/**
+ * @import { DomstackManifestEntry } from '#types'
+ */
+
 import { test } from 'node:test'
 import assert from 'node:assert'
-import { testBuild } from '../../index.js'
+import { DOMSTACK_MANIFEST_SCHEMA_ID, DomStack, buildDomstackManifest, testBuild } from '../../index.js'
 import * as path from 'path'
-import { stat, readFile } from 'fs/promises'
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'fs/promises'
+import { tmpdir } from 'os'
 import * as cheerio from 'cheerio'
 import { allFiles } from 'async-folder-walker'
 
@@ -19,6 +24,513 @@ test.describe('general-features', () => {
     })
 
     assert.ok(results, 'DomStack built site and returned build results')
+    assert.ok(results.domstackManifest, 'build returned a domstack manifest')
+    assert.strictEqual(
+      results.domstackManifest.$schema,
+      DOMSTACK_MANIFEST_SCHEMA_ID,
+      'domstack manifest includes its schema URL'
+    )
+
+    const domstackManifestPath = path.join(dest, 'domstack-manifest.json')
+    await assert.rejects(
+      () => stat(domstackManifestPath),
+      'domstack manifest is not written by default'
+    )
+
+    const manifestEntries = /** @type {DomstackManifestEntry[]} */ (results.domstackManifest.entries)
+    const manifestEntryByUrl = new Map(manifestEntries.map(entry => [entry.url, entry]))
+
+    assert.ok(manifestEntryByUrl.has('/'), 'domstack manifest includes root page URL')
+    assert.ok(manifestEntryByUrl.has('/md-page/'), 'domstack manifest includes nested page URL')
+    assert.ok(manifestEntryByUrl.has('/md-page/loose-md.html'), 'domstack manifest includes loose markdown URL')
+    assert.ok(manifestEntryByUrl.has('/feeds/feed.json'), 'domstack manifest includes normal template output')
+    assert.ok(manifestEntryByUrl.has('/worker-page/workers.json'), 'domstack manifest includes worker manifest')
+    assert.ok(
+      !manifestEntryByUrl.has('/domstack-manifest.json'),
+      'domstack manifest does not include itself'
+    )
+
+    assert.ok(
+      !manifestEntryByUrl.has('/service-worker.js'),
+      'domstack manifest omits the site service worker to avoid circular manifest-version dependencies'
+    )
+
+    assert.ok(
+      manifestEntries.some(entry => entry.kind === 'chunk' && entry.url.startsWith('/chunks/js/chunk-')),
+      'domstack manifest classifies shared JS chunks'
+    )
+    assert.ok(
+      manifestEntries.some(entry => entry.kind === 'sourcemap' && entry.url.endsWith('.map')),
+      'domstack manifest classifies source maps'
+    )
+    assert.ok(
+      manifestEntries.some(entry => entry.kind === 'worker' && entry.url.includes('/worker-page/counter.worker-')),
+      'domstack manifest classifies worker bundles'
+    )
+    assert.ok(
+      manifestEntries.some(entry => entry.kind === 'copy' && entry.url === '/oldsite/client.js'),
+      'domstack manifest includes copy directory outputs'
+    )
+    assert.ok(
+      manifestEntries.some(entry => entry.kind === 'static' && entry.url === '/static.json'),
+      'domstack manifest includes static outputs'
+    )
+    assert.deepStrictEqual(
+      manifestEntryByUrl.get('/js-page/')?.page?.vars,
+      { precache: false, offline: false },
+      'domstack manifest includes page-level precache/offline vars'
+    )
+
+    const rootEntry = manifestEntryByUrl.get('/')
+    assert.strictEqual(rootEntry?.contentType, 'text/html; charset=utf-8', 'page entries include best-known content type')
+    assert.strictEqual(rootEntry?.static, true, 'page entries are marked as static domstack outputs')
+    assert.strictEqual(rootEntry?.role, 'navigation', 'page entries get the navigation role')
+    assert.strictEqual(rootEntry?.urlRevisioned, false, 'page URLs are not marked as URL-revisioned')
+    assert.match(rootEntry?.integrity ?? '', /^sha256-/, 'entries include SRI-formatted integrity metadata')
+
+    const hashedScriptEntry = manifestEntries.find(entry => entry.kind === 'script' && entry.url.endsWith('.js'))
+    assert.strictEqual(hashedScriptEntry?.urlRevisioned, true, 'hashed esbuild script URLs are marked as URL-revisioned')
+    assert.strictEqual(hashedScriptEntry?.role, 'subresource', 'script entries get the subresource role')
+    assert.strictEqual(hashedScriptEntry?.static, true, 'script entries are marked as static outputs')
+
+    for (const entry of manifestEntries) {
+      assert.ok(entry.url.startsWith('/'), `${entry.outputRelname} has an absolute URL`)
+      assert.ok(entry.revision, `${entry.outputRelname} has a content revision`)
+      assert.ok(Number.isInteger(entry.bytes), `${entry.outputRelname} has byte size`)
+    }
+
+    const serviceWorkerContent = await readFile(path.join(dest, 'service-worker.js'), 'utf8')
+    assert.ok(serviceWorkerContent.includes('/domstack-manifest.json'), 'service worker was bundled')
+    assert.ok(!serviceWorkerContent.includes('process.env.DOMSTACK_MANIFEST_URL'), 'service worker receives the domstack manifest URL define')
+    assert.ok(!serviceWorkerContent.includes('process.env.DOMSTACK_MANIFEST_ENABLED'), 'service worker receives the domstack manifest enabled define')
+    assert.ok(serviceWorkerContent.includes(results.domstackManifest.version), 'service worker receives the finalized domstack manifest version define')
+    assert.ok(serviceWorkerContent.includes('cache: "no-store"'), 'service worker fetches the domstack manifest at runtime')
+    assert.ok(serviceWorkerContent.includes('caches.match(request)'), 'service worker has cache-first fetch handling')
+
+    const metaContent = await readFile(path.join(dest, 'domstack-esbuild-meta.json'), 'utf8')
+    const metaData = JSON.parse(metaContent)
+    assert.ok(
+      !Object.keys(metaData.outputs).some(outputPath => outputPath.endsWith('/service-worker.js')),
+      'domstack app esbuild metafile omits the final service worker build'
+    )
+
+    const stableSite = new DomStack(src, dest, { copy: [path.join(__dirname, './copyfolder')] })
+    const stableResults = await stableSite.build()
+
+    assert.strictEqual(
+      stableResults.domstackManifest?.version,
+      results.domstackManifest.version,
+      'domstack manifest version is stable across identical builds'
+    )
+
+    await t.test('domstackManifest version includes cache-relevant metadata', async () => {
+      const basePage = {
+        path: '',
+        url: '/',
+        vars: {
+          precache: true,
+          offline: true,
+        },
+      }
+      /** @type {DomstackManifestEntry} */
+      const baseEntry = {
+        outputRelname: 'index.html',
+        kind: 'page',
+        url: '/',
+        revision: 'same-file-revision',
+        bytes: 42,
+        sourceRelname: 'pages/index.js',
+        page: basePage,
+      }
+
+      const baseManifest = await buildDomstackManifest({ dest, entries: [baseEntry] })
+      const sourceOnlyManifest = await buildDomstackManifest({
+        dest,
+        entries: [{
+          ...baseEntry,
+          sourceRelname: 'pages/renamed-index.js',
+        }],
+      })
+      const kindChangedManifest = await buildDomstackManifest({
+        dest,
+        entries: [{
+          ...baseEntry,
+          kind: 'template',
+        }],
+      })
+      const offlineChangedManifest = await buildDomstackManifest({
+        dest,
+        entries: [{
+          ...baseEntry,
+          page: {
+            ...basePage,
+            vars: {
+              ...basePage.vars,
+              offline: false,
+            },
+          },
+        }],
+      })
+      const manifestVarsManifest = await buildDomstackManifest({
+        dest,
+        entries: [baseEntry],
+        options: {
+          manifestVars: ['precache'],
+        },
+      })
+      const policyManifest = await buildDomstackManifest({
+        dest,
+        entries: [baseEntry],
+        options: {
+          manifestVars: ['precache'],
+          policy ({ entries }) {
+            return {
+              precacheUrls: entries
+                .filter(entry => entry.manifestVars?.['precache'] === true)
+                .map(entry => entry.url),
+            }
+          },
+        },
+      })
+      const objectPrecacheManifest = await buildDomstackManifest({
+        dest,
+        entries: [{
+          ...baseEntry,
+          page: {
+            ...basePage,
+            vars: {
+              ...basePage.vars,
+              precache: { core: true, priority: 1 },
+            },
+          },
+        }],
+      })
+      const reorderedObjectPrecacheManifest = await buildDomstackManifest({
+        dest,
+        entries: [{
+          ...baseEntry,
+          page: {
+            ...basePage,
+            vars: {
+              ...basePage.vars,
+              precache: { priority: 1, core: true },
+            },
+          },
+        }],
+      })
+
+      assert.strictEqual(
+        sourceOnlyManifest.version,
+        baseManifest.version,
+        'source metadata does not affect domstack manifest version'
+      )
+      assert.notStrictEqual(
+        kindChangedManifest.version,
+        baseManifest.version,
+        'kind affects domstack manifest version'
+      )
+      assert.notStrictEqual(
+        offlineChangedManifest.version,
+        baseManifest.version,
+        'page offline policy affects domstack manifest version'
+      )
+      assert.deepStrictEqual(
+        manifestVarsManifest.entries[0]?.manifestVars,
+        { precache: true },
+        'manifestVars allowlist exposes selected page vars'
+      )
+      assert.deepStrictEqual(
+        policyManifest.policy,
+        { precacheUrls: ['/'] },
+        'policy transform exposes derived root manifest policy'
+      )
+      assert.notStrictEqual(
+        manifestVarsManifest.version,
+        baseManifest.version,
+        'manifestVars affect domstack manifest version'
+      )
+      assert.notStrictEqual(
+        policyManifest.version,
+        baseManifest.version,
+        'policy affects domstack manifest version'
+      )
+      assert.strictEqual(
+        reorderedObjectPrecacheManifest.version,
+        objectPrecacheManifest.version,
+        'object-valued page cache policy uses stable key ordering'
+      )
+    })
+
+    await t.test('domstackManifest exclude handles root page URL', async () => {
+      const excludeBuild = await testBuild(src, {
+        copy: [path.join(__dirname, './copyfolder')],
+        domstackManifest: {
+          exclude: ['oldsite/**'],
+        },
+      })
+      t.after(async () => {
+        await excludeBuild.cleanup()
+      })
+
+      const excludeEntries = /** @type {DomstackManifestEntry[]} */ (excludeBuild.results.domstackManifest?.entries ?? [])
+
+      assert.ok(
+        excludeEntries.some(entry => entry.url === '/'),
+        'root page URL survives non-root exclude filters'
+      )
+      assert.ok(
+        !excludeEntries.some(entry => entry.url.startsWith('/oldsite/')),
+        'exclude filters still remove matching output paths'
+      )
+    })
+
+    await t.test('domstack-manifest.settings.js filters domstack manifest entries', async (t) => {
+      const settingsSrc = await mkdtemp(path.join(tmpdir(), 'domstack-manifest-settings-'))
+      const settingsDest = await mkdtemp(path.join(tmpdir(), 'domstack-manifest-settings-public-'))
+      t.after(async () => {
+        await rm(settingsSrc, { recursive: true, force: true })
+        await rm(settingsDest, { recursive: true, force: true })
+      })
+
+      await mkdir(path.join(settingsSrc, 'kept'), { recursive: true })
+      await mkdir(path.join(settingsSrc, 'programmatic'), { recursive: true })
+      await mkdir(path.join(settingsSrc, 'settings'), { recursive: true })
+      await writeFile(path.join(settingsSrc, 'page.js'), 'export default () => "<p>Domstack manifest settings</p>"\n')
+      await writeFile(path.join(settingsSrc, 'service-worker.js'), 'console.log(process.env.DOMSTACK_MANIFEST_URL, DOMSTACK_TEST_SERVICE_WORKER_POLICY.message)\n')
+      await writeFile(path.join(settingsSrc, 'kept/page.js'), 'export default () => "<p>Kept</p>"\n')
+      await writeFile(path.join(settingsSrc, 'programmatic/page.js'), 'export default () => "<p>Programmatic exclude</p>"\n')
+      await writeFile(path.join(settingsSrc, 'settings/page.js'), 'export default () => "<p>Settings exclude</p>"\n')
+      await writeFile(path.join(settingsSrc, 'domstack-manifest.settings.js'), `
+export default async function domstackManifestSettings () {
+  return {
+    exclude: ['settings/**'],
+    includeEntry (entry) {
+      return entry.kind !== 'sourcemap'
+    },
+    hooks: {
+      manifestBuilt: [context => {
+        context.defineServiceWorkerConstant('DOMSTACK_TEST_SERVICE_WORKER_POLICY', {
+          message: 'from-manifest-hook',
+          version: context.manifest.version,
+        })
+      }],
+    },
+  }
+}
+`)
+
+      const settingsSite = new DomStack(settingsSrc, settingsDest, {
+        domstackManifest: {
+          exclude: ['programmatic/**'],
+          write: true,
+        },
+      })
+
+      const settingsResults = await settingsSite.build()
+      const settingsEntries = /** @type {DomstackManifestEntry[]} */ (settingsResults.domstackManifest?.entries ?? [])
+
+      const settingsServiceWorkerContent = await readFile(path.join(settingsDest, 'service-worker.js'), 'utf8')
+
+      await stat(path.join(settingsDest, 'domstack-manifest.json'))
+      assert.ok(
+        settingsServiceWorkerContent.includes('/domstack-manifest.json'),
+        'service worker define receives the standard domstack manifest URL'
+      )
+      assert.ok(
+        settingsServiceWorkerContent.includes('from-manifest-hook'),
+        'manifestBuilt hook can define constants for the final service-worker bundle'
+      )
+      assert.ok(
+        settingsEntries.some(entry => entry.url === '/'),
+        'root page survives domstack manifest settings filters'
+      )
+      assert.ok(
+        settingsEntries.some(entry => entry.url === '/kept/'),
+        'unfiltered page output remains in manifest'
+      )
+      assert.ok(
+        !settingsEntries.some(entry => entry.url === '/programmatic/'),
+        'programmatic domstackManifest exclude is applied'
+      )
+      assert.ok(
+        !settingsEntries.some(entry => entry.url === '/settings/'),
+        'domstack-manifest.settings.js exclude is applied'
+      )
+      assert.ok(
+        !settingsEntries.some(entry => entry.kind === 'sourcemap'),
+        'domstack-manifest.settings.js includeEntry is applied'
+      )
+    })
+
+    await t.test('metafile false skips esbuild metadata without breaking domstack manifest', async () => {
+      const noMetaBuild = await testBuild(src, {
+        copy: [path.join(__dirname, './copyfolder')],
+        metafile: false,
+      })
+      t.after(async () => {
+        await noMetaBuild.cleanup()
+      })
+
+      const noMetaDest = noMetaBuild.dest
+      const noMetaResults = noMetaBuild.results
+      const noMetaEntries = /** @type {DomstackManifestEntry[]} */ (noMetaResults.domstackManifest?.entries ?? [])
+
+      assert.ok(noMetaResults.domstackManifest, 'build returned a domstack manifest with metafile disabled')
+      assert.ok(
+        noMetaEntries.some(entry => entry.kind === 'script'),
+        'domstack manifest still includes esbuild script outputs'
+      )
+      assert.ok(
+        noMetaEntries.some(entry => entry.kind === 'sourcemap'),
+        'domstack manifest still includes esbuild sourcemap outputs'
+      )
+      assert.ok(
+        !noMetaEntries.some(entry => entry.kind === 'metadata' && entry.url === '/domstack-esbuild-meta.json'),
+        'domstack manifest does not include skipped esbuild metafile'
+      )
+      await assert.rejects(
+        () => stat(path.join(noMetaDest, 'domstack-esbuild-meta.json')),
+        'esbuild metafile was not written'
+      )
+    })
+
+    await t.test('domstackManifest true writes the default manifest file', async () => {
+      const writtenManifestBuild = await testBuild(src, { domstackManifest: true })
+      t.after(async () => {
+        await writtenManifestBuild.cleanup()
+      })
+
+      const writtenManifestDest = writtenManifestBuild.dest
+      /** @type {{ version: string, entries: Record<string, unknown>[] }} */
+      const writtenManifest = JSON.parse(await readFile(path.join(writtenManifestDest, 'domstack-manifest.json'), 'utf8'))
+      assert.strictEqual(
+        writtenManifest.version,
+        writtenManifestBuild.results.domstackManifest?.version,
+        'domstackManifest true writes the returned manifest to disk'
+      )
+      assert.ok(
+        writtenManifest.entries.every(entry => !('filepath' in entry)),
+        'written domstack manifest does not expose absolute filesystem paths'
+      )
+    })
+
+    await t.test('build without manifest settings or write request skips domstack manifest pipeline', async (t) => {
+      const noManifestSrc = await mkdtemp(path.join(tmpdir(), 'domstack-no-manifest-'))
+      const noManifestDest = await mkdtemp(path.join(tmpdir(), 'domstack-no-manifest-public-'))
+      t.after(async () => {
+        await rm(noManifestSrc, { recursive: true, force: true })
+        await rm(noManifestDest, { recursive: true, force: true })
+      })
+
+      await writeFile(path.join(noManifestSrc, 'page.js'), 'export default () => "<p>No manifest settings</p>"\n')
+      await writeFile(path.join(noManifestSrc, 'service-worker.js'), 'console.log(process.env.DOMSTACK_MANIFEST_URL, process.env.DOMSTACK_MANIFEST_ENABLED)\n')
+      const noManifestResults = await new DomStack(noManifestSrc, noManifestDest).build()
+      const noManifestServiceWorkerContent = await readFile(path.join(noManifestDest, 'service-worker.js'), 'utf8')
+
+      assert.strictEqual(noManifestResults.domstackManifest, undefined, 'build does not return a domstack manifest without a consumer')
+      await assert.rejects(
+        () => stat(path.join(noManifestDest, 'domstack-manifest.json')),
+        'domstack manifest is not written without an explicit write request'
+      )
+      assert.ok(
+        noManifestServiceWorkerContent.includes('/domstack-manifest.json'),
+        'standard domstack manifest URL define remains stable even when the pipeline is disabled'
+      )
+    })
+
+    await t.test('esbuild settings cannot drop reserved DOMSTACK defines', async (t) => {
+      const defineSrc = await mkdtemp(path.join(tmpdir(), 'domstack-esbuild-defines-'))
+      t.after(async () => {
+        await rm(defineSrc, { recursive: true, force: true })
+      })
+
+      await writeFile(path.join(defineSrc, 'page.js'), 'export default () => "<p>DOMSTACK defines</p>"\n')
+      await writeFile(path.join(defineSrc, 'global.client.js'), `
+console.log(
+  process.env.DOMSTACK_MANIFEST_URL,
+  process.env.DOMSTACK_SERVICE_WORKER_URL,
+  process.env.CUSTOM_DEFINE
+)
+`)
+      await writeFile(path.join(defineSrc, 'service-worker.js'), `
+console.log(
+  process.env.DOMSTACK_MANIFEST_URL,
+  process.env.DOMSTACK_SERVICE_WORKER_SCOPE,
+  process.env.CUSTOM_DEFINE
+)
+`)
+      await writeFile(path.join(defineSrc, 'esbuild.settings.js'), `
+export default function esbuildSettings (opts) {
+  return {
+    ...opts,
+    define: {
+      'process.env.CUSTOM_DEFINE': JSON.stringify('from-settings'),
+    },
+  }
+}
+`)
+
+      const defineBuild = await testBuild(defineSrc)
+      t.after(async () => {
+        await defineBuild.cleanup()
+      })
+
+      const defineFiles = await allFiles(defineBuild.dest, { shaper: fwData => fwData })
+      const globalClientFile = defineFiles.find(file => file.relname.match(/global\.client-.+\.js$/))
+      assert.ok(globalClientFile, 'global client bundle was written')
+
+      const globalClientContent = await readFile(path.join(defineBuild.dest, globalClientFile.relname), 'utf8')
+      const defineServiceWorkerContent = await readFile(path.join(defineBuild.dest, 'service-worker.js'), 'utf8')
+
+      assert.ok(globalClientContent.includes('/domstack-manifest.json'), 'global client keeps domstack manifest URL define')
+      assert.ok(globalClientContent.includes('/service-worker.js'), 'global client keeps service worker URL define')
+      assert.ok(globalClientContent.includes('from-settings'), 'global client keeps user esbuild define')
+      assert.ok(!globalClientContent.includes('process.env.DOMSTACK_'), 'global client has no unreplaced DOMSTACK defines')
+      assert.ok(defineServiceWorkerContent.includes('/domstack-manifest.json'), 'service worker keeps domstack manifest URL define')
+      assert.match(defineServiceWorkerContent, /["']\/["']/, 'service worker keeps service worker scope define')
+      assert.ok(defineServiceWorkerContent.includes('from-settings'), 'service worker keeps user esbuild define')
+      assert.ok(!defineServiceWorkerContent.includes('process.env.DOMSTACK_'), 'service worker has no unreplaced DOMSTACK defines')
+    })
+
+    await t.test('esbuild settings cannot override reserved DOMSTACK defines', async (t) => {
+      const conflictSrc = await mkdtemp(path.join(tmpdir(), 'domstack-esbuild-define-conflict-'))
+      const conflictDest = await mkdtemp(path.join(tmpdir(), 'domstack-esbuild-define-conflict-public-'))
+      t.after(async () => {
+        await rm(conflictSrc, { recursive: true, force: true })
+        await rm(conflictDest, { recursive: true, force: true })
+      })
+
+      await writeFile(path.join(conflictSrc, 'page.js'), 'export default () => "<p>DOMSTACK define conflict</p>"\n')
+      await writeFile(path.join(conflictSrc, 'global.client.js'), 'console.log(process.env.DOMSTACK_MANIFEST_URL)\n')
+      await writeFile(path.join(conflictSrc, 'esbuild.settings.js'), `
+export default function esbuildSettings (opts) {
+  return {
+    ...opts,
+    define: {
+      ...opts.define,
+      'process.env.DOMSTACK_MANIFEST_URL': JSON.stringify('/not-domstack-owned.json'),
+    },
+  }
+}
+`)
+
+      await assert.rejects(
+        () => new DomStack(conflictSrc, conflictDest).build(),
+        error => {
+          if (!(error instanceof Error)) return false
+          const buildError = /** @type {Error & { errors?: Array<Error & { cause?: unknown }> }} */ (error)
+          return error.message.includes('Prebuild finished but there were errors') &&
+            buildError.errors?.some(err => {
+              const cause = err.cause
+              return err.message.includes('Error building JS+CSS with esbuild') &&
+                cause instanceof Error &&
+                cause.message.includes('process.env.DOMSTACK_MANIFEST_URL') &&
+                cause.message.includes('reserved by domstack')
+            }) === true
+        },
+        'reserved DOMSTACK define conflicts fail clearly'
+      )
+    })
 
     const globalAssets = {
       globalStyle: true,
diff --git a/test-cases/general-features/src/blog/2025/a-blog-post-from-2025/page.ts b/test-cases/general-features/src/blog/2025/a-blog-post-from-2025/page.ts
index d882874d..1f1fadd9 100644
--- a/test-cases/general-features/src/blog/2025/a-blog-post-from-2025/page.ts
+++ b/test-cases/general-features/src/blog/2025/a-blog-post-from-2025/page.ts
@@ -1,4 +1,4 @@
-export default function ()  {
+export default function () {
   return `
   Hello world, from 2025. Also typescript
   <div class="tsx-app"></div>
@@ -7,6 +7,6 @@ export default function ()  {
 
 export const vars = {
   layout: 'ts',
-  publishDate: "2023-03-01T18:06:24.000Z",
-  title: "A Blogpost from 2025"
+  publishDate: '2023-03-01T18:06:24.000Z',
+  title: 'A Blogpost from 2025'
 } as const
diff --git a/test-cases/general-features/src/domstack-manifest.settings.js b/test-cases/general-features/src/domstack-manifest.settings.js
new file mode 100644
index 00000000..b1c6ea43
--- /dev/null
+++ b/test-cases/general-features/src/domstack-manifest.settings.js
@@ -0,0 +1 @@
+export default {}
diff --git a/test-cases/general-features/src/globals/service-worker.mts b/test-cases/general-features/src/globals/service-worker.mts
new file mode 100644
index 00000000..36498416
--- /dev/null
+++ b/test-cases/general-features/src/globals/service-worker.mts
@@ -0,0 +1,67 @@
+import { CACHE_PREFIX, DOMSTACK_MANIFEST_URL, DOMSTACK_MANIFEST_VERSION, loadManifest } from '../libs/service-worker-helper.js'
+
+type DomstackManifestEntry = {
+  revision?: unknown,
+  kind: string,
+  url: string
+}
+
+type DomstackManifest = {
+  version: string,
+  entries: DomstackManifestEntry[]
+}
+
+type ServiceWorkerExtendableEvent = Event & {
+  waitUntil (promise: Promise<unknown>): void
+}
+
+type ServiceWorkerFetchEvent = Event & {
+  request: Request,
+  respondWith (response: Promise<Response>): void
+}
+
+self.addEventListener('install', event => {
+  const installEvent = event as ServiceWorkerExtendableEvent
+  installEvent.waitUntil(precache())
+})
+
+self.addEventListener('activate', event => {
+  const activateEvent = event as ServiceWorkerExtendableEvent
+  activateEvent.waitUntil(cleanup())
+})
+
+self.addEventListener('fetch', event => {
+  const fetchEvent = event as ServiceWorkerFetchEvent
+  if (fetchEvent.request.method !== 'GET') return
+  fetchEvent.respondWith(cacheFirst(fetchEvent.request))
+})
+
+async function precache () {
+  const manifest = await loadDomstackManifest()
+  const cache = await caches.open(CACHE_PREFIX + DOMSTACK_MANIFEST_VERSION)
+  const urls = manifest.entries
+    .filter(entry => entry.revision)
+    .filter(entry => entry.kind !== 'sourcemap')
+    .filter(entry => entry.kind !== 'metadata')
+    .filter(entry => entry.url !== DOMSTACK_MANIFEST_URL)
+    .map(entry => entry.url)
+
+  await cache.addAll(urls)
+}
+
+async function cleanup () {
+  const current = CACHE_PREFIX + DOMSTACK_MANIFEST_VERSION
+  const names = await caches.keys()
+  await Promise.all(names
+    .filter(name => name.startsWith(CACHE_PREFIX) && name !== current)
+    .map(name => caches.delete(name)))
+}
+
+async function cacheFirst (request: Request) {
+  const cached = await caches.match(request)
+  return cached || fetch(request)
+}
+
+async function loadDomstackManifest (): Promise<DomstackManifest> {
+  return await loadManifest() as DomstackManifest
+}
diff --git a/test-cases/general-features/src/js-page/page.vars.js b/test-cases/general-features/src/js-page/page.vars.js
index 7cccd01c..f061ca5d 100644
--- a/test-cases/general-features/src/js-page/page.vars.js
+++ b/test-cases/general-features/src/js-page/page.vars.js
@@ -1,3 +1,5 @@
 export default {
   somePageVars: 'foo',
+  precache: false,
+  offline: false,
 }
diff --git a/test-cases/general-features/src/libs/service-worker-helper.js b/test-cases/general-features/src/libs/service-worker-helper.js
new file mode 100644
index 00000000..04df20c8
--- /dev/null
+++ b/test-cases/general-features/src/libs/service-worker-helper.js
@@ -0,0 +1,13 @@
+export const DOMSTACK_MANIFEST_URL = process.env['DOMSTACK_MANIFEST_URL'] ?? ''
+export const DOMSTACK_MANIFEST_ENABLED = process.env['DOMSTACK_MANIFEST_ENABLED'] ?? 'false'
+export const DOMSTACK_MANIFEST_VERSION = process.env['DOMSTACK_MANIFEST_VERSION'] ?? ''
+export const CACHE_PREFIX = 'domstack-precache-'
+
+export async function loadManifest () {
+  if (DOMSTACK_MANIFEST_ENABLED !== 'true') {
+    throw new Error('Domstack manifest is not enabled')
+  }
+  const response = await fetch(DOMSTACK_MANIFEST_URL, { cache: 'no-store' })
+  if (!response.ok) throw new Error('Unable to load domstack manifest')
+  return response.json()
+}
diff --git a/test-cases/template-output-escape/index.test.js b/test-cases/template-output-escape/index.test.js
new file mode 100644
index 00000000..89064ba6
--- /dev/null
+++ b/test-cases/template-output-escape/index.test.js
@@ -0,0 +1,28 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { rm } from 'node:fs/promises'
+import path from 'node:path'
+import { DomStack } from '../../index.js'
+
+const __dirname = import.meta.dirname
+
+test('template outputs cannot escape dest', async (t) => {
+  const src = path.join(__dirname, './src')
+  const dest = path.join(__dirname, './public')
+  const siteUp = new DomStack(src, dest)
+
+  t.after(async () => {
+    await rm(dest, { recursive: true, force: true })
+  })
+
+  await rm(dest, { recursive: true, force: true })
+
+  await assert.rejects(
+    () => siteUp.build(),
+    error => {
+      assert.ok(error instanceof Error)
+      assert.match(error.message, /Build finished/)
+      return true
+    }
+  )
+})
diff --git a/test-cases/template-output-escape/src/README.md b/test-cases/template-output-escape/src/README.md
new file mode 100644
index 00000000..e23a3d12
--- /dev/null
+++ b/test-cases/template-output-escape/src/README.md
@@ -0,0 +1 @@
+# Template output escape fixture
diff --git a/test-cases/template-output-escape/src/escape.template.js b/test-cases/template-output-escape/src/escape.template.js
new file mode 100644
index 00000000..0f6a0d7c
--- /dev/null
+++ b/test-cases/template-output-escape/src/escape.template.js
@@ -0,0 +1,6 @@
+export default function escapeTemplate () {
+  return {
+    outputName: '../escape.txt',
+    content: 'bad output',
+  }
+}
diff --git a/test-cases/type-exports/index.test.ts b/test-cases/type-exports/index.test.ts
index 28f7f3c2..88491d2c 100644
--- a/test-cases/type-exports/index.test.ts
+++ b/test-cases/type-exports/index.test.ts
@@ -1,12 +1,32 @@
 import { test } from 'node:test'
 import assert from 'node:assert'
-import { PageData } from '../../index.js'
+import { readFile } from 'node:fs/promises'
+import {
+  DOMSTACK_MANIFEST_SCHEMA_ID,
+  DOMSTACK_MANIFEST_SCHEMA_PATH,
+  PageData,
+  domstackManifestEntryPageMetaSchema,
+  domstackManifestEntrySchema,
+  domstackManifestKindSchema,
+  domstackManifestSchema,
+  getDomstackManifestSchemaId,
+} from '../../index.js'
 import type {
   AsyncGlobalDataFunction,
   AsyncLayoutFunction,
   AsyncPageFunction,
   BuildOptions,
   DomStackOpts,
+  DomstackManifest,
+  DomstackManifestEntry,
+  DomstackManifestEntryPageMeta,
+  DomstackManifestKind,
+  DomstackManifestOptions,
+  DomstackManifestPolicyTransform,
+  DomstackManifestPolicyTransformContext,
+  DomstackManifestRecord,
+  DomstackManifestTransform,
+  DomstackManifestTransformContext,
   GlobalDataFunction,
   GlobalDataFunctionParams,
   LayoutFunction,
@@ -15,6 +35,7 @@ import type {
   PageFunctionParams,
   PageInfo,
   Results,
+  ServiceWorkerInfo,
   SiteData,
   TemplateAsyncIterator,
   TemplateFunction,
@@ -48,6 +69,12 @@ const templateInfo: TemplateInfo = {
   outputName: 'feed.xml',
 }
 
+const serviceWorkerInfo: ServiceWorkerInfo = {
+  ...walkerFile,
+  basename: 'service-worker.js',
+  relname: 'globals/service-worker.js',
+}
+
 const pageData = new PageData({
   pageInfo,
   globalVars: {},
@@ -108,26 +135,148 @@ const domStackOpts: DomStackOpts = {
 const siteData: SiteData | null = null
 const results: Results | null = null
 const testBuildResult: TestBuildResult | null = null
+const domstackManifestKind: DomstackManifestKind = 'page'
+const domstackManifestEntryPageMeta: DomstackManifestEntryPageMeta = {
+  path: '',
+  url: '/',
+  vars: {
+    precache: true,
+  },
+}
+type ExamplePolicy = {
+  cache: 'precache' | 'runtime' | 'network-only'
+}
+
+type ExampleManifestVars = {
+  section: string
+}
+
+type ExampleSourceVars = ExampleManifestVars & {
+  cache: ExamplePolicy['cache']
+}
+
+const domstackManifestEntry: DomstackManifestEntry<ExampleManifestVars> = {
+  outputRelname: 'index.html',
+  kind: domstackManifestKind,
+  url: '/',
+  revision: 'revision',
+  bytes: 42,
+  contentType: 'text/html; charset=utf-8',
+  integrity: 'sha256-test',
+  manifestVars: { section: 'docs' },
+  urlRevisioned: false,
+  static: true,
+  role: 'navigation',
+  page: domstackManifestEntryPageMeta,
+}
+const domstackManifest: DomstackManifest<ExamplePolicy, ExampleManifestVars> = {
+  $schema: DOMSTACK_MANIFEST_SCHEMA_ID,
+  version: 'version',
+  generatedAt: new Date(0).toISOString(),
+  entries: [domstackManifestEntry],
+  policy: { cache: 'precache' },
+}
+const domstackManifestRecord: DomstackManifestRecord = {
+  outputRelname: 'index.html',
+  filepath: '/public/index.html',
+  kind: 'page',
+}
+const domstackManifestTransformContext: DomstackManifestTransformContext<ExampleManifestVars, ExampleSourceVars> = {
+  vars: { cache: 'precache', section: 'docs' },
+  entry: domstackManifestEntry,
+}
+const domstackManifestVarsTransform: DomstackManifestTransform<ExampleManifestVars, ExampleManifestVars, ExampleSourceVars> = ({ vars }) => ({ section: vars.section })
+const domstackManifestPolicyTransformContext: DomstackManifestPolicyTransformContext<ExamplePolicy, ExampleManifestVars> = {
+  entries: [domstackManifestEntry],
+}
+const domstackManifestPolicyTransform: DomstackManifestPolicyTransform<ExamplePolicy, ExampleManifestVars> = () => ({ cache: 'precache' })
+const domstackManifestOptions: DomstackManifestOptions<ExamplePolicy, ExampleManifestVars, ExampleSourceVars> = {
+  manifestVars: domstackManifestVarsTransform,
+  policy: domstackManifestPolicyTransform,
+}
 
-void layoutParams
-void pageParams
-void templateParams
-void globalDataParams
-void layoutFunction
-void asyncLayoutFunction
-void pageFunction
-void asyncPageFunction
-void templateFunction
-void templateAsyncIterator
-void globalDataFunction
-void asyncGlobalDataFunction
-void templateOutputOverride
-void buildOptions
-void domStackOpts
-void siteData
-void results
-void testBuildResult
+assert.equal([
+  layoutParams,
+  pageParams,
+  templateParams,
+  globalDataParams,
+  layoutFunction,
+  asyncLayoutFunction,
+  pageFunction,
+  asyncPageFunction,
+  templateFunction,
+  templateAsyncIterator,
+  globalDataFunction,
+  asyncGlobalDataFunction,
+  templateOutputOverride,
+  buildOptions,
+  domStackOpts,
+  serviceWorkerInfo,
+  siteData,
+  results,
+  testBuildResult,
+  domstackManifestKind,
+  domstackManifestEntryPageMeta,
+  domstackManifestEntry,
+  domstackManifest,
+  domstackManifestRecord,
+  domstackManifestTransformContext,
+  domstackManifestVarsTransform,
+  domstackManifestPolicyTransformContext,
+  domstackManifestPolicyTransform,
+  domstackManifestOptions,
+].length, 29)
 
 test('PageData is importable from the package entry point', () => {
   assert.strictEqual(typeof PageData, 'function', 'PageData is a class')
 })
+
+test('domstack manifest schemas are importable from the package entry point', async () => {
+  const [schemaJson, packageJson] = await Promise.all([
+    readFile(new URL('../../lib/domstack-manifest/schema.json', import.meta.url), 'utf8'),
+    readFile(new URL('../../package.json', import.meta.url), 'utf8'),
+  ])
+  const schemaFile = JSON.parse(schemaJson)
+  const packageInfo = JSON.parse(packageJson)
+
+  assert.deepStrictEqual(
+    schemaFile,
+    domstackManifestSchema,
+    'packaged schema.json matches exported schema'
+  )
+  assert.ok(
+    DOMSTACK_MANIFEST_SCHEMA_ID.includes(`@${packageInfo.version}/`),
+    'manifest schema ID includes the package version'
+  )
+  assert.strictEqual(
+    DOMSTACK_MANIFEST_SCHEMA_ID,
+    getDomstackManifestSchemaId(packageInfo.version),
+    'schema ID helper builds the exported schema ID from the package version'
+  )
+  assert.strictEqual(
+    DOMSTACK_MANIFEST_SCHEMA_PATH,
+    'lib/domstack-manifest/schema.json',
+    'schema path points at the packaged JSON schema'
+  )
+  assert.strictEqual(
+    domstackManifestSchema.$id,
+    DOMSTACK_MANIFEST_SCHEMA_ID,
+    'manifest schema uses exported schema ID'
+  )
+  assert.strictEqual(
+    domstackManifestSchema.properties.$schema.const,
+    DOMSTACK_MANIFEST_SCHEMA_ID,
+    'manifest instance schema field uses exported schema ID'
+  )
+  assert.ok(domstackManifestKindSchema.enum.includes('page'), 'kind schema includes pages')
+  assert.strictEqual(
+    domstackManifestEntrySchema.properties.page,
+    domstackManifestEntryPageMetaSchema,
+    'entry schema uses page metadata schema'
+  )
+  assert.strictEqual(
+    domstackManifestSchema.properties.entries.items,
+    domstackManifestEntrySchema,
+    'manifest schema uses entry schema'
+  )
+})
diff --git a/test-cases/watch/index.test.js b/test-cases/watch/index.test.js
index 98df368e..81220af4 100644
--- a/test-cases/watch/index.test.js
+++ b/test-cases/watch/index.test.js
@@ -89,21 +89,27 @@ test.describe('watch', () => {
     const results = await domStack.watch({ serve: false })
     assert.ok(results, 'watch() returned initial build results')
     assert.ok(results.siteData, 'results include siteData')
+    assert.equal(results.domstackManifest, undefined, 'watch mode does not return a domstack manifest')
 
     const jsPageIndex = path.join(dest, 'js-page/index.html')
     const st = await stat(jsPageIndex)
     assert.ok(st.isFile(), 'js-page/index.html was built')
-
-    // ── Chunks have hashed names in watch mode ───────────────────────
-    // html-page/client.js, js-page/client.js, and md-page/client.js all import
-    // client-helper.js, so esbuild splits it into a shared chunk. The chunk must
-    // have a hash in its name even in watch mode to avoid output path collisions.
-    const chunkFiles = await readdir(path.join(dest, 'chunks', 'js'))
-    const jsChunks = chunkFiles.filter(f => f.endsWith('.js'))
-    assert.ok(jsChunks.length > 0, 'at least one shared JS chunk was produced')
+    await assert.rejects(
+      () => stat(path.join(dest, 'domstack-manifest.json')),
+      'watch mode does not write a domstack manifest'
+    )
+    const serviceWorkerStat = await stat(path.join(dest, 'service-worker.js'))
+    assert.ok(serviceWorkerStat.isFile(), 'watch mode builds site service-worker entries')
+    const serviceWorkerContent = await readFile(path.join(dest, 'service-worker.js'), 'utf8')
+    assert.ok(!serviceWorkerContent.includes('process.env.DOMSTACK_MANIFEST_ENABLED'), 'watch service worker receives the domstack manifest enabled define')
+    assert.ok(serviceWorkerContent.includes('"false"'), 'watch service worker knows the domstack manifest is disabled')
+
+    // ── Watch keeps browser splitting but keeps the service worker self-contained ──
+    const jsChunks = await readdir(path.join(dest, 'chunks', 'js'))
+    assert.ok(jsChunks.length > 0, 'watch mode preserves shared browser JS chunks')
     assert.ok(
-      jsChunks.every(f => /chunk-.+\.js$/.test(f)),
-      `all chunk filenames must include a hash (got: ${jsChunks.join(', ')})`
+      !/import\s.+from\s+['"].*chunks\//.test(serviceWorkerContent),
+      'watch service worker does not import shared chunks'
     )
 
     // ── Page file change → only that page rebuilds ───────────────────
@@ -182,6 +188,28 @@ test.describe('watch', () => {
       )
     })
 
+    // ── service worker change → esbuild rebuilds, no page rebuild ───
+    await t.test('service worker change does not rebuild pages', async () => {
+      mockLog.mock.resetCalls()
+      loggerLogs.length = 0
+
+      const serviceWorkerFile = path.join(src, 'globals/service-worker.mts')
+      const original = await readFile(serviceWorkerFile, 'utf8')
+      await writeFile(serviceWorkerFile, original + '\n// touch')
+
+      await settle(domStack)
+
+      const logs = getLogLines(mockLog, loggerLogs)
+      assert.ok(
+        logs.some(l => l.includes('esbuild will handle rebundling')),
+        'domstack lets esbuild rebundle the service worker'
+      )
+      assert.ok(
+        !logs.some(l => l.includes('Pages built')),
+        'no page rebuild was triggered'
+      )
+    })
+
     // ── esbuild dep change → esbuild rebuilds, no page rebuild ─────
     await t.test('changing a client.js dependency triggers esbuild rebuild only', async () => {
       mockLog.mock.resetCalls()
diff --git a/types.ts b/types.ts
index 37059fb7..b2196131 100644
--- a/types.ts
+++ b/types.ts
@@ -12,8 +12,11 @@ export type {
 } from './lib/build-pages/index.js'
 export type {
   AsyncLayoutFunction,
+  AsyncLayoutVarsFunction,
   LayoutFunction,
   LayoutFunctionParams,
+  LayoutVars,
+  LayoutVarsFunction,
   PageData,
 } from './lib/build-pages/page-data.js'
 export type {
@@ -27,7 +30,22 @@ export type {
   TemplateFunctionParams,
   TemplateOutputOverride,
 } from './lib/build-pages/page-builders/template-builder.js'
-export type { PageInfo, TemplateInfo } from './lib/identify-pages.js'
+export type { PageInfo, ServiceWorkerInfo, TemplateInfo } from './lib/identify-pages.js'
+export type {
+  DomstackManifest,
+  DomstackManifestEntry,
+  DomstackManifestEntryPageMeta,
+  DomstackManifestBuiltHook,
+  DomstackManifestBuiltHookContext,
+  DomstackManifestHooks,
+  DomstackManifestKind,
+  DomstackManifestOptions,
+  DomstackManifestPolicyTransform,
+  DomstackManifestPolicyTransformContext,
+  DomstackManifestRecord,
+  DomstackManifestTransform,
+  DomstackManifestTransformContext,
+} from './lib/domstack-manifest/index.js'
 
 export type TestBuildResult = {
   dest: string
diff --git a/types/@11ty__dependency-tree-typescript.d.ts b/types/@11ty__dependency-tree-typescript.d.ts
index d697308a..575fc73d 100644
--- a/types/@11ty__dependency-tree-typescript.d.ts
+++ b/types/@11ty__dependency-tree-typescript.d.ts
@@ -1,5 +1,5 @@
 declare module '@11ty/dependency-tree-typescript' {
-  export function find(filePath: string): Promise<string[]>
-  export function findGraph(filePath: string): Promise<object>
-  export function mergeGraphs(...graphs: object[]): object
+  export function find (filePath: string): Promise<string[]>
+  export function findGraph (filePath: string): Promise<object>
+  export function mergeGraphs (...graphs: object[]): object
 }