diff --git a/.github/workflows/ci-superdoc.yml b/.github/workflows/ci-superdoc.yml
index 3860946284..cdb9b23734 100644
--- a/.github/workflows/ci-superdoc.yml
+++ b/.github/workflows/ci-superdoc.yml
@@ -39,6 +39,7 @@ jobs:
               - 'packages/document-api/**'
               - 'packages/collaboration-yjs/**'
               - 'packages/docx-evidence-contracts/**'
+              - 'packages/fonts/**'
               - 'shared/**'
               - 'tests/**'
               - 'scripts/**'
@@ -131,6 +132,13 @@ jobs:
         # Local equivalent: `pnpm check:public:superdoc` (with build).
         run: pnpm check:public:superdoc --skip-build
 
+      - name: Font curation list drift check
+        # Fails if the committed packages/fonts/src/bundled-families.ts no longer matches the
+        # font-system curation set, so a font-offerings change that is not regenerated cannot merge
+        # stale (guards the Verdana-bug class). Runs here because the job's path filter covers both
+        # the font offerings (shared/**) and the fonts package (packages/fonts/**).
+        run: pnpm --filter @superdoc-dev/fonts run check:families
+
   unit-tests:
     needs: build
     runs-on: ubuntu-latest
diff --git a/apps/docs/advanced/headless-toolbar.mdx b/apps/docs/advanced/headless-toolbar.mdx
index 67c744488b..f0f3df8d6f 100644
--- a/apps/docs/advanced/headless-toolbar.mdx
+++ b/apps/docs/advanced/headless-toolbar.mdx
@@ -329,8 +329,6 @@ Snapshot values match the format you pass to `execute()`. What you read is what
 
 For a font dropdown that also includes fonts used by the active document, use `useSuperDocFontOptions()` from `superdoc/ui/react` or `ui.fonts` from `superdoc/ui`.
 
-`DEFAULT_FONT_FAMILY_OPTIONS` mirrors the built-in picker list. It can include bundled font choices beyond the core defaults; use the font report when you need per-font rendering details.
-
 For font family, font size, and other commands that apply to selected text, prefer a button menu or popover that prevents `mousedown` from moving focus out of the editor. Native selects can visually clear the editor selection while their menu is open.
 
 <CodeGroup>
@@ -361,7 +359,7 @@ const {
 
 | Constant | Contents |
 |----------|----------|
-| `DEFAULT_FONT_FAMILY_OPTIONS` | Built-in picker list. Includes strict defaults plus explicitly advertised bundled fallback choices. |
+| `DEFAULT_FONT_FAMILY_OPTIONS` | Conservative no-pack baseline: one font per CSS generic (Arial, Times New Roman, Courier New). Configure the pack for the full list, or use `useSuperDocFontOptions()` / `ui.fonts`. |
 | `DEFAULT_FONT_SIZE_OPTIONS` | 8pt through 96pt (14 sizes) |
 | `DEFAULT_TEXT_ALIGN_OPTIONS` | left, center, right, justify |
 | `DEFAULT_LINE_HEIGHT_OPTIONS` | 1.00, 1.15, 1.50, 2.00, 2.50, 3.00 |
diff --git a/apps/docs/editor/custom-ui/toolbar-and-commands.mdx b/apps/docs/editor/custom-ui/toolbar-and-commands.mdx
index 0fe7bf225e..84140402bd 100644
--- a/apps/docs/editor/custom-ui/toolbar-and-commands.mdx
+++ b/apps/docs/editor/custom-ui/toolbar-and-commands.mdx
@@ -101,7 +101,7 @@ function FontSizePicker() {
 
 ## Font family picker
 
-Use `useSuperDocFontOptions()` for a custom font dropdown. It returns the built-in defaults plus fonts used by the active document, sorted alphabetically.
+Use `useSuperDocFontOptions()` for a custom font dropdown. It returns the fonts SuperDoc can render plus fonts used by the active document, sorted alphabetically. Without a configured font pack that is the conservative baseline; configure the pack (`@superdoc-dev/fonts`, or `fonts.assetBaseUrl`) and it returns the full set, minus anything curated with `createSuperDocFonts`.
 
 `label` is what you show. `value` is what you pass to the `font-family` command. `previewFamily` is only for rendering the option row.
 
diff --git a/apps/docs/getting-started/fonts.mdx b/apps/docs/getting-started/fonts.mdx
index 523e9a65cf..5078a3dcfb 100644
--- a/apps/docs/getting-started/fonts.mdx
+++ b/apps/docs/getting-started/fonts.mdx
@@ -10,19 +10,21 @@ SuperDoc keeps the font name from the Word document. When SuperDoc ships an appr
 
 A Word document asks for fonts like Calibri, Cambria, and Times New Roman. Most are proprietary, or not installed on every machine. SuperDoc renders them with reviewed open substitutes that match the metrics: Carlito for Calibri, Liberation Serif for Times New Roman, and more. The original name is kept for export.
 
+Without the pack, the toolbar lists one widely available font per CSS generic: Arial for sans-serif, Times New Roman for serif, Courier New for monospace. Each is applied with that generic as a fallback, so it renders acceptably even where the exact font is absent - a readable floor, not an exact-typography guarantee. Wire the pack and the toolbar lists the full reviewed set, and SuperDoc renders the substitutes everywhere. Either way, the Word font name is kept for export.
+
 These substitutes are real `.woff2` files. The browser fetches them from a URL. Installing SuperDoc from npm puts them in `node_modules`, which does not serve them to the browser. So you tell your app where they live. Pick one path.
 
-### Recommended: the `@superdoc/fonts` package
+### Recommended: the `@superdoc-dev/fonts` package
 
 Install the optional pack and pass it. Your bundler (Vite, Webpack, Next, Nuxt) emits the files and rewrites the URLs. No copy step. No path config.
 
 ```bash
-npm install @superdoc/fonts
+npm install @superdoc-dev/fonts
 ```
 
 ```js
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 
 new SuperDoc({
   selector: '#editor',
@@ -31,6 +33,30 @@ new SuperDoc({
 });
 ```
 
+### Choose which bundled fonts
+
+By default the pack enables every reviewed font. To narrow it, use `createSuperDocFonts` and name the families. Think in Word names (`Calibri`, not the substitute `Carlito`).
+
+Drop a few:
+
+```js
+import { createSuperDocFonts } from '@superdoc-dev/fonts';
+
+new SuperDoc({
+  selector: '#editor',
+  document: 'contract.docx',
+  fonts: createSuperDocFonts({ exclude: ['Cooper Black', 'Brush Script MT'] }),
+});
+```
+
+Or allow only a set:
+
+```js
+fonts: createSuperDocFonts({ include: ['Calibri', 'Cambria', 'Arial'] }),
+```
+
+Curation changes the toolbar list and which families SuperDoc substitutes. It does not touch your own licensed fonts (see [Load your own fonts](#load-your-own-fonts)). A curated-out family a document still uses keeps its Word name for export and renders with a system font.
+
 ### Alternative: host the files yourself
 
 Serve the `.woff2` from your own path or a CDN, then point SuperDoc at them. The files ship in the package at `node_modules/superdoc/dist/fonts/`.
@@ -51,7 +77,7 @@ The CDN build loads the fonts from a path relative to the script. Loading from a
 
 ### Skipping the pack
 
-The pack is optional. Skip it if you load your own fonts for every family, or only need fonts the user's OS already has. When the bundled `.woff2` cannot be fetched, SuperDoc logs a one-time warning and falls back to the original font name. On a machine without that font, the text renders in a system fallback, so it can look unchanged.
+The pack is optional. Skip it if you load your own fonts for every family, or only need fonts the user's OS already has. With no pack configured the toolbar shows the baseline and documents render with system fonts, quietly. If you do wire the pack but the `.woff2` cannot be fetched, SuperDoc logs a one-time warning that names the fix; until then text falls back to the original font name, so it can look unchanged on a machine that lacks it.
 
 ## Load your own fonts
 
@@ -65,11 +91,11 @@ For a brand font, a licensed font, or any family SuperDoc does not ship a fallba
 }
 ```
 
-SuperDoc's built-in fallbacks cover only the fonts it ships and verifies. For everything else, the real file is yours to provide. To register it through SuperDoc instead of CSS, pass it in `fonts.families` (which composes with `@superdoc/fonts`).
+SuperDoc's built-in fallbacks cover only the fonts it ships and verifies. For everything else, the real file is yours to provide. To register it through SuperDoc instead of CSS, pass it in `fonts.families` (which composes with `@superdoc-dev/fonts`).
 
 ## Toolbar font list
 
-The built-in toolbar lists SuperDoc's defaults plus fonts used by the active document, sorted alphabetically. If you pass `modules.toolbar.fonts`, that custom list replaces the default list.
+The built-in toolbar lists the fonts SuperDoc can render, plus the fonts the active document uses, sorted alphabetically. With no pack configured that is the baseline of one font per CSS generic (Arial, Times New Roman, Courier New); with the pack it is the full reviewed set, minus anything you curated out with `createSuperDocFonts`. If you pass `modules.toolbar.fonts`, that custom list replaces it entirely.
 
 Each custom entry is a `{ label, key }` pair where `key` is the CSS `font-family` value:
 
@@ -108,6 +134,7 @@ editor.doc.format.apply({
 
 - **Font name preserved, browser falls back.** SuperDoc keeps the DOCX font name. If no bundled fallback or loaded real font exists, the browser chooses its own fallback.
 - **Custom toolbar list hides document fonts.** Passing `modules.toolbar.fonts` replaces the built-in list. Include every option you want users to pick.
+- **Not every bundled family ships every weight and style.** A few substitutes are a single face. For a bold or italic run the substitute lacks, SuperDoc renders the faces it has and leaves the missing ones to the browser's fallback rather than synthesizing a face, so spacing stays predictable.
 - **Office font licensing.** Calibri, Cambria, and Aptos are licensed Microsoft fonts. Self-hosting the real files requires a license.
 
 ## Where to next
diff --git a/apps/docs/getting-started/frameworks/angular.mdx b/apps/docs/getting-started/frameworks/angular.mdx
index 057ed02a64..c7d7294064 100644
--- a/apps/docs/getting-started/frameworks/angular.mdx
+++ b/apps/docs/getting-started/frameworks/angular.mdx
@@ -11,7 +11,7 @@ Requires Angular 17.2+. `viewChild()` and `input()` are stable from Angular 19;
 ## Install
 
 ```bash
-npm install superdoc @superdoc/fonts
+npm install superdoc @superdoc-dev/fonts
 ```
 
 ## Basic setup
@@ -19,7 +19,7 @@ npm install superdoc @superdoc/fonts
 ```typescript
 import { Component, ElementRef, viewChild, AfterViewInit, inject, DestroyRef } from '@angular/core';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 @Component({
diff --git a/apps/docs/getting-started/frameworks/laravel.mdx b/apps/docs/getting-started/frameworks/laravel.mdx
index 9c156f3815..b003b9cbf6 100644
--- a/apps/docs/getting-started/frameworks/laravel.mdx
+++ b/apps/docs/getting-started/frameworks/laravel.mdx
@@ -11,7 +11,7 @@ SuperDoc works with Laravel + Blade + Vite. Laravel serves the Blade template wi
 ```bash
 composer install
 npm install
-npm install superdoc @superdoc/fonts
+npm install superdoc @superdoc-dev/fonts
 ```
 
 ## Vite config
@@ -56,7 +56,7 @@ Create a Blade view that loads the Vite-bundled script and mounts the editor:
 
 ```js resources/js/app.js
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 let superdoc = new SuperDoc({ selector: '#editor', fonts: superdocFonts });
diff --git a/apps/docs/getting-started/frameworks/nextjs.mdx b/apps/docs/getting-started/frameworks/nextjs.mdx
index 0ffa56c9d5..086ab7cf94 100644
--- a/apps/docs/getting-started/frameworks/nextjs.mdx
+++ b/apps/docs/getting-started/frameworks/nextjs.mdx
@@ -10,7 +10,7 @@ SuperDoc works seamlessly with Next.js. The recommended approach is using `@supe
 The React wrapper is the simplest way to integrate SuperDoc with Next.js:
 
 ```bash
-npm install @superdoc-dev/react @superdoc/fonts
+npm install @superdoc-dev/react @superdoc-dev/fonts
 ```
 
 ### App Router (Next.js 13+)
@@ -20,7 +20,7 @@ npm install @superdoc-dev/react @superdoc/fonts
 'use client';
 
 import { SuperDocEditor } from '@superdoc-dev/react';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import '@superdoc-dev/react/style.css';
 
 export default function EditorPage() {
diff --git a/apps/docs/getting-started/frameworks/nuxt.mdx b/apps/docs/getting-started/frameworks/nuxt.mdx
index 66b22a3c26..029f9c6549 100644
--- a/apps/docs/getting-started/frameworks/nuxt.mdx
+++ b/apps/docs/getting-started/frameworks/nuxt.mdx
@@ -9,7 +9,7 @@ SuperDoc works with Nuxt 4+ as a client-side Vue component. Set `ssr: false` in
 ## Install
 
 ```bash
-npm install superdoc @superdoc/fonts
+npm install superdoc @superdoc-dev/fonts
 ```
 
 ## Configure Nuxt
@@ -33,7 +33,7 @@ Nuxt auto-imports Vue's `ref`, `watch`, and lifecycle hooks: no manual imports n
 ```vue app/pages/index.vue
 <script setup lang="ts">
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 
 const container = ref<HTMLDivElement | null>(null);
 const file = ref<File | null>(null);
diff --git a/apps/docs/getting-started/frameworks/react.mdx b/apps/docs/getting-started/frameworks/react.mdx
index a74f1e8d0c..cca910df78 100644
--- a/apps/docs/getting-started/frameworks/react.mdx
+++ b/apps/docs/getting-started/frameworks/react.mdx
@@ -9,7 +9,7 @@ SuperDoc provides `@superdoc-dev/react`: a first-party wrapper with lifecycle ma
 ## Install
 
 ```bash
-npm install @superdoc-dev/react @superdoc/fonts
+npm install @superdoc-dev/react @superdoc-dev/fonts
 ```
 
 <Note>
@@ -20,7 +20,7 @@ npm install @superdoc-dev/react @superdoc/fonts
 
 ```jsx
 import { SuperDocEditor } from '@superdoc-dev/react';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import '@superdoc-dev/react/style.css';
 
 function App() {
diff --git a/apps/docs/getting-started/frameworks/solid.mdx b/apps/docs/getting-started/frameworks/solid.mdx
index 8e248e286c..06846a03c9 100644
--- a/apps/docs/getting-started/frameworks/solid.mdx
+++ b/apps/docs/getting-started/frameworks/solid.mdx
@@ -13,7 +13,7 @@ SuperDoc does not ship a first-party Solid wrapper. Use the core `superdoc` pack
 ## Install
 
 ```bash
-npm install superdoc @superdoc/fonts
+npm install superdoc @superdoc-dev/fonts
 ```
 
 ## Quick start
@@ -21,7 +21,7 @@ npm install superdoc @superdoc/fonts
 ```tsx
 import { onCleanup, onMount } from 'solid-js';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 export default function App() {
diff --git a/apps/docs/getting-started/frameworks/vanilla-js.mdx b/apps/docs/getting-started/frameworks/vanilla-js.mdx
index 450b8ab8c6..ee3e602be5 100644
--- a/apps/docs/getting-started/frameworks/vanilla-js.mdx
+++ b/apps/docs/getting-started/frameworks/vanilla-js.mdx
@@ -34,7 +34,7 @@ SuperDoc works with plain JavaScript. No framework required.
 
 ```javascript NPM/Bundler
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 const superdoc = new SuperDoc({
diff --git a/apps/docs/getting-started/frameworks/vue.mdx b/apps/docs/getting-started/frameworks/vue.mdx
index c7961ecf79..16db3208c6 100644
--- a/apps/docs/getting-started/frameworks/vue.mdx
+++ b/apps/docs/getting-started/frameworks/vue.mdx
@@ -8,7 +8,7 @@ SuperDoc works with Vue 3.0+ using Composition API, Options API, or `<script set
 ## Install
 
 ```bash
-npm install superdoc @superdoc/fonts
+npm install superdoc @superdoc-dev/fonts
 ```
 
 ## Basic setup
@@ -23,7 +23,7 @@ npm install superdoc @superdoc/fonts
 <script setup>
 import { ref, onMounted, onBeforeUnmount } from 'vue';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 const container = ref(null);
diff --git a/apps/docs/getting-started/quickstart.mdx b/apps/docs/getting-started/quickstart.mdx
index cde4adeaef..cada99c407 100644
--- a/apps/docs/getting-started/quickstart.mdx
+++ b/apps/docs/getting-started/quickstart.mdx
@@ -14,12 +14,12 @@ By the end of this page you'll have a working DOCX editor in your app: load a Wo
 <Tabs>
   <Tab title="npm">
     ```bash
-    npm install superdoc @superdoc/fonts
+    npm install superdoc @superdoc-dev/fonts
     ```
   </Tab>
   <Tab title="React">
     ```bash
-    npm install @superdoc-dev/react @superdoc/fonts
+    npm install @superdoc-dev/react @superdoc-dev/fonts
     ```
   </Tab>
   <Tab title="CDN">
@@ -32,7 +32,7 @@ By the end of this page you'll have a working DOCX editor in your app: load a Wo
 </Tabs>
 
 <Info>
-  `@superdoc/fonts` serves SuperDoc's bundled fallback fonts so Word fonts render without copying assets. It's optional. See [Font support](/getting-started/fonts).
+  `@superdoc-dev/fonts` serves SuperDoc's bundled fallback fonts so Word fonts render without copying assets. It's optional. See [Font support](/getting-started/fonts).
 </Info>
 
 ## 2. Render the editor
@@ -44,7 +44,7 @@ By the end of this page you'll have a working DOCX editor in your app: load a Wo
 
     <script type="module">
       import { SuperDoc } from 'superdoc';
-      import { superdocFonts } from '@superdoc/fonts';
+      import { superdocFonts } from '@superdoc-dev/fonts';
       import 'superdoc/style.css';
 
       const superdoc = new SuperDoc({
@@ -57,7 +57,7 @@ By the end of this page you'll have a working DOCX editor in your app: load a Wo
   <Tab title="React">
     ```jsx
     import { SuperDocEditor } from '@superdoc-dev/react';
-    import { superdocFonts } from '@superdoc/fonts';
+    import { superdocFonts } from '@superdoc-dev/fonts';
     import '@superdoc-dev/react/style.css';
 
     export default function App() {
diff --git a/apps/docs/scripts/validate-code-imports.ts b/apps/docs/scripts/validate-code-imports.ts
index 2642bfc7a8..4470d341de 100644
--- a/apps/docs/scripts/validate-code-imports.ts
+++ b/apps/docs/scripts/validate-code-imports.ts
@@ -36,7 +36,7 @@ const EXACT_SUPERDOC_IMPORTS = new Set([
   '@superdoc-dev/template-builder/defaults',
   '@superdoc-dev/template-builder/field-types.css',
   '@superdoc-dev/superdoc-yjs-collaboration',
-  '@superdoc/fonts',
+  '@superdoc-dev/fonts',
 ]);
 
 const EXACT_EXTERNAL_IMPORTS = new Set([
diff --git a/examples/getting-started/README.md b/examples/getting-started/README.md
index 546c29f240..a6d158b4fd 100644
--- a/examples/getting-started/README.md
+++ b/examples/getting-started/README.md
@@ -11,7 +11,7 @@ Minimal examples for integrating SuperDoc into your project. Each example loads
 | [vanilla](./vanilla) | Plain JavaScript with Vite | [Guide](https://docs.superdoc.dev/getting-started/quickstart) |
 | [cdn](./cdn) | Zero build tools — just an HTML file | [Guide](https://docs.superdoc.dev/getting-started/quickstart) |
 
-The bundler examples pass [`@superdoc/fonts`](https://docs.superdoc.dev/getting-started/fonts), so SuperDoc's bundled fallback fonts (Carlito for Calibri, and more) render without copying any assets. The CDN example loads them from the script's path; the Laravel example copies them into `public/fonts/`.
+The bundler examples pass [`@superdoc-dev/fonts`](https://docs.superdoc.dev/getting-started/fonts), so SuperDoc's bundled fallback fonts (Carlito for Calibri, and more) render without copying any assets. The CDN example loads them from the script's path; the Laravel example copies them into `public/fonts/`.
 
 ## Running
 
diff --git a/examples/getting-started/angular/package.json b/examples/getting-started/angular/package.json
index 98acdebd68..7407cefe15 100644
--- a/examples/getting-started/angular/package.json
+++ b/examples/getting-started/angular/package.json
@@ -11,7 +11,7 @@
     "@angular/core": "^21.1.4",
     "@angular/platform-browser": "^21.1.4",
     "@angular/platform-browser-dynamic": "^21.1.4",
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "rxjs": "~7.8.2",
     "superdoc": "latest",
     "tslib": "^2.8.1",
diff --git a/examples/getting-started/angular/src/app/app.component.ts b/examples/getting-started/angular/src/app/app.component.ts
index aed39b9e3b..505f29bed4 100644
--- a/examples/getting-started/angular/src/app/app.component.ts
+++ b/examples/getting-started/angular/src/app/app.component.ts
@@ -1,6 +1,6 @@
 import { Component, ElementRef, ViewChild, OnDestroy } from '@angular/core';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 
 @Component({
   selector: 'app-root',
diff --git a/examples/getting-started/laravel/README.md b/examples/getting-started/laravel/README.md
index d2b9a468f0..698cb94957 100644
--- a/examples/getting-started/laravel/README.md
+++ b/examples/getting-started/laravel/README.md
@@ -31,4 +31,4 @@ Open **http://localhost:8000** — pick a `.docx` file and SuperDoc renders it.
 
 ## Fonts
 
-SuperDoc's bundled fallback fonts (Carlito for Calibri, and more) are served from `public/fonts/`. `copy-fonts.mjs` copies them out of the installed package before the Vite build. That's the self-host approach. A simpler option for a Vite app is to install [`@superdoc/fonts`](https://docs.superdoc.dev/getting-started/fonts) and pass `fonts: superdocFonts`, which lets Vite emit the fonts with no copy step.
+SuperDoc's bundled fallback fonts (Carlito for Calibri, and more) are served from `public/fonts/`. `copy-fonts.mjs` copies them out of the installed package before the Vite build. That's the self-host approach. A simpler option for a Vite app is to install [`@superdoc-dev/fonts`](https://docs.superdoc.dev/getting-started/fonts) and pass `fonts: superdocFonts`, which lets Vite emit the fonts with no copy step.
diff --git a/examples/getting-started/nextjs/package.json b/examples/getting-started/nextjs/package.json
index ced3925d3c..cbc341270b 100644
--- a/examples/getting-started/nextjs/package.json
+++ b/examples/getting-started/nextjs/package.json
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@superdoc-dev/react": "^1.0.0-rc.1",
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "next": "16.1.6",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
diff --git a/examples/getting-started/nextjs/src/app/page.tsx b/examples/getting-started/nextjs/src/app/page.tsx
index 3a44afa2de..194bb5322d 100644
--- a/examples/getting-started/nextjs/src/app/page.tsx
+++ b/examples/getting-started/nextjs/src/app/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState, useRef } from 'react';
 import { SuperDocEditor, SuperDocRef, DocumentMode } from '@superdoc-dev/react';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import '@superdoc-dev/react/style.css';
 
 export default function Home() {
diff --git a/examples/getting-started/nuxt/app/pages/index.vue b/examples/getting-started/nuxt/app/pages/index.vue
index 71886f0286..e49c948675 100644
--- a/examples/getting-started/nuxt/app/pages/index.vue
+++ b/examples/getting-started/nuxt/app/pages/index.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 
 const editor = ref<HTMLDivElement | null>(null);
 const file = ref<File | null>(null);
diff --git a/examples/getting-started/nuxt/package.json b/examples/getting-started/nuxt/package.json
index c32e2c2a9f..79d356bbd6 100644
--- a/examples/getting-started/nuxt/package.json
+++ b/examples/getting-started/nuxt/package.json
@@ -7,7 +7,7 @@
     "postinstall": "nuxt prepare"
   },
   "dependencies": {
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "nuxt": "^4.3.1",
     "superdoc": "latest",
     "vue": "^3.5.28"
diff --git a/examples/getting-started/react/package.json b/examples/getting-started/react/package.json
index 07cbf0803a..9cfa670c88 100644
--- a/examples/getting-started/react/package.json
+++ b/examples/getting-started/react/package.json
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@superdoc-dev/react": "^1.0.0-rc.1",
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
diff --git a/examples/getting-started/react/src/App.tsx b/examples/getting-started/react/src/App.tsx
index d58cb78ded..6f3dc3a5a6 100644
--- a/examples/getting-started/react/src/App.tsx
+++ b/examples/getting-started/react/src/App.tsx
@@ -1,7 +1,7 @@
 import { useRef, useState } from 'react';
 import { SuperDocEditor } from '@superdoc-dev/react';
 import type { SuperDocRef, DocumentMode } from '@superdoc-dev/react';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import '@superdoc-dev/react/style.css';
 import './App.css';
 
diff --git a/examples/getting-started/solid/package.json b/examples/getting-started/solid/package.json
index 95280683aa..4c3b3e38e8 100644
--- a/examples/getting-started/solid/package.json
+++ b/examples/getting-started/solid/package.json
@@ -6,7 +6,7 @@
     "dev": "vite"
   },
   "dependencies": {
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "solid-js": "^1.9.5",
     "superdoc": "latest"
   },
diff --git a/examples/getting-started/solid/src/App.tsx b/examples/getting-started/solid/src/App.tsx
index ab25227b46..5d77cce20c 100644
--- a/examples/getting-started/solid/src/App.tsx
+++ b/examples/getting-started/solid/src/App.tsx
@@ -1,6 +1,6 @@
 import { createEffect, createSignal, createUniqueId, onCleanup, Show, untrack } from 'solid-js';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 import './App.css';
 
diff --git a/examples/getting-started/vanilla/package.json b/examples/getting-started/vanilla/package.json
index 1a19368fc3..1a7b76c142 100644
--- a/examples/getting-started/vanilla/package.json
+++ b/examples/getting-started/vanilla/package.json
@@ -6,7 +6,7 @@
     "dev": "vite"
   },
   "dependencies": {
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "superdoc": "latest"
   },
   "devDependencies": {
diff --git a/examples/getting-started/vanilla/src/main.js b/examples/getting-started/vanilla/src/main.js
index 2027b21fa7..cc020c0c09 100644
--- a/examples/getting-started/vanilla/src/main.js
+++ b/examples/getting-started/vanilla/src/main.js
@@ -1,9 +1,9 @@
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 // `fonts: superdocFonts` serves SuperDoc's bundled fallback fonts (Carlito for Calibri, etc.)
-// from the @superdoc/fonts package. Your bundler emits the .woff2; no copy step, no assetBaseUrl.
+// from the @superdoc-dev/fonts package. Your bundler emits the .woff2; no copy step, no assetBaseUrl.
 let superdoc = new SuperDoc({
   selector: '#editor',
   fonts: superdocFonts,
diff --git a/examples/getting-started/vue/package.json b/examples/getting-started/vue/package.json
index c9f3cd5dd9..fd49edcc8a 100644
--- a/examples/getting-started/vue/package.json
+++ b/examples/getting-started/vue/package.json
@@ -6,7 +6,7 @@
     "dev": "vite"
   },
   "dependencies": {
-    "@superdoc/fonts": "workspace:*",
+    "@superdoc-dev/fonts": "workspace:*",
     "superdoc": "latest",
     "vue": "^3.5.0"
   },
diff --git a/examples/getting-started/vue/src/App.vue b/examples/getting-started/vue/src/App.vue
index b3cbeeb0b1..1b29a377ce 100644
--- a/examples/getting-started/vue/src/App.vue
+++ b/examples/getting-started/vue/src/App.vue
@@ -10,7 +10,7 @@
 <script setup lang="ts">
 import { ref, watch, onMounted } from 'vue';
 import { SuperDoc } from 'superdoc';
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 import 'superdoc/style.css';
 
 const container = ref<HTMLDivElement>();
diff --git a/packages/fonts/README.md b/packages/fonts/README.md
index 7d781c3d46..f33d5525bb 100644
--- a/packages/fonts/README.md
+++ b/packages/fonts/README.md
@@ -1,4 +1,4 @@
-# @superdoc/fonts
+# @superdoc-dev/fonts
 
 The reviewed metric-compatible font substitutes SuperDoc renders when a document asks for a
 proprietary font (Carlito for Calibri, Liberation Serif for Times New Roman, and so on). This
@@ -19,7 +19,7 @@ lazily in the browser: only the few a document actually uses are fetched.
 
 ```js
 import { SuperDoc } from 'superdoc';
-import { resolveBundledFontAssetUrl } from '@superdoc/fonts';
+import { resolveBundledFontAssetUrl } from '@superdoc-dev/fonts';
 
 new SuperDoc({
   selector: '#editor',
@@ -31,7 +31,7 @@ new SuperDoc({
 Or pass the ready-made config object:
 
 ```js
-import { superdocFonts } from '@superdoc/fonts';
+import { superdocFonts } from '@superdoc-dev/fonts';
 
 new SuperDoc({ selector: '#editor', document, fonts: superdocFonts });
 ```
@@ -40,6 +40,25 @@ That is the whole setup. No copying files into `public/`, no `assetBaseUrl`. The
 written as `new URL('../assets/<file>', import.meta.url)`, which Vite, Webpack 5, Next, Nuxt,
 esbuild, and Parcel all detect, emit, and rewrite to the final hashed path.
 
+### Choosing which fonts
+
+`superdocFonts` enables every reviewed family. To narrow the set, use `createSuperDocFonts` and name
+the families by their Word name (`Calibri`, not the substitute `Carlito`):
+
+```js
+import { createSuperDocFonts } from '@superdoc-dev/fonts';
+
+// Everything except a couple:
+new SuperDoc({ selector: '#editor', document, fonts: createSuperDocFonts({ exclude: ['Cooper Black'] }) });
+
+// Or only an explicit set:
+new SuperDoc({ selector: '#editor', document, fonts: createSuperDocFonts({ include: ['Calibri', 'Cambria'] }) });
+```
+
+`include` is an allow-list; `exclude` keeps everything but the named families. Curation drives the
+toolbar list and which families SuperDoc substitutes. Your own licensed fonts stay separate
+(`fonts.families`).
+
 ### Hosting the assets another way
 
 If you serve the fonts from a CDN or a signed path instead, you do not need this package's
@@ -48,7 +67,7 @@ resolver. Point SuperDoc at your location with `fonts.assetBaseUrl` or your own
 
 ## Versioning
 
-`@superdoc/fonts` and `superdoc` version independently, but they share the bundled font set.
+`@superdoc-dev/fonts` and `superdoc` version independently, but they share the bundled font set.
 Update them together. If the two drift, the resolver throws on an unknown face filename rather
 than degrading silently, so a mismatch surfaces immediately instead of turning into a missing
 font at render time.
diff --git a/packages/fonts/RELEASING.md b/packages/fonts/RELEASING.md
index 0b9ec25057..4d2bfa7a0a 100644
--- a/packages/fonts/RELEASING.md
+++ b/packages/fonts/RELEASING.md
@@ -1,4 +1,4 @@
-# Releasing @superdoc/fonts
+# Releasing @superdoc-dev/fonts
 
 This package is not yet wired into the automated release pipeline. The first publish is manual;
 recurring CI publishing is a follow-up.
@@ -6,22 +6,22 @@ recurring CI publishing is a follow-up.
 ## First publish (manual, required once)
 
 We are not wiring release automation into this PR. The first publish is done by hand so we can
-publish `0.1.0` under the new `@superdoc` org with a deliberate version, rather than letting
-automation pick it. Use the `caio-pizzol` account / a token with publish rights to the `@superdoc`
+publish `0.1.0` under the `@superdoc-dev` org with a deliberate version, rather than letting
+automation pick it. Use the `caio-pizzol` account / a token with publish rights to the `@superdoc-dev`
 org.
 
 ```bash
 # from the repo root
-pnpm --filter @superdoc/fonts build   # runs sync-assets + generate + tsc; produces dist/ + assets/
+pnpm --filter @superdoc-dev/fonts build   # runs sync-assets + generate + tsc; produces dist/ + assets/
 cd packages/fonts
-npm publish --access public           # publishes @superdoc/fonts@0.1.0
+npm publish --access public           # publishes @superdoc-dev/fonts@0.1.0
 ```
 
 `npm publish` runs `prepare` first, so `dist/` and `assets/` (the 65 `.woff2` + license texts) are
 rebuilt and included in the tarball via `package.json` "files". Verify with `npm pack --dry-run`
 before publishing (expect ~65 `.woff2` plus `dist/*` and license files).
 
-After this, the getting-started examples can move from `@superdoc/fonts: workspace:*` to a published
+After this, the getting-started examples can move from `@superdoc-dev/fonts: workspace:*` to a published
 version range, and the docs link resolves.
 
 ## Recurring publishing (follow-up)
diff --git a/packages/fonts/package.json b/packages/fonts/package.json
index 0b4f853aed..8ad1e0bc7d 100644
--- a/packages/fonts/package.json
+++ b/packages/fonts/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "@superdoc/fonts",
+  "name": "@superdoc-dev/fonts",
   "version": "0.1.0",
   "description": "Optional bundled metric-compatible font substitutes for SuperDoc, shipped as bundler-resolvable assets.",
   "type": "module",
@@ -27,10 +27,12 @@
   "sideEffects": false,
   "scripts": {
     "sync": "node scripts/sync-assets.mjs",
-    "generate": "node scripts/generate-asset-urls.mjs",
+    "generate": "node scripts/generate-asset-urls.mjs && pnpm exec tsx scripts/generate-bundled-families.ts",
+    "check:families": "pnpm exec tsx scripts/check-bundled-families.ts",
     "build": "node scripts/sync-assets.mjs && node scripts/generate-asset-urls.mjs && tsc --project tsconfig.json",
     "prepare": "node scripts/sync-assets.mjs && node scripts/generate-asset-urls.mjs && tsc --project tsconfig.json",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest"
   },
   "devDependencies": {
     "@types/node": "catalog:",
diff --git a/packages/fonts/scripts/check-bundled-families.ts b/packages/fonts/scripts/check-bundled-families.ts
new file mode 100644
index 0000000000..274503195c
--- /dev/null
+++ b/packages/fonts/scripts/check-bundled-families.ts
@@ -0,0 +1,39 @@
+// Non-mutating drift check (CI-safe): fails if the committed src/bundled-families.ts no longer
+// matches @superdoc/font-system's runtime curation set (getBundledFamilyNames). Guards the
+// Verdana-bug class - a font-offerings change that regenerates the list in a CI working tree but
+// merges without the committed update, so the published list silently drifts.
+//
+// Skips when the font-system source is absent (a standalone install cannot recompute the set); in the
+// monorepo it runs and a real import error fails loudly. Run via
+// `pnpm --filter @superdoc-dev/fonts check:families`.
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BUNDLED_FAMILY_NAMES } from '../src/bundled-families';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const fontSystemSource = resolve(here, '../../../shared/font-system/src/font-offerings.ts');
+
+if (!existsSync(fontSystemSource)) {
+  console.log('[@superdoc-dev/fonts] font-system source not present (standalone install); skipping curation-drift check');
+  process.exit(0);
+}
+
+// eslint-disable-next-line import-x/no-relative-packages -- build-only script (not shipped); @superdoc-dev/fonts stays a dependency-free runtime package and font-system exposes no /src export, so reading its source relatively here is intentional
+const { getBundledFamilyNames } = await import('../../../shared/font-system/src/font-offerings');
+const expected = [...getBundledFamilyNames()].sort();
+const committed = [...BUNDLED_FAMILY_NAMES].sort();
+
+if (JSON.stringify(expected) !== JSON.stringify(committed)) {
+  const missing = expected.filter((name) => !committed.includes(name));
+  const extra = committed.filter((name) => !expected.includes(name));
+  console.error(
+    '[@superdoc-dev/fonts] src/bundled-families.ts is STALE: it no longer matches the font-system curation set.',
+  );
+  if (missing.length) console.error(`  missing (in offerings, not committed): ${missing.join(', ')}`);
+  if (extra.length) console.error(`  extra (committed, not in offerings):    ${extra.join(', ')}`);
+  console.error('  Fix: run `pnpm --filter @superdoc-dev/fonts generate` and commit src/bundled-families.ts');
+  process.exit(1);
+}
+
+console.log(`[@superdoc-dev/fonts] curation list in sync with font-system (${committed.length} families)`);
diff --git a/packages/fonts/scripts/generate-asset-urls.mjs b/packages/fonts/scripts/generate-asset-urls.mjs
index 262754a7dc..0acde5df15 100644
--- a/packages/fonts/scripts/generate-asset-urls.mjs
+++ b/packages/fonts/scripts/generate-asset-urls.mjs
@@ -17,12 +17,23 @@ const local = resolve(here, '../assets');
 const sourceDir = existsSync(canonical) ? canonical : local;
 const outFile = resolve(here, '../src/asset-urls.ts');
 
+/** Format with the repo Prettier when available so committed output is stable; tolerate its absence. */
+async function formatTs(content, filepath) {
+  try {
+    const prettier = await import('prettier');
+    const config = (await prettier.resolveConfig(filepath)) ?? {};
+    return await prettier.format(content, { ...config, filepath });
+  } catch {
+    return content;
+  }
+}
+
 const files = readdirSync(sourceDir)
   .filter((f) => f.endsWith('.woff2'))
   .sort();
 
 if (files.length === 0) {
-  console.error(`[@superdoc/fonts] no .woff2 found in ${sourceDir}`);
+  console.error(`[@superdoc-dev/fonts] no .woff2 found in ${sourceDir}`);
   process.exit(1);
 }
 
@@ -44,16 +55,11 @@ ${entries}
 // generator produces byte-identical output and the format hook never rewrites it. Prettier is
 // optional - in a consumer git-install it may be absent, and the unformatted output is still
 // valid TypeScript - so a missing prettier is not an error.
-let output = content;
-try {
-  const prettier = await import('prettier');
-  const config = (await prettier.resolveConfig(outFile)) ?? {};
-  output = await prettier.format(content, { ...config, filepath: outFile });
-} catch {
-  // Prettier not resolvable here; write the unformatted (still valid) output.
-}
-
-writeFileSync(outFile, output);
+writeFileSync(outFile, await formatTs(content, outFile));
 console.log(
-  `[@superdoc/fonts] wrote ${files.length} asset URLs -> src/asset-urls.ts (source: ${sourceDir.includes('shared') ? 'canonical' : 'local'})`,
+  `[@superdoc-dev/fonts] wrote ${files.length} asset URLs -> src/asset-urls.ts (source: ${sourceDir.includes('shared') ? 'canonical' : 'local'})`,
 );
+
+// The curatable family-name list (src/bundled-families.ts) is generated SEPARATELY by
+// scripts/generate-bundled-families.ts: it must mirror the runtime resolver/offerings curation set
+// (which includes category fallbacks like Verdana), not the asset manifest's metric-clone `replaces`.
diff --git a/packages/fonts/scripts/generate-bundled-families.ts b/packages/fonts/scripts/generate-bundled-families.ts
new file mode 100644
index 0000000000..289aae79de
--- /dev/null
+++ b/packages/fonts/scripts/generate-bundled-families.ts
@@ -0,0 +1,55 @@
+// Generates src/bundled-families.ts: the Word family names a document can curate via
+// createSuperDocFonts({ include / exclude }), mirrored from @superdoc/font-system's runtime curation
+// set (every logical family the resolver substitutes to a bundled face, including category fallbacks
+// like Verdana) - NOT the asset manifest's narrower metric-clone `replaces`.
+//
+// Skips when the font-system source is absent (a rare standalone install), leaving the committed file;
+// in the monorepo a real import error fails loudly. Committed so npm consumers get the list without
+// re-generating. Re-run via `pnpm --filter @superdoc-dev/fonts generate` when the curation set changes.
+import { existsSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const outFile = resolve(here, '../src/bundled-families.ts');
+const fontSystemSource = resolve(here, '../../../shared/font-system/src/font-offerings.ts');
+
+if (!existsSync(fontSystemSource)) {
+  console.log(
+    '[@superdoc-dev/fonts] font-system source not present (standalone install); kept committed src/bundled-families.ts',
+  );
+  process.exit(0);
+}
+
+// eslint-disable-next-line import-x/no-relative-packages -- build-only script (not shipped); @superdoc-dev/fonts stays a dependency-free runtime package and font-system exposes no /src export, so reading its source relatively here is intentional
+const { getBundledFamilyNames } = await import('../../../shared/font-system/src/font-offerings');
+const names = getBundledFamilyNames();
+if (names.length === 0) {
+  console.error('[@superdoc-dev/fonts] font-system returned no curatable families');
+  process.exit(1);
+}
+
+const content = `/**
+ * GENERATED by scripts/generate-bundled-families.ts - do not edit by hand.
+ *
+ * The Word family names a document can curate via createSuperDocFonts({ include / exclude }), mirrored
+ * from @superdoc/font-system's runtime curation set (every logical family the resolver substitutes to a
+ * bundled face, including category fallbacks like Verdana). A name outside this set is a typo or an
+ * unbundled font, so createSuperDocFonts rejects it instead of silently dropping the intended fonts.
+ */
+export const BUNDLED_FAMILY_NAMES: readonly string[] = Object.freeze([
+${names.map((name) => `  ${JSON.stringify(name)},`).join('\n')}
+]);
+`;
+
+let output = content;
+try {
+  const prettier = await import('prettier');
+  const config = (await prettier.resolveConfig(outFile)) ?? {};
+  output = await prettier.format(content, { ...config, filepath: outFile });
+} catch {
+  // Prettier optional; the unformatted output is still valid TypeScript.
+}
+
+writeFileSync(outFile, output);
+console.log(`[@superdoc-dev/fonts] wrote ${names.length} curatable family names -> src/bundled-families.ts`);
diff --git a/packages/fonts/scripts/sync-assets.mjs b/packages/fonts/scripts/sync-assets.mjs
index 93365b5c4a..3371848a6d 100644
--- a/packages/fonts/scripts/sync-assets.mjs
+++ b/packages/fonts/scripts/sync-assets.mjs
@@ -18,7 +18,7 @@ const dst = resolve(here, '../assets');
 if (!existsSync(src)) {
   // Not in the monorepo (e.g. a published install that somehow ran prepare). The assets are
   // expected to already be present from the tarball, so this is a no-op, not an error.
-  console.warn(`[@superdoc/fonts] canonical assets not found at ${src}; skipping sync (assets assumed present)`);
+  console.warn(`[@superdoc-dev/fonts] canonical assets not found at ${src}; skipping sync (assets assumed present)`);
   process.exit(0);
 }
 
@@ -31,4 +31,4 @@ for (const name of readdirSync(src)) {
   }
 }
 const count = readdirSync(dst).filter((f) => f.endsWith('.woff2')).length;
-console.log(`[@superdoc/fonts] synced ${count} font faces from shared/font-system/assets -> assets/`);
+console.log(`[@superdoc-dev/fonts] synced ${count} font faces from shared/font-system/assets -> assets/`);
diff --git a/packages/fonts/src/bundled-families.ts b/packages/fonts/src/bundled-families.ts
new file mode 100644
index 0000000000..141c1c8fb8
--- /dev/null
+++ b/packages/fonts/src/bundled-families.ts
@@ -0,0 +1,40 @@
+/**
+ * GENERATED by scripts/generate-bundled-families.ts - do not edit by hand.
+ *
+ * The Word family names a document can curate via createSuperDocFonts({ include / exclude }), mirrored
+ * from @superdoc/font-system's runtime curation set (every logical family the resolver substitutes to a
+ * bundled face, including category fallbacks like Verdana). A name outside this set is a typo or an
+ * unbundled font, so createSuperDocFonts rejects it instead of silently dropping the intended fonts.
+ */
+export const BUNDLED_FAMILY_NAMES: readonly string[] = Object.freeze([
+  'Arial',
+  'Arial Black',
+  'Arial MT',
+  'Arial Narrow',
+  'Baskerville Old Face',
+  'Bookman Old Style',
+  'Brush Script MT',
+  'Calibri',
+  'Calibri Light',
+  'Cambria',
+  'Century',
+  'Century Gothic',
+  'Century Schoolbook',
+  'Comic Sans MS',
+  'Consolas',
+  'Cooper Black',
+  'Courier',
+  'Courier New',
+  'Garamond',
+  'Georgia',
+  'Gill Sans MT Condensed',
+  'Helvetica',
+  'ITC Bookman',
+  'Lucida Console',
+  'Segoe UI',
+  'Tahoma',
+  'Times',
+  'Times New Roman',
+  'Trebuchet MS',
+  'Verdana',
+]);
diff --git a/packages/fonts/src/index.test.ts b/packages/fonts/src/index.test.ts
new file mode 100644
index 0000000000..63df8e6255
--- /dev/null
+++ b/packages/fonts/src/index.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { BUNDLED_FONT_ASSET_URLS, createSuperDocFonts, resolveBundledFontAssetUrl, superdocFonts } from './index';
+
+describe('superdocFonts / resolveBundledFontAssetUrl', () => {
+  it('superdocFonts is a ready-made resolveAssetUrl config', () => {
+    expect(typeof superdocFonts.resolveAssetUrl).toBe('function');
+  });
+
+  it('resolves a known bundled face to its emitted URL', () => {
+    const file = Object.keys(BUNDLED_FONT_ASSET_URLS)[0];
+    expect(file).toBeTruthy();
+    expect(superdocFonts.resolveAssetUrl({ file })).toBe(BUNDLED_FONT_ASSET_URLS[file]);
+  });
+
+  it('throws on an unknown file so a version mismatch surfaces immediately', () => {
+    expect(() => resolveBundledFontAssetUrl({ file: 'NotAFont.woff2' })).toThrow(/no bundled asset/);
+  });
+});
+
+describe('createSuperDocFonts', () => {
+  it('with no options is the full pack: resolver only, no curation', () => {
+    const config = createSuperDocFonts();
+    expect(typeof config.resolveAssetUrl).toBe('function');
+    expect(config.bundled).toBeUndefined();
+  });
+
+  it('include sets an allow-list', () => {
+    expect(createSuperDocFonts({ include: ['Calibri', 'Cambria'] }).bundled).toEqual({
+      include: ['Calibri', 'Cambria'],
+    });
+  });
+
+  it('exclude sets a block-list', () => {
+    expect(createSuperDocFonts({ exclude: ['Cooper Black'] }).bundled).toEqual({ exclude: ['Cooper Black'] });
+  });
+
+  it('trims entries and drops empty lists', () => {
+    expect(createSuperDocFonts({ include: ['  Calibri  '] }).bundled).toEqual({ include: ['Calibri'] });
+    expect(createSuperDocFonts({ include: [] }).bundled).toBeUndefined();
+    expect(createSuperDocFonts({ exclude: [] }).bundled).toBeUndefined();
+  });
+
+  it('throws when include and exclude are both given (mutually exclusive intents)', () => {
+    expect(() => createSuperDocFonts({ include: ['Calibri'], exclude: ['Cambria'] })).toThrow(/not both/);
+  });
+
+  it('throws on a non-array list or non-string entries', () => {
+    expect(() => createSuperDocFonts({ include: 'Calibri' as unknown as string[] })).toThrow(/must be an array/);
+    expect(() => createSuperDocFonts({ exclude: ['Calibri', 42 as unknown as string] })).toThrow(
+      /non-empty font name strings/,
+    );
+  });
+
+  it('throws on a font name SuperDoc does not bundle, suggesting the closest match for a typo', () => {
+    expect(() => createSuperDocFonts({ include: ['Calbri'] })).toThrow(/does not bundle/);
+    expect(() => createSuperDocFonts({ include: ['Calbri'] })).toThrow(/did you mean "Calibri"\?/);
+    // A real Word font with no bundled clone is also rejected (curating it would be a no-op).
+    expect(() => createSuperDocFonts({ exclude: ['Aptos'] })).toThrow(/does not bundle/);
+  });
+
+  it('accepts every family the toolbar advertises, including category fallbacks like Verdana', () => {
+    // Regression: the curatable list must mirror the resolver/offerings, not the manifest's narrower
+    // metric-clone `replaces` (which omits Verdana). A font shown in the toolbar must be curatable.
+    expect(() => createSuperDocFonts({ exclude: ['Verdana'] })).not.toThrow();
+    expect(() => createSuperDocFonts({ include: ['Verdana', 'Calibri'] })).not.toThrow();
+    expect(createSuperDocFonts({ exclude: ['Verdana'] }).bundled).toEqual({ exclude: ['Verdana'] });
+  });
+
+  it('accepts case- and quote-variant spellings of bundled families (matched normalized)', () => {
+    expect(() => createSuperDocFonts({ include: ['  calibri  ', '"Cambria"'] })).not.toThrow();
+  });
+});
diff --git a/packages/fonts/src/index.ts b/packages/fonts/src/index.ts
index 6d5af872d2..4e6323e0cc 100644
--- a/packages/fonts/src/index.ts
+++ b/packages/fonts/src/index.ts
@@ -1,5 +1,5 @@
 /**
- * `@superdoc/fonts` - the reviewed metric-compatible font substitutes SuperDoc renders for
+ * `@superdoc-dev/fonts` - the reviewed metric-compatible font substitutes SuperDoc renders for
  * proprietary Word fonts (Carlito for Calibri, Liberation Serif for Times New Roman, etc.).
  *
  * Optional: install it to make the bundled fallbacks load automatically in any bundler app, with
@@ -10,6 +10,7 @@
  * @beta This package is in preview; its surface may change before 1.0.
  */
 import { BUNDLED_FONT_ASSET_URLS } from './asset-urls';
+import { BUNDLED_FAMILY_NAMES } from './bundled-families';
 
 /**
  * The full filename -> bundler-emitted URL map for every bundled face. Most consumers use
@@ -41,10 +42,10 @@ export interface BundledFontAssetContext {
  * Pass as SuperDoc's `fonts.resolveAssetUrl` so the reviewed fallback pack loads from THIS
  * package's emitted assets, with no manual copy step and no `assetBaseUrl`:
  *
- *     import { resolveBundledFontAssetUrl } from '@superdoc/fonts';
+ *     import { resolveBundledFontAssetUrl } from '@superdoc-dev/fonts';
  *     new SuperDoc({ selector: '#editor', document, fonts: { resolveAssetUrl: resolveBundledFontAssetUrl } });
  *
- * Throws on an unknown file, which signals a version mismatch between `@superdoc/fonts` and
+ * Throws on an unknown file, which signals a version mismatch between `@superdoc-dev/fonts` and
  * the `superdoc` core manifest rather than silently degrading to the logical font name.
  *
  * @beta
@@ -53,9 +54,9 @@ export function resolveBundledFontAssetUrl(context: BundledFontAssetContext): st
   const url = BUNDLED_FONT_ASSET_URLS[context.file];
   if (!url) {
     throw new Error(
-      `[@superdoc/fonts] no bundled asset for "${context.file}". This pack ships ` +
+      `[@superdoc-dev/fonts] no bundled asset for "${context.file}". This pack ships ` +
         `${Object.keys(BUNDLED_FONT_ASSET_URLS).length} faces; the file is unknown, so ` +
-        `@superdoc/fonts and superdoc are likely version-mismatched. Align their versions.`,
+        `@superdoc-dev/fonts and superdoc are likely version-mismatched. Align their versions.`,
     );
   }
   return url;
@@ -70,3 +71,139 @@ export function resolveBundledFontAssetUrl(context: BundledFontAssetContext): st
 export const superdocFonts: { resolveAssetUrl: (context: BundledFontAssetContext) => string } = {
   resolveAssetUrl: resolveBundledFontAssetUrl,
 };
+
+/**
+ * Choose which bundled families SuperDoc advertises and renders, by LOGICAL Word family name
+ * (`"Calibri"`, never the physical `"Carlito"`).
+ *
+ * @beta
+ */
+export interface SuperDocFontsOptions {
+  /** Allow-list: ONLY these logical families are active, e.g. `['Calibri', 'Cambria']`. */
+  include?: string[];
+  /** Block-list: every bundled family EXCEPT these, e.g. `['Cooper Black', 'Brush Script MT']`. */
+  exclude?: string[];
+}
+
+/**
+ * The `fonts` config {@link createSuperDocFonts} returns: the bundled-asset resolver plus the
+ * curation. Structurally assignable to SuperDoc's `fonts` option.
+ *
+ * @beta
+ */
+export interface SuperDocFontsConfig {
+  resolveAssetUrl: (context: BundledFontAssetContext) => string;
+  bundled?: { include?: string[]; exclude?: string[] };
+}
+
+/**
+ * Build a curated `fonts` config: the bundled pack, narrowed to the families you choose.
+ *
+ *     import { createSuperDocFonts } from '@superdoc-dev/fonts';
+ *     new SuperDoc({
+ *       selector: '#editor',
+ *       document,
+ *       fonts: createSuperDocFonts({ exclude: ['Cooper Black', 'Brush Script MT'] }),
+ *     });
+ *
+ * Names are Word logical families. Pass neither `include` nor `exclude` for the full pack - that is
+ * exactly {@link superdocFonts}. Curation governs the BUNDLED pack only; your own licensed fonts stay
+ * separate (`fonts.families` / `fonts.map`).
+ *
+ * @beta
+ */
+export function createSuperDocFonts(options: SuperDocFontsOptions = {}): SuperDocFontsConfig {
+  const include = normalizeNameList(options.include, 'include');
+  const exclude = normalizeNameList(options.exclude, 'exclude');
+  // include and exclude are mutually exclusive intents; accepting both silently would hide which one
+  // wins. Reject at the API boundary (this runs in the consumer's setup code, so it fails fast and
+  // clearly) rather than picking one arbitrarily.
+  if (include && exclude) {
+    throw new Error(
+      '[@superdoc-dev/fonts] createSuperDocFonts: pass `include` OR `exclude`, not both. ' +
+        '`include` is an allow-list (only those families resolve and appear in the toolbar); ' +
+        '`exclude` keeps everything but the named families.',
+    );
+  }
+  // Reject names SuperDoc does not bundle. This runs in the consumer's setup code, so it fails fast
+  // and clearly - especially for `include`, where a typo would otherwise silently hide the fonts the
+  // consumer meant to keep. (Raw `fonts.bundled` set directly stays lenient and only warns.)
+  if (include) assertKnownFamilies(include, 'include');
+  if (exclude) assertKnownFamilies(exclude, 'exclude');
+  const config: SuperDocFontsConfig = { resolveAssetUrl: resolveBundledFontAssetUrl };
+  if (include) config.bundled = { include };
+  else if (exclude) config.bundled = { exclude };
+  return config;
+}
+
+/** Validate and clean a curation list: an array of non-empty strings, or omitted. Throws on misuse. */
+function normalizeNameList(value: string[] | undefined, field: 'include' | 'exclude'): string[] | undefined {
+  if (value == null) return undefined;
+  if (!Array.isArray(value)) {
+    throw new Error(`[@superdoc-dev/fonts] createSuperDocFonts: \`${field}\` must be an array of Word font names.`);
+  }
+  const names = value.map((name) => (typeof name === 'string' ? name.trim() : '')).filter(Boolean);
+  if (names.length !== value.length) {
+    throw new Error(
+      `[@superdoc-dev/fonts] createSuperDocFonts: \`${field}\` must contain only non-empty font name strings ` +
+        `(e.g. ["Calibri", "Cambria"]).`,
+    );
+  }
+  return names.length ? names : undefined;
+}
+
+/** Normalize a family name for matching: trim, strip surrounding quotes, lowercase. */
+function normalizeKey(name: string): string {
+  return name
+    .trim()
+    .replace(/^["']|["']$/g, '')
+    .toLowerCase();
+}
+
+const KNOWN_FAMILY_KEYS: ReadonlySet<string> = new Set(BUNDLED_FAMILY_NAMES.map(normalizeKey));
+
+/** Bounded Levenshtein distance between two short strings, for a "did you mean" hint on a typo. */
+function editDistance(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  if (Math.abs(m - n) > 2) return 3;
+  let prev = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i += 1) {
+    const curr = [i];
+    for (let j = 1; j <= n; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    prev = curr;
+  }
+  return prev[n];
+}
+
+/** The closest bundled family within edit distance 2, or null - so a typo gets a concrete suggestion. */
+function closestKnownFamily(name: string): string | null {
+  const key = normalizeKey(name);
+  let best: string | null = null;
+  let bestDist = 3;
+  for (const family of BUNDLED_FAMILY_NAMES) {
+    const dist = editDistance(key, normalizeKey(family));
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = family;
+    }
+  }
+  return best;
+}
+
+/** Throw on any curation name SuperDoc does not bundle, with a suggestion and the full valid list. */
+function assertKnownFamilies(names: readonly string[], field: 'include' | 'exclude'): void {
+  const unknown = names.filter((name) => !KNOWN_FAMILY_KEYS.has(normalizeKey(name)));
+  if (unknown.length === 0) return;
+  const hints = unknown.map((name) => {
+    const suggestion = closestKnownFamily(name);
+    return suggestion ? `"${name}" (did you mean "${suggestion}"?)` : `"${name}"`;
+  });
+  throw new Error(
+    `[@superdoc-dev/fonts] createSuperDocFonts: \`${field}\` names a font SuperDoc does not bundle: ${hints.join(', ')}. ` +
+      `Curate by Word family name. Bundled families: ${BUNDLED_FAMILY_NAMES.join(', ')}.`,
+  );
+}
diff --git a/packages/fonts/vitest.config.mjs b/packages/fonts/vitest.config.mjs
new file mode 100644
index 0000000000..a95488f542
--- /dev/null
+++ b/packages/fonts/vitest.config.mjs
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import baseConfig from '../../vitest.baseConfig';
+
+export default defineConfig({
+  ...baseConfig,
+  test: {
+    name: '@fonts',
+    environment: 'node',
+    globals: true,
+  },
+});
diff --git a/packages/super-editor/src/editors/v1/components/toolbar/constants.js b/packages/super-editor/src/editors/v1/components/toolbar/constants.js
index 623a8b673e..fc45894db5 100644
--- a/packages/super-editor/src/editors/v1/components/toolbar/constants.js
+++ b/packages/super-editor/src/editors/v1/components/toolbar/constants.js
@@ -1,24 +1,39 @@
-import { fontOfferingRenderStack, fontOfferingStack, getBuiltInToolbarFontOfferings } from '@superdoc/font-system';
+import {
+  BASELINE_BUNDLED,
+  fontOfferingRenderStack,
+  fontOfferingStack,
+  getBuiltInToolbarFontOfferings,
+} from '@superdoc/font-system';
 
 /**
- * Built-in toolbar font dropdown options, DERIVED from the shared font-offering registry
- * (`@superdoc/font-system`) instead of a hand-maintained list. Bundled clean defaults and explicit
- * qualified/category fallback choices are advertised; unbundled candidates are intentionally absent
- * from the static defaults.
+ * Build the built-in toolbar font dropdown options for a bundled-font activation, DERIVED from the
+ * shared font-offering registry (`@superdoc/font-system`). Without a configured pack this is the
+ * conservative baseline; with one it is the curated rich set.
  *
  * Per `FontConfig`: `label` is the Word-facing logical name (stored on the selection + active-state
  * match), `key` is the logical CSS stack, and the row preview renders in the physical clone that
  * actually paints (e.g. Carlito), so the dropdown looks like the rendered result.
+ *
+ * @param {import('@superdoc/font-system').BundledActivation} [activation]
+ */
+export function toolbarFontOptionsFor(activation = BASELINE_BUNDLED) {
+  return getBuiltInToolbarFontOfferings(activation).map((offering) => ({
+    label: offering.logicalFamily,
+    key: fontOfferingStack(offering),
+    fontWeight: 400,
+    props: {
+      style: { fontFamily: fontOfferingRenderStack(offering) },
+      'data-item': 'btn-fontFamily-option',
+    },
+  }));
+}
+
+/**
+ * Static baseline dropdown options (no pack configured). The fallback when a toolbar has no live
+ * activation to build from; the live path uses {@link composeToolbarFontOptions} with the document's
+ * activation so a configured pack shows the rich set.
  */
-export const TOOLBAR_FONTS = getBuiltInToolbarFontOfferings().map((offering) => ({
-  label: offering.logicalFamily,
-  key: fontOfferingStack(offering),
-  fontWeight: 400,
-  props: {
-    style: { fontFamily: fontOfferingRenderStack(offering) },
-    'data-item': 'btn-fontFamily-option',
-  },
-}));
+export const TOOLBAR_FONTS = toolbarFontOptionsFor(BASELINE_BUNDLED);
 
 function normalizeToolbarFamily(value) {
   return String(value ?? '')
@@ -34,25 +49,26 @@ function compareToolbarFontOptions(a, b) {
 
 /**
  * The single seam that composes the font dropdown options: it turns the active document's
- * {@link import('@superdoc/font-system').DocumentFontOption}s into toolbar font options and unions them
- * with the bundled defaults. The toolbar only asks for the result; it does not know how a font previews.
- *
- * - A consumer-provided `configFonts` list is returned UNCHANGED (custom toolbars own their list).
- * - With no document options, returns `undefined` so the caller keeps its fallback to {@link TOOLBAR_FONTS}.
- * - Otherwise: bundled defaults and document fonts are deduped by normalized logical family, then sorted
- *   alphabetically by the visible font name. `label`/`key` stay the pure logical family (active-state
- *   matching + the stored value), and the preview renders in `previewFamily`.
+ * {@link import('@superdoc/font-system').DocumentFontOption}s into toolbar font options, unions them
+ * with the activation-gated built-in base (baseline without a configured pack, the curated rich set
+ * with one), dedupes by normalized logical family, and sorts by visible name. A consumer-provided
+ * `configFonts` list is returned unchanged. Returns `undefined` only when the base is the baseline and
+ * there are no document fonts, so the caller can keep the equal static {@link TOOLBAR_FONTS} const.
  *
  * @param {ReadonlyArray<import('@superdoc/font-system').DocumentFontOption>} documentOptions
  * @param {Array} [configFonts] - the consumer's `fonts` config, if any
+ * @param {import('@superdoc/font-system').BundledActivation} [activation] - the document's bundled-font activation
  * @returns {Array|undefined}
  */
-export function composeToolbarFontOptions(documentOptions, configFonts) {
+export function composeToolbarFontOptions(documentOptions, configFonts, activation = BASELINE_BUNDLED) {
   if (configFonts) return configFonts;
-  if (!documentOptions?.length) return undefined;
-  const seen = new Set(TOOLBAR_FONTS.map((option) => normalizeToolbarFamily(option.label)));
-  const merged = [...TOOLBAR_FONTS];
-  for (const option of documentOptions) {
+  // Baseline base AND no document fonts is identical to the static TOOLBAR_FONTS const: let the
+  // caller keep that const instead of rebuilding an equal array.
+  if (!activation.packConfigured && !documentOptions?.length) return undefined;
+  const base = toolbarFontOptionsFor(activation);
+  const seen = new Set(base.map((option) => normalizeToolbarFamily(option.label)));
+  const merged = [...base];
+  for (const option of documentOptions ?? []) {
     const dedupeKey = normalizeToolbarFamily(option.logicalFamily);
     if (seen.has(dedupeKey)) continue;
     seen.add(dedupeKey);
@@ -66,7 +82,7 @@ export function composeToolbarFontOptions(documentOptions, configFonts) {
       },
     });
   }
-  return merged.length > TOOLBAR_FONTS.length ? merged.sort(compareToolbarFontOptions) : undefined;
+  return merged.sort(compareToolbarFontOptions);
 }
 
 export const TOOLBAR_FONT_SIZES = [
diff --git a/packages/super-editor/src/editors/v1/components/toolbar/constants.test.js b/packages/super-editor/src/editors/v1/components/toolbar/constants.test.js
index e44af345a1..622c5ab6d5 100644
--- a/packages/super-editor/src/editors/v1/components/toolbar/constants.test.js
+++ b/packages/super-editor/src/editors/v1/components/toolbar/constants.test.js
@@ -1,43 +1,68 @@
 import { describe, expect, it } from 'vitest';
-import { composeToolbarFontOptions, TOOLBAR_FONTS } from './constants';
+import { FULLY_ACTIVE_BUNDLED } from '@superdoc/font-system';
+import { composeToolbarFontOptions, TOOLBAR_FONTS, toolbarFontOptionsFor } from './constants';
 
-describe('TOOLBAR_FONTS (built-in font dropdown, derived from the font-offering registry)', () => {
-  it('advertises bundled defaults and selected bundled fallback choices, in alphabetical order', () => {
-    expect(TOOLBAR_FONTS.map((f) => f.label)).toEqual([
-      'Arial',
-      'Arial Black',
-      'Arial Narrow',
-      'Baskerville Old Face',
-      'Bookman Old Style',
-      'Brush Script MT',
+const RICH_LABELS = [
+  'Arial',
+  'Arial Black',
+  'Arial Narrow',
+  'Baskerville Old Face',
+  'Bookman Old Style',
+  'Brush Script MT',
+  'Calibri',
+  'Century',
+  'Century Gothic',
+  'Comic Sans MS',
+  'Cooper Black',
+  'Courier New',
+  'Garamond',
+  'Georgia',
+  'Gill Sans MT Condensed',
+  'Helvetica',
+  'Lucida Console',
+  'Segoe UI',
+  'Tahoma',
+  'Times New Roman',
+  'Trebuchet MS',
+  'Verdana',
+];
+
+describe('TOOLBAR_FONTS (static built-in font dropdown)', () => {
+  it('is the conservative no-pack baseline: one Word font per CSS generic', () => {
+    expect(TOOLBAR_FONTS.map((f) => f.label)).toEqual(['Arial', 'Courier New', 'Times New Roman']);
+  });
+
+  it('does not advertise the rich pack or unsupported fonts in the static default', () => {
+    const labels = new Set(TOOLBAR_FONTS.map((f) => f.label));
+    // Georgia is a second serif: a pack-enabled rich option, not part of the one-per-generic baseline.
+    for (const name of [
       'Calibri',
-      'Century',
-      'Century Gothic',
-      'Comic Sans MS',
-      'Cooper Black',
-      'Courier New',
-      'Garamond',
       'Georgia',
-      'Gill Sans MT Condensed',
-      'Helvetica',
-      'Lucida Console',
-      'Segoe UI',
-      'Tahoma',
-      'Times New Roman',
-      'Trebuchet MS',
+      'Cooper Black',
       'Verdana',
-    ]);
+      'Aptos',
+      'Cambria',
+      'Calibri Light',
+      'Arial MT',
+    ]) {
+      expect(labels.has(name)).toBe(false);
+    }
   });
 
-  it('does not leak non-advertised fonts into the default dropdown', () => {
-    const labels = new Set(TOOLBAR_FONTS.map((f) => f.label));
-    for (const name of ['Aptos', 'Cambria', 'Calibri Light', 'Century Schoolbook', 'Arial MT', 'Courier', 'Times']) {
-      expect(labels.has(name)).toBe(false);
+  it('honors the FontConfig contract: label equals the first family in key', () => {
+    for (const f of TOOLBAR_FONTS) {
+      expect(f.key.split(',')[0].trim()).toBe(f.label);
     }
   });
+});
+
+describe('toolbarFontOptionsFor (the configured rich set)', () => {
+  it('returns the full advertised set when the pack is active', () => {
+    expect(toolbarFontOptionsFor(FULLY_ACTIVE_BUNDLED).map((f) => f.label)).toEqual(RICH_LABELS);
+  });
 
   it('builds a FontConfig: logical label + logical key + physical-clone preview', () => {
-    const calibri = TOOLBAR_FONTS.find((f) => f.label === 'Calibri');
+    const calibri = toolbarFontOptionsFor(FULLY_ACTIVE_BUNDLED).find((f) => f.label === 'Calibri');
     expect(calibri).toMatchObject({
       label: 'Calibri', // applied to the selection + active-state match (Word-facing name)
       key: 'Calibri, sans-serif', // logical CSS stack (option identity)
@@ -48,15 +73,9 @@ describe('TOOLBAR_FONTS (built-in font dropdown, derived from the font-offering
       },
     });
   });
-
-  it('honors the FontConfig contract: label equals the first family in key', () => {
-    for (const f of TOOLBAR_FONTS) {
-      expect(f.key.split(',')[0].trim()).toBe(f.label);
-    }
-  });
 });
 
-describe('composeToolbarFontOptions (document fonts unioned with the bundled defaults)', () => {
+describe('composeToolbarFontOptions (document fonts unioned with the built-in set)', () => {
   const doc = (logicalFamily, previewFamily) => ({
     logicalFamily,
     previewFamily: previewFamily ?? logicalFamily,
@@ -67,15 +86,33 @@ describe('composeToolbarFontOptions (document fonts unioned with the bundled def
     expect(composeToolbarFontOptions([doc('Aptos')], custom)).toBe(custom);
   });
 
-  it('returns undefined with no document fonts, so the caller keeps the bundled defaults', () => {
+  it('returns undefined with baseline base AND no document fonts, so the caller keeps the static const', () => {
     expect(composeToolbarFontOptions([], undefined)).toBeUndefined();
     expect(composeToolbarFontOptions(undefined, undefined)).toBeUndefined();
   });
 
-  it('combines defaults and document fonts alphabetically, deduping one already in the defaults', () => {
+  it('with no pack configured: baseline base unioned with document fonts, alphabetical', () => {
+    const options = composeToolbarFontOptions(
+      [doc('Calibri', 'Carlito'), doc('Bangla MN'), doc('Aptos'), doc('Apple Chancery')],
+      undefined,
+    );
+    expect(options.map((o) => o.label)).toEqual([
+      'Apple Chancery',
+      'Aptos',
+      'Arial',
+      'Bangla MN',
+      'Calibri',
+      'Courier New',
+      'Times New Roman',
+    ]);
+    expect(options.filter((o) => o.label === 'Calibri')).toHaveLength(1);
+  });
+
+  it('with the pack configured: the full set unioned with document fonts, deduping shared names', () => {
     const options = composeToolbarFontOptions(
       [doc('Calibri', 'Carlito'), doc('Bangla MN'), doc('Aptos'), doc('Apple Chancery')],
       undefined,
+      FULLY_ACTIVE_BUNDLED,
     );
     expect(options.map((o) => o.label)).toEqual([
       'Apple Chancery',
diff --git a/packages/super-editor/src/editors/v1/components/toolbar/super-toolbar.js b/packages/super-editor/src/editors/v1/components/toolbar/super-toolbar.js
index 7c03677c1c..7ce01386e8 100644
--- a/packages/super-editor/src/editors/v1/components/toolbar/super-toolbar.js
+++ b/packages/super-editor/src/editors/v1/components/toolbar/super-toolbar.js
@@ -5,6 +5,7 @@ import { createHeadlessToolbar } from '../../../../headless-toolbar/create-headl
 import { getActiveFormatting } from '@core/helpers/getActiveFormatting.js';
 import { findParentNode } from '@helpers/index.js';
 import { vClickOutside } from '@superdoc/common';
+import { deriveBundledActivation } from '@superdoc/font-system';
 import Toolbar from './Toolbar.vue';
 import { toolbarIcons } from './toolbarIcons.js';
 import { toolbarTexts } from './toolbarTexts.js';
@@ -546,7 +547,11 @@ export class SuperToolbar extends EventEmitter {
    * @returns {Array|undefined} the toolbar font options, or undefined to fall back to the bundled defaults
    */
   #resolveToolbarFonts(configFonts) {
-    return composeToolbarFontOptions(this.superdoc?.fonts?.getDocumentFontOptions?.() ?? [], configFonts);
+    return composeToolbarFontOptions(
+      this.superdoc?.fonts?.getDocumentFontOptions?.() ?? [],
+      configFonts,
+      deriveBundledActivation(this.superdoc?.config?.fonts),
+    );
   }
 
   /**
diff --git a/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.test.ts b/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.test.ts
index 0287783117..a4c6b1d347 100644
--- a/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.test.ts
+++ b/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.test.ts
@@ -205,7 +205,9 @@ describe('DocumentFontController', () => {
 
     controller.map({ Georgia: 'Tinos', Verdana: 'Some Runtime Font' });
     controller.reset();
-    controller.applyInitialConfig({ map: { Georgia: 'Gelasio' } });
+    // assetBaseUrl marks the pack configured, so bundled substitutes stay active and Verdana reverts
+    // to its bundled default (Noto Sans) - proving reset cleared the stale runtime Verdana mapping.
+    controller.applyInitialConfig({ assetBaseUrl: '/fonts/', map: { Georgia: 'Gelasio' } });
     flushMicrotasks();
 
     expect(resolver.resolvePrimaryPhysicalFamily('Georgia')).toBe('Gelasio');
diff --git a/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.ts b/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.ts
index f4de192b55..9f07836d81 100644
--- a/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.ts
+++ b/packages/super-editor/src/editors/v1/core/presentation-editor/fonts/DocumentFontController.ts
@@ -1,4 +1,9 @@
-import type { FontFaceRequest, FontResolver } from '@superdoc/font-system';
+import {
+  deriveBundledActivation,
+  warnUnknownBundledSelection,
+  type FontFaceRequest,
+  type FontResolver,
+} from '@superdoc/font-system';
 import type { FontFamilyConfig, FontsConfig } from '../../types/EditorConfig.js';
 import type { FontReadinessGate } from './FontReadinessGate.js';
 
@@ -169,8 +174,14 @@ export class DocumentFontController {
    * registration cannot move the resolver signature that would otherwise bust them), so the first
    * measure cannot reuse a stale fallback width another editor instance left in the global cache.
    */
-  applyInitialConfig(config: Pick<FontsConfig, 'families' | 'map'> | null | undefined): void {
+  applyInitialConfig(config: FontsConfig | null | undefined): void {
     this.#cancelPendingRuntimeReflow();
+    // Surface curation typos / non-bundled names (and include+exclude both) once, at config time.
+    warnUnknownBundledSelection(config?.bundled);
+    // Derive activation even with NO config: an npm app that wired no pack defaults to the safe
+    // baseline (no substitution, no stray .woff2 fetches), while the CDN build - which marks the pack
+    // present - stays rich. Set before families/map so the first resolution already reflects it.
+    this.#resolver.setActivation(deriveBundledActivation(config));
     if (!config) return;
     const registered = this.#registerFamilies(config.families);
     this.#applyMappings(config.map);
diff --git a/packages/super-editor/src/editors/v1/core/types/EditorConfig.ts b/packages/super-editor/src/editors/v1/core/types/EditorConfig.ts
index fcc5c46922..1dadd6427b 100644
--- a/packages/super-editor/src/editors/v1/core/types/EditorConfig.ts
+++ b/packages/super-editor/src/editors/v1/core/types/EditorConfig.ts
@@ -13,7 +13,7 @@ import type {
   CommentLocationsPayload,
   ListDefinitionsPayload,
 } from './EditorEvents.js';
-import type { FontAssetUrlResolver } from '@superdoc/font-system';
+import type { BundledFontSelection, FontAssetUrlResolver } from '@superdoc/font-system';
 
 /**
  * One physical font face to register from a URL source.
@@ -57,6 +57,14 @@ export interface FontsConfig {
    * Synchronous (font resolution stays deterministic). Takes precedence over `assetBaseUrl`.
    */
   resolveAssetUrl?: FontAssetUrlResolver;
+  /**
+   * Curate which bundled families this document advertises and substitutes to, by LOGICAL Word name
+   * (e.g. `"Calibri"`). Applies only when the pack is configured; it narrows the rich set, it does
+   * not enable it. Prefer setting this with `createSuperDocFonts({ include / exclude })` from
+   * `@superdoc-dev/fonts` rather than by hand. Does not affect customer fonts ({@link families} /
+   * {@link map}), which are always honored.
+   */
+  bundled?: BundledFontSelection;
 }
 import type { ProseMirrorJSON } from './EditorTypes.js';
 
diff --git a/packages/super-editor/src/headless-toolbar/constants.test.ts b/packages/super-editor/src/headless-toolbar/constants.test.ts
index 21c6d104e8..d45bd51817 100644
--- a/packages/super-editor/src/headless-toolbar/constants.test.ts
+++ b/packages/super-editor/src/headless-toolbar/constants.test.ts
@@ -2,41 +2,26 @@ import { describe, expect, it } from 'vitest';
 import { DEFAULT_FONT_FAMILY_OPTIONS } from './constants';
 
 describe('DEFAULT_FONT_FAMILY_OPTIONS (headless default font options, derived from the font-offering registry)', () => {
-  it('advertises bundled defaults and selected bundled fallback choices (logical name + logical stack)', () => {
+  it('is the conservative no-pack baseline: one Word font per CSS generic', () => {
     expect(DEFAULT_FONT_FAMILY_OPTIONS).toEqual([
       { label: 'Arial', value: 'Arial, sans-serif' },
-      { label: 'Arial Black', value: 'Arial Black, sans-serif' },
-      { label: 'Arial Narrow', value: 'Arial Narrow, sans-serif' },
-      { label: 'Baskerville Old Face', value: 'Baskerville Old Face, serif' },
-      { label: 'Bookman Old Style', value: 'Bookman Old Style, serif' },
-      { label: 'Brush Script MT', value: 'Brush Script MT, serif' },
-      { label: 'Calibri', value: 'Calibri, sans-serif' },
-      { label: 'Century', value: 'Century, serif' },
-      { label: 'Century Gothic', value: 'Century Gothic, sans-serif' },
-      { label: 'Comic Sans MS', value: 'Comic Sans MS, sans-serif' },
-      { label: 'Cooper Black', value: 'Cooper Black, serif' },
       { label: 'Courier New', value: 'Courier New, monospace' },
-      { label: 'Garamond', value: 'Garamond, serif' },
-      { label: 'Georgia', value: 'Georgia, serif' },
-      { label: 'Gill Sans MT Condensed', value: 'Gill Sans MT Condensed, sans-serif' },
-      { label: 'Helvetica', value: 'Helvetica, sans-serif' },
-      { label: 'Lucida Console', value: 'Lucida Console, monospace' },
-      { label: 'Segoe UI', value: 'Segoe UI, sans-serif' },
-      { label: 'Tahoma', value: 'Tahoma, sans-serif' },
       { label: 'Times New Roman', value: 'Times New Roman, serif' },
-      { label: 'Trebuchet MS', value: 'Trebuchet MS, sans-serif' },
-      { label: 'Verdana', value: 'Verdana, sans-serif' },
     ]);
   });
 
-  it('drops non-advertised fonts from defaults', () => {
+  it('does not advertise the rich pack or unsupported fonts in the static default', () => {
     const labels = new Set(DEFAULT_FONT_FAMILY_OPTIONS.map((o) => o.label));
+    // Rich-pack families appear only once the pack is configured (built per instance). Georgia is a
+    // second serif, so it is a pack-enabled option, not part of the one-per-generic baseline.
+    expect(labels.has('Calibri')).toBe(false);
+    expect(labels.has('Georgia')).toBe(false);
+    expect(labels.has('Cooper Black')).toBe(false);
+    expect(labels.has('Verdana')).toBe(false);
+    // Never-default fonts stay absent regardless.
     expect(labels.has('Aptos')).toBe(false);
     expect(labels.has('Cambria')).toBe(false);
     expect(labels.has('Calibri Light')).toBe(false);
-    expect(labels.has('Century Schoolbook')).toBe(false);
     expect(labels.has('Arial MT')).toBe(false);
-    expect(labels.has('Courier')).toBe(false);
-    expect(labels.has('Times')).toBe(false);
   });
 });
diff --git a/packages/super-editor/src/headless-toolbar/constants.ts b/packages/super-editor/src/headless-toolbar/constants.ts
index e0cb9cce01..df65e6e917 100644
--- a/packages/super-editor/src/headless-toolbar/constants.ts
+++ b/packages/super-editor/src/headless-toolbar/constants.ts
@@ -63,10 +63,12 @@ export const DEFAULT_FONT_SIZE_OPTIONS = [
 
 /**
  * Default headless-toolbar font options, DERIVED from the shared font-offering registry
- * (`@superdoc/font-system`) instead of a hand-maintained list. Bundled clean defaults and explicit
- * qualified choices are advertised; customer-supplied and category fallback rows stay absent.
- * `label` is the Word-facing logical name (stored/exported); `value` is the logical CSS stack applied
- * to the run.
+ * (`@superdoc/font-system`). This static const is the conservative NO-PACK baseline - one Word font
+ * per CSS generic (Arial, Times New Roman, Courier New) - the floor for a headless toolbar with no
+ * runtime font config.
+ * A headless consumer that wires the bundled pack and wants the curated rich set builds its options
+ * per instance from `getDefaultFontFamilyOptions(deriveBundledActivation(fontsConfig))`. `label` is
+ * the Word-facing logical name (stored/exported); `value` is the logical CSS stack applied to the run.
  */
 export const DEFAULT_FONT_FAMILY_OPTIONS = getDefaultFontFamilyOptions();
 
diff --git a/packages/super-editor/src/ui/create-super-doc-ui.test.ts b/packages/super-editor/src/ui/create-super-doc-ui.test.ts
index f7ea11ea7d..de7b9658d3 100644
--- a/packages/super-editor/src/ui/create-super-doc-ui.test.ts
+++ b/packages/super-editor/src/ui/create-super-doc-ui.test.ts
@@ -14,6 +14,12 @@ function makeSuperdocStub(
     documentMode?: 'editing' | 'suggesting' | 'viewing';
     selection?: { empty: boolean; text?: string };
     documentFontOptions?: Array<{ logicalFamily: string; previewFamily: string }>;
+    /** The `fonts` config the toolbar derives bundled activation from. Omit for the no-pack baseline. */
+    fontsConfig?: {
+      resolveAssetUrl?: unknown;
+      assetBaseUrl?: string;
+      bundled?: { include?: string[]; exclude?: string[] };
+    };
   } = {},
 ) {
   const editorListeners = new Map<string, Set<(...args: unknown[]) => void>>();
@@ -53,7 +59,7 @@ function makeSuperdocStub(
     superdocListenerCount(event: string): number;
   } = {
     activeEditor: editor,
-    config: { documentMode: initial.documentMode ?? 'editing' },
+    config: { documentMode: initial.documentMode ?? 'editing', fonts: initial.fontsConfig },
     fonts: {
       getDocumentFontOptions: vi.fn(() => documentFontOptions),
     },
@@ -136,8 +142,28 @@ describe('createSuperDocUI', () => {
     expect(slice.get()).toBe('editing');
   });
 
-  it('exposes final font-family options for custom UI', () => {
+  it('defaults to the baseline font set when no pack is configured', () => {
+    const superdoc = makeSuperdocStub({
+      documentFontOptions: [
+        { logicalFamily: 'Aptos', previewFamily: 'Aptos' },
+        { logicalFamily: 'Calibri', previewFamily: 'Carlito' },
+      ],
+    });
+    const ui = createSuperDocUI({ superdoc });
+    teardown.push(() => ui.destroy());
+    // No pack: the one-per-generic baseline plus the document's own fonts (Calibri is a document font).
+    expect(ui.fonts.getOptions().map((o) => o.label)).toEqual([
+      'Aptos',
+      'Arial',
+      'Calibri',
+      'Courier New',
+      'Times New Roman',
+    ]);
+  });
+
+  it('exposes final font-family options for custom UI when the pack is configured', () => {
     const superdoc = makeSuperdocStub({
+      fontsConfig: { assetBaseUrl: '/fonts/' },
       documentFontOptions: [
         { logicalFamily: 'Aptos', previewFamily: 'Aptos' },
         { logicalFamily: 'Bangla MN', previewFamily: 'Bangla MN' },
@@ -201,7 +227,8 @@ describe('createSuperDocUI', () => {
   });
 
   it('refreshes ui.fonts when fonts-changed fires', async () => {
-    const superdoc = makeSuperdocStub();
+    // Configured pack so the snapshot is the full set (the refresh behavior is the point here).
+    const superdoc = makeSuperdocStub({ fontsConfig: { assetBaseUrl: '/fonts/' } });
     const ui = createSuperDocUI({ superdoc });
     teardown.push(() => ui.destroy());
 
diff --git a/packages/super-editor/src/ui/create-super-doc-ui.ts b/packages/super-editor/src/ui/create-super-doc-ui.ts
index 067fab5e97..def6ffc320 100644
--- a/packages/super-editor/src/ui/create-super-doc-ui.ts
+++ b/packages/super-editor/src/ui/create-super-doc-ui.ts
@@ -22,7 +22,7 @@ import type {
 } from '@superdoc/document-api';
 import { composeAuthorColorResolver } from '@superdoc/contracts';
 import type { TrackChangeAuthorColorResolver } from '@superdoc/contracts';
-import { buildFontFamilyOptions } from '@superdoc/font-system';
+import { buildFontFamilyOptions, deriveBundledActivation } from '@superdoc/font-system';
 import type { FontFamilyOption } from '@superdoc/font-system';
 import { collectEntityHitsFromChain } from './entity-at.js';
 import { shallowEqual } from './equality.js';
@@ -599,16 +599,20 @@ export function createSuperDocUI(options: SuperDocUIOptions): SuperDocUI {
   };
   refreshContentControlsListCache();
 
-  let fontOptionsCache: FontFamilyOption[] = buildFontFamilyOptions([]);
+  // The document's bundled-font activation, derived from the same `fonts` config the editor used
+  // (a pure function of config + the CDN pack flag, so it matches the editor's resolver). Gates the
+  // built-in picker rows: baseline without a pack, the curated rich set with one.
+  const bundledActivation = () => deriveBundledActivation(superdoc.config?.fonts);
+  let fontOptionsCache: FontFamilyOption[] = buildFontFamilyOptions([], bundledActivation());
   const fontOptionsSignatureFor = (options: readonly FontFamilyOption[]) =>
     JSON.stringify(options.map((option) => [option.label, option.value, option.previewFamily]));
   let fontOptionsSignature = fontOptionsSignatureFor(fontOptionsCache);
   const refreshFontOptionsCache = () => {
     let next: FontFamilyOption[];
     try {
-      next = buildFontFamilyOptions(superdoc.fonts?.getDocumentFontOptions?.() ?? []);
+      next = buildFontFamilyOptions(superdoc.fonts?.getDocumentFontOptions?.() ?? [], bundledActivation());
     } catch {
-      next = buildFontFamilyOptions([]);
+      next = buildFontFamilyOptions([], bundledActivation());
     }
     const signature = fontOptionsSignatureFor(next);
     if (signature === fontOptionsSignature) return false;
diff --git a/packages/super-editor/src/ui/react/hooks.test.tsx b/packages/super-editor/src/ui/react/hooks.test.tsx
index faba8450f1..36e54ed1f3 100644
--- a/packages/super-editor/src/ui/react/hooks.test.tsx
+++ b/packages/super-editor/src/ui/react/hooks.test.tsx
@@ -16,6 +16,11 @@ function makeSuperdocStub(
   overrides: {
     selectionInfo?: unknown;
     documentFontOptions?: Array<{ logicalFamily: string; previewFamily: string }>;
+    fontsConfig?: {
+      resolveAssetUrl?: unknown;
+      assetBaseUrl?: string;
+      bundled?: { include?: string[]; exclude?: string[] };
+    };
   } = {},
 ) {
   const editorListeners = new Map<string, Set<(...args: unknown[]) => void>>();
@@ -51,7 +56,7 @@ function makeSuperdocStub(
 
   return {
     activeEditor: editor,
-    config: { documentMode: 'editing' as const },
+    config: { documentMode: 'editing' as const, fonts: overrides.fontsConfig },
     on: vi.fn((event: string, handler: (...args: unknown[]) => void) => {
       if (!superdocListeners.has(event)) superdocListeners.set(event, new Set());
       superdocListeners.get(event)!.add(handler);
@@ -157,7 +162,7 @@ describe('domain hooks', () => {
     expect(toolbar).toEqual({ context: null, commands: {} });
   });
 
-  it('useSuperDocFontOptions returns defaults plus active document fonts', () => {
+  it('useSuperDocFontOptions returns the configured set plus active document fonts', () => {
     let options: ReturnType<typeof useSuperDocFontOptions> | undefined;
     let setSuperDoc: ReturnType<typeof useSetSuperDoc> | undefined;
 
@@ -178,6 +183,7 @@ describe('domain hooks', () => {
     act(() => {
       setSuperDoc!(
         makeSuperdocStub({
+          fontsConfig: { assetBaseUrl: '/fonts/' },
           documentFontOptions: [{ logicalFamily: 'Aptos', previewFamily: 'Aptos' }],
         }),
       );
diff --git a/packages/super-editor/src/ui/types.ts b/packages/super-editor/src/ui/types.ts
index d1f85f9b36..95873faeb8 100644
--- a/packages/super-editor/src/ui/types.ts
+++ b/packages/super-editor/src/ui/types.ts
@@ -81,6 +81,13 @@ export interface SuperDocLike {
         authorColors?: import('@superdoc/contracts').AuthorColorsConfig;
       };
     };
+    /**
+     * The `fonts` config (the same object passed to `new SuperDoc({ fonts })`). The toolbar derives
+     * the document's bundled-font activation from it via `deriveBundledActivation`, so the picker
+     * advertises the conservative baseline by default and the curated rich set only once the pack is wired.
+     * Loosely typed (structural) so test stubs need not model the full `FontsConfig`.
+     */
+    fonts?: import('@superdoc/font-system').FontAssetConfigLike;
   };
   /**
    * Optional setter for documentMode. Consumed by `ui.document.setMode`
diff --git a/packages/superdoc/src/cdn-entry.js b/packages/superdoc/src/cdn-entry.js
index 053c4a8bd7..055b5ab943 100644
--- a/packages/superdoc/src/cdn-entry.js
+++ b/packages/superdoc/src/cdn-entry.js
@@ -5,11 +5,15 @@
 // from Quill / Chart.js.
 
 import { SuperDoc } from './core/SuperDoc.js';
-import { setBundledFontAssetBase } from '@superdoc/font-system';
+import { markBundledPackPresent, setBundledFontAssetBase } from '@superdoc/font-system';
 import * as namespace from './index.js';
 
-// Default the bundled-font asset base to `./fonts/` relative to THIS script - the CDN
-// package layout ships `superdoc.min.js` next to `fonts/*.woff2`. `document.currentScript`
+// The CDN package layout ships `fonts/*.woff2` next to `superdoc.min.js`, so the bundled pack is
+// served by default - mark it present so the toolbar and resolver light up the rich pack without
+// per-instance `fonts` config (npm consumers signal it via `fonts.resolveAssetUrl` / `assetBaseUrl`).
+markBundledPackPresent();
+
+// Default the bundled-font asset base to `./fonts/` relative to THIS script. `document.currentScript`
 // is valid while the script is executing (this top-level runs then), and null later in
 // callbacks, so we must capture it here, not inside font loading. Consumer config
 // (`fonts.assetBaseUrl` / `fonts.resolveAssetUrl`) takes precedence over this default.
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5e832bd71a..a9948a882f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2207,7 +2207,7 @@ importers:
       '@angular/platform-browser-dynamic':
         specifier: ^21.1.4
         version: 21.2.6(@angular/common@21.2.6(@angular/core@21.2.6(@angular/compiler@21.2.6)(rxjs@7.8.2)(zone.js@0.16.1))(rxjs@7.8.2))(@angular/compiler@21.2.6)(@angular/core@21.2.6(@angular/compiler@21.2.6)(rxjs@7.8.2)(zone.js@0.16.1))(@angular/platform-browser@21.2.6(@angular/common@21.2.6(@angular/core@21.2.6(@angular/compiler@21.2.6)(rxjs@7.8.2)(zone.js@0.16.1))(rxjs@7.8.2))(@angular/core@21.2.6(@angular/compiler@21.2.6)(rxjs@7.8.2)(zone.js@0.16.1)))
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       rxjs:
@@ -2258,7 +2258,7 @@ importers:
       '@superdoc-dev/react':
         specifier: workspace:*
         version: link:../../../packages/react
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       next:
@@ -2298,7 +2298,7 @@ importers:
 
   examples/getting-started/nuxt:
     dependencies:
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       nuxt:
@@ -2316,7 +2316,7 @@ importers:
       '@superdoc-dev/react':
         specifier: workspace:*
         version: link:../../../packages/react
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       react:
@@ -2344,7 +2344,7 @@ importers:
 
   examples/getting-started/solid:
     dependencies:
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       solid-js:
@@ -2366,7 +2366,7 @@ importers:
 
   examples/getting-started/vanilla:
     dependencies:
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       superdoc:
@@ -2379,7 +2379,7 @@ importers:
 
   examples/getting-started/vue:
     dependencies:
-      '@superdoc/fonts':
+      '@superdoc-dev/fonts':
         specifier: workspace:*
         version: link:../../../packages/fonts
       superdoc:
diff --git a/scripts/generate-all.mjs b/scripts/generate-all.mjs
index a46e354e95..f937c8206e 100644
--- a/scripts/generate-all.mjs
+++ b/scripts/generate-all.mjs
@@ -3,11 +3,12 @@
 /**
  * Full generation DAG — produces all derived artifacts from source-of-truth inputs.
  *
- * Phases (sequential — each depends on the previous):
+ * Phases (run in order; 1-4 are sequential, 5 is independent):
  *   1. docapi:sync             → packages/document-api/generated/** + apps/docs/document-api/reference/**
  *   2. cli:export-sdk-contract → apps/cli/generated/sdk-contract.json
  *   3. docs:sync-engine        → SDK overview operations table in apps/docs/document-engine/sdks.mdx
  *   4. sdk codegen             → packages/sdk/langs/{node,python}/…/generated/** + packages/sdk/tools/*.json
+ *   5. @superdoc-dev/fonts generate → packages/fonts/src/{asset-urls,bundled-families}.ts (from font-system)
  *
  * Before generation, gitignored output directories are cleaned to prevent stale file accumulation.
  * apps/docs/document-api/reference/ is NOT cleaned here — it stays committed (Mintlify deploys from git)
@@ -98,6 +99,12 @@ async function main() {
   console.log('\n--- Phase 4: sdk codegen ---');
   await run('node', [path.join(REPO_ROOT, 'packages/sdk/codegen/src/generate-all.mjs')]);
 
+  // Phase 5: @superdoc-dev/fonts derived sources: bundled asset URLs (from the asset dir) plus curatable
+  // family names (from font-system offerings). Kept out of the package's build/prepare lifecycle so a
+  // standalone install never needs tsx; regenerated here, in the workspace pipeline.
+  console.log('\n--- Phase 5: @superdoc-dev/fonts generate ---');
+  await run('pnpm', ['--filter', '@superdoc-dev/fonts', 'generate']);
+
   console.log('\ngenerate:all complete.');
 }
 
diff --git a/shared/font-system/src/activation.test.ts b/shared/font-system/src/activation.test.ts
new file mode 100644
index 0000000000..ee0f0bf693
--- /dev/null
+++ b/shared/font-system/src/activation.test.ts
@@ -0,0 +1,121 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { BASELINE_BUNDLED, FULLY_ACTIVE_BUNDLED, createBundledActivation, deriveBundledActivation } from './activation';
+import { __resetBundledPackPresent, isBundledPackPresent, markBundledPackPresent } from './bundled';
+
+describe('createBundledActivation', () => {
+  it('no pack configured: nothing active, with a distinct non-empty signature', () => {
+    const a = createBundledActivation({ packConfigured: false });
+    expect(a).toBe(BASELINE_BUNDLED);
+    expect(a.packConfigured).toBe(false);
+    expect(a.isActive('Calibri')).toBe(false);
+    expect(a.isActive('Arial')).toBe(false);
+    // Non-empty so a no-pack document never shares a full-pack document's measure cache.
+    expect(a.signature).not.toBe('');
+  });
+
+  it('pack configured with no curation: fully active, empty signature (preserves cache sharing)', () => {
+    const a = createBundledActivation({ packConfigured: true });
+    expect(a).toBe(FULLY_ACTIVE_BUNDLED);
+    expect(a.packConfigured).toBe(true);
+    expect(a.isActive('Calibri')).toBe(true);
+    expect(a.signature).toBe('');
+  });
+
+  it('include is an allow-list, matched case-insensitively after quote-strip', () => {
+    const a = createBundledActivation({ packConfigured: true, include: ['Calibri', 'Cambria'] });
+    expect(a.isActive('Calibri')).toBe(true);
+    expect(a.isActive('"calibri"')).toBe(true);
+    expect(a.isActive('Cambria')).toBe(true);
+    expect(a.isActive('Arial')).toBe(false);
+    expect(a.signature).not.toBe('');
+  });
+
+  it('exclude keeps every family but the listed ones', () => {
+    const a = createBundledActivation({ packConfigured: true, exclude: ['Cooper Black'] });
+    expect(a.isActive('Cooper Black')).toBe(false);
+    expect(a.isActive('cooper black')).toBe(false);
+    expect(a.isActive('Calibri')).toBe(true);
+  });
+
+  it('include wins over exclude when both are given', () => {
+    const a = createBundledActivation({ packConfigured: true, include: ['Calibri'], exclude: ['Calibri'] });
+    expect(a.isActive('Calibri')).toBe(true);
+    expect(a.isActive('Arial')).toBe(false);
+  });
+
+  it('include/exclude with no usable entries are ignored (no accidental empty toolbar)', () => {
+    expect(createBundledActivation({ packConfigured: true, include: [] })).toBe(FULLY_ACTIVE_BUNDLED);
+    expect(createBundledActivation({ packConfigured: true, exclude: ['', '  '] })).toBe(FULLY_ACTIVE_BUNDLED);
+  });
+
+  it('curation is moot with no pack: still baseline', () => {
+    expect(createBundledActivation({ packConfigured: false, include: ['Calibri'] })).toBe(BASELINE_BUNDLED);
+  });
+
+  it('signatures distinguish baseline / full / curated, and equal curation gives an equal signature', () => {
+    const baseline = createBundledActivation({ packConfigured: false }).signature;
+    const full = createBundledActivation({ packConfigured: true }).signature;
+    const inc = createBundledActivation({ packConfigured: true, include: ['Calibri'] }).signature;
+    const exc = createBundledActivation({ packConfigured: true, exclude: ['Calibri'] }).signature;
+    expect(new Set([baseline, full, inc, exc]).size).toBe(4);
+    // Order-independent and de-duplicated, so the same curation is the same signature.
+    expect(
+      createBundledActivation({ packConfigured: true, include: ['Cambria', 'Calibri', 'Calibri'] }).signature,
+    ).toBe(createBundledActivation({ packConfigured: true, include: ['Calibri', 'Cambria'] }).signature);
+  });
+
+  it('ignores malformed (non-array) curation instead of crashing - falls back to the full pack', () => {
+    // Raw JS config can hand-write a bare string; deriving activation must never throw at init.
+    const a = createBundledActivation({ packConfigured: true, include: 'Calibri' as unknown as string[] });
+    expect(a).toBe(FULLY_ACTIVE_BUNDLED);
+    expect(a.isActive('Calibri')).toBe(true);
+  });
+
+  it('drops non-string entries from a curation array', () => {
+    const a = createBundledActivation({
+      packConfigured: true,
+      include: ['Calibri', 123, null] as unknown as string[],
+    });
+    expect(a.isActive('Calibri')).toBe(true);
+    expect(a.isActive('Cambria')).toBe(false);
+  });
+});
+
+describe('deriveBundledActivation', () => {
+  beforeEach(() => __resetBundledPackPresent());
+  afterEach(() => __resetBundledPackPresent());
+
+  it('npm with no config and no CDN flag: baseline', () => {
+    expect(isBundledPackPresent()).toBe(false);
+    expect(deriveBundledActivation(undefined)).toBe(BASELINE_BUNDLED);
+    expect(deriveBundledActivation(null)).toBe(BASELINE_BUNDLED);
+    expect(deriveBundledActivation({})).toBe(BASELINE_BUNDLED);
+  });
+
+  it('resolveAssetUrl or assetBaseUrl marks the pack configured (rich)', () => {
+    expect(deriveBundledActivation({ resolveAssetUrl: () => 'x' }).packConfigured).toBe(true);
+    expect(deriveBundledActivation({ assetBaseUrl: '/fonts/' }).packConfigured).toBe(true);
+  });
+
+  it('passes bundled curation through', () => {
+    const a = deriveBundledActivation({ assetBaseUrl: '/fonts/', bundled: { exclude: ['Cooper Black'] } });
+    expect(a.packConfigured).toBe(true);
+    expect(a.isActive('Cooper Black')).toBe(false);
+    expect(a.isActive('Calibri')).toBe(true);
+  });
+
+  it('CDN: markBundledPackPresent makes a no-config document rich', () => {
+    markBundledPackPresent();
+    expect(deriveBundledActivation(undefined).packConfigured).toBe(true);
+    expect(deriveBundledActivation({}).isActive('Calibri')).toBe(true);
+  });
+
+  it('does not crash on malformed raw bundled config (a string instead of an array)', () => {
+    const a = deriveBundledActivation({
+      assetBaseUrl: '/fonts/',
+      bundled: { include: 'Calibri' as unknown as string[] },
+    });
+    expect(a.packConfigured).toBe(true);
+    expect(a.isActive('Calibri')).toBe(true); // malformed curation ignored -> full pack
+  });
+});
diff --git a/shared/font-system/src/activation.ts b/shared/font-system/src/activation.ts
new file mode 100644
index 0000000000..caf185dc30
--- /dev/null
+++ b/shared/font-system/src/activation.ts
@@ -0,0 +1,148 @@
+/**
+ * Per-document "bundled font activation": which bundled substitute families a document may
+ * ADVERTISE (toolbar) and RESOLVE to (substitute). The decision is config-driven, never a runtime
+ * probe, and it is DOCUMENT-SCOPED - it lives in the resolver / offering / load / warning layers,
+ * not in registration. The shared per-`FontFaceSet` registry still registers the full pack
+ * (registration is lazy and global; filtering it would break two editors sharing one page), so a
+ * document simply decides which of those faces it actually uses.
+ *
+ * Two states, driven by whether the consumer wired the pack:
+ *  - `packConfigured: false` (no `@superdoc-dev/fonts`, no `fonts.assetBaseUrl` / `fonts.resolveAssetUrl`,
+ *    not the CDN build): NO bundled family is active. The document advertises the conservative
+ *    baseline and renders logical names with system fonts; nothing fetches a substitute `.woff2` that
+ *    is not being served, so there is no stray 404 and no spurious warning.
+ *  - `packConfigured: true`: every bundled family is active, minus `exclude` (or, with `include`,
+ *    only the listed families).
+ *
+ * `include` / `exclude` are by LOGICAL Word family name (e.g. `"Calibri"`, never the physical
+ * `"Carlito"`), matched case-insensitively after quote-stripping - the same normalization the
+ * resolver and offerings use as keys. The documented way to set them is `createSuperDocFonts`.
+ */
+import { isBundledPackPresent } from './bundled';
+
+/** Selection of which bundled families are active, by logical Word family name. */
+export interface BundledFontSelection {
+  /** Active families. When set (non-empty), ONLY these logical families resolve/advertise. */
+  include?: readonly string[];
+  /** Inactive families. When set, every bundled family EXCEPT these is active. */
+  exclude?: readonly string[];
+}
+
+/** Inputs that decide bundled activation for a document. */
+export interface BundledActivationInput extends BundledFontSelection {
+  /** Whether the consumer wired the bundled pack (config presence or the CDN build). */
+  packConfigured: boolean;
+}
+
+/** A resolved activation: the packConfigured flag, a per-logical-family predicate, and a signature. */
+export interface BundledActivation {
+  /** True when the bundled pack is wired for this document (config presence or the CDN build). */
+  readonly packConfigured: boolean;
+  /** Whether bundled substitution / advertising is active for this LOGICAL family (any case). */
+  isActive(logicalFamily: string): boolean;
+  /**
+   * Deterministic identity of this activation. `''` when FULLY active (packConfigured with no
+   * include/exclude) so default / full-pack documents keep sharing the measure cache and match the
+   * global resolver; any narrower activation (no pack, or curated) gets a distinct, non-empty
+   * signature the resolver folds into its own {@link FontResolver.signature} (the measure-cache key)
+   * - so a no-pack or curated document never reuses a full-pack document's cached measures.
+   */
+  readonly signature: string;
+}
+
+/** Normalize a family name for keying: trim, strip surrounding quotes, lowercase. */
+function normalizeKey(family: string): string {
+  return family
+    .trim()
+    .replace(/^["']|["']$/g, '')
+    .toLowerCase();
+}
+
+/** Normalized, de-duplicated, sorted list - or undefined when there is nothing usable. */
+function normalizeList(families: readonly string[] | undefined): string[] | undefined {
+  // Raw `fonts.bundled` is hand-written JS that may be malformed (a bare string, a number, a
+  // non-array). Treat anything that is not an array of strings as "no curation" so a wrong shape
+  // can never crash editor init; createSuperDocFonts is the strict path that rejects it instead.
+  if (!Array.isArray(families)) return undefined;
+  const out = [
+    ...new Set(
+      families
+        .filter((f) => typeof f === 'string')
+        .map(normalizeKey)
+        .filter(Boolean),
+    ),
+  ].sort();
+  return out.length > 0 ? out : undefined;
+}
+
+/**
+ * Fully-active activation: every bundled family, signature `''`. The resolver's default, so the
+ * module-level resolver and any `createFontResolver()` with no activation keep the prior global
+ * substitution behavior (and share the measure cache).
+ */
+export const FULLY_ACTIVE_BUNDLED: BundledActivation = Object.freeze({
+  packConfigured: true,
+  isActive: () => true,
+  signature: '',
+});
+
+/**
+ * No-pack activation: no bundled family is active. The conservative baseline default for the STATIC
+ * toolbar surfaces (the headless `DEFAULT_FONT_FAMILY_OPTIONS` / Vue `TOOLBAR_FONTS` consts, which
+ * have no runtime config to read).
+ */
+export const BASELINE_BUNDLED: BundledActivation = Object.freeze({
+  packConfigured: false,
+  isActive: () => false,
+  signature: JSON.stringify({ p: false }),
+});
+
+/**
+ * Build a {@link BundledActivation} from config-presence plus optional include/exclude.
+ *
+ * `include` is the stronger intent and WINS if both are passed (they are not meant to be combined).
+ * An include/exclude list with no usable entries is ignored rather than emptying the toolbar - "no
+ * bundled fonts" is expressed by not configuring the pack, not by `include: []`.
+ */
+export function createBundledActivation(input: BundledActivationInput): BundledActivation {
+  if (!input.packConfigured) return BASELINE_BUNDLED;
+  const include = normalizeList(input.include);
+  const exclude = include ? undefined : normalizeList(input.exclude);
+  if (!include && !exclude) return FULLY_ACTIVE_BUNDLED;
+  if (include) {
+    const set = new Set(include);
+    return Object.freeze({
+      packConfigured: true,
+      isActive: (family: string) => set.has(normalizeKey(family)),
+      signature: JSON.stringify({ p: true, i: include }),
+    });
+  }
+  const set = new Set(exclude);
+  return Object.freeze({
+    packConfigured: true,
+    isActive: (family: string) => !set.has(normalizeKey(family)),
+    signature: JSON.stringify({ p: true, x: exclude }),
+  });
+}
+
+/** Structural slice of a `fonts` config the activation needs - keeps this free of the editor type. */
+export interface FontAssetConfigLike {
+  resolveAssetUrl?: unknown;
+  assetBaseUrl?: unknown;
+  bundled?: BundledFontSelection;
+}
+
+/**
+ * Derive a document's {@link BundledActivation} from its `fonts` config. The pack counts as
+ * configured when the consumer set `resolveAssetUrl` (e.g. `superdocFonts`) or `assetBaseUrl`, or
+ * when the CDN build marked it present ({@link isBundledPackPresent}). Selection comes from
+ * `fonts.bundled` (set via `createSuperDocFonts`).
+ */
+export function deriveBundledActivation(config: FontAssetConfigLike | null | undefined): BundledActivation {
+  const packConfigured = !!(config?.resolveAssetUrl || config?.assetBaseUrl) || isBundledPackPresent();
+  return createBundledActivation({
+    packConfigured,
+    include: config?.bundled?.include,
+    exclude: config?.bundled?.exclude,
+  });
+}
diff --git a/shared/font-system/src/bundled.ts b/shared/font-system/src/bundled.ts
index 7e7098c03d..6f4682faab 100644
--- a/shared/font-system/src/bundled.ts
+++ b/shared/font-system/src/bundled.ts
@@ -28,6 +28,28 @@ export function getBundledFontAssetBase(): string {
   return defaultAssetBase;
 }
 
+// Whether the bundled pack is served WITHOUT per-instance config. The CDN `<script>` build ships
+// `fonts/*.woff2` next to `superdoc.min.js`, so its entry marks the pack present; npm consumers
+// signal it per instance via `fonts.resolveAssetUrl` / `fonts.assetBaseUrl` instead. Drives the
+// config-presence gate (`deriveBundledActivation`) so the toolbar/resolver light up the rich pack
+// only when it will actually be served.
+let bundledPackPresent = false;
+
+/** Mark the bundled pack as served page-globally (the CDN build calls this beside its base setter). */
+export function markBundledPackPresent(): void {
+  bundledPackPresent = true;
+}
+
+/** Whether the bundled pack is served page-globally (set by the CDN build). */
+export function isBundledPackPresent(): boolean {
+  return bundledPackPresent;
+}
+
+/** Reset the page-global pack-present flag. Test-only; not part of the public surface. */
+export function __resetBundledPackPresent(): void {
+  bundledPackPresent = false;
+}
+
 export interface InstallBundledOptions {
   /** Highest-precedence per-face URL resolver (consumer `fonts.resolveAssetUrl`). */
   resolveAssetUrl?: FontAssetUrlResolver;
diff --git a/shared/font-system/src/document-font-options.test.ts b/shared/font-system/src/document-font-options.test.ts
index 6e2cb57d8f..206d238100 100644
--- a/shared/font-system/src/document-font-options.test.ts
+++ b/shared/font-system/src/document-font-options.test.ts
@@ -1,5 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import {
+  BASELINE_BUNDLED,
+  FULLY_ACTIVE_BUNDLED,
   buildDocumentFontOptions,
   buildFontFamilyOptions,
   type FontFaceRequest,
@@ -116,13 +118,34 @@ describe('buildDocumentFontOptions (document-specific toolbar fonts)', () => {
 });
 
 describe('buildFontFamilyOptions (custom UI font picker rows)', () => {
-  it('combines bundled toolbar choices and document fonts alphabetically with no status field', () => {
-    const options = buildFontFamilyOptions([
-      { logicalFamily: 'Aptos', previewFamily: 'Aptos' },
-      { logicalFamily: 'Bangla MN', previewFamily: 'Bangla MN' },
-      { logicalFamily: 'Calibri', previewFamily: 'Carlito' },
-      { logicalFamily: 'Apple Chancery', previewFamily: 'Apple Chancery' },
+  const documentOptions = [
+    { logicalFamily: 'Aptos', previewFamily: 'Aptos' },
+    { logicalFamily: 'Bangla MN', previewFamily: 'Bangla MN' },
+    { logicalFamily: 'Calibri', previewFamily: 'Carlito' },
+    { logicalFamily: 'Apple Chancery', previewFamily: 'Apple Chancery' },
+  ];
+
+  it('with no pack configured: the baseline plus document fonts, alphabetical, no status field', () => {
+    const options = buildFontFamilyOptions(documentOptions);
+    expect(options.map((option) => option.label)).toEqual([
+      'Apple Chancery',
+      'Aptos',
+      'Arial',
+      'Bangla MN',
+      'Calibri',
+      'Courier New',
+      'Times New Roman',
     ]);
+    // BASELINE_BUNDLED is the explicit form of the same default.
+    expect(buildFontFamilyOptions(documentOptions, BASELINE_BUNDLED).map((o) => o.label)).toEqual(
+      options.map((o) => o.label),
+    );
+    expect(options.filter((option) => option.label === 'Calibri')).toHaveLength(1);
+    expect(options.every((option) => !('status' in option))).toBe(true);
+  });
+
+  it('with the pack configured: the full built-in set plus document fonts', () => {
+    const options = buildFontFamilyOptions(documentOptions, FULLY_ACTIVE_BUNDLED);
     expect(options.map((option) => option.label)).toEqual([
       'Apple Chancery',
       'Aptos',
@@ -151,7 +174,6 @@ describe('buildFontFamilyOptions (custom UI font picker rows)', () => {
       'Verdana',
     ]);
     expect(options.filter((option) => option.label === 'Calibri')).toHaveLength(1);
-    expect(options.every((option) => !('status' in option))).toBe(true);
   });
 
   it('uses the logical family as the apply value and previewFamily only for row rendering', () => {
diff --git a/shared/font-system/src/document-font-options.ts b/shared/font-system/src/document-font-options.ts
index 95c273e880..bbd0b0767f 100644
--- a/shared/font-system/src/document-font-options.ts
+++ b/shared/font-system/src/document-font-options.ts
@@ -6,6 +6,7 @@
  * Fallback diagnostics are intentionally not part of this surface. The toolbar lists document fonts as
  * plain picker rows; internal fallback/reporting details stay in SuperDoc's runtime font report.
  */
+import { type BundledActivation, BASELINE_BUNDLED } from './activation';
 import { buildFaceReport, type FontResolutionRecord, type UsedFace } from './report';
 import { getBuiltInToolbarFontOfferings } from './font-offerings';
 import type { FontRegistry } from './registry';
@@ -84,13 +85,20 @@ function compareByLabel(a: FontFamilyOption, b: FontFamilyOption): number {
 }
 
 /**
- * Compose the final font-family picker list from bundled toolbar choices plus active document fonts.
- * The result is sorted alphabetically and deduped by logical family.
+ * Compose the final font-family picker list from the built-in toolbar choices plus the active
+ * document's fonts. The built-in choices are gated on the document's bundled-font {@link
+ * BundledActivation} (baseline when no pack is configured, the curated rich set when it is); pass it
+ * from the editor so the picker advertises only what this document will render. Document fonts are
+ * always listed - they come from the loaded document itself. Sorted alphabetically, deduped by
+ * logical family.
  */
-export function buildFontFamilyOptions(documentOptions: ReadonlyArray<DocumentFontOption>): FontFamilyOption[] {
+export function buildFontFamilyOptions(
+  documentOptions: ReadonlyArray<DocumentFontOption>,
+  activation: BundledActivation = BASELINE_BUNDLED,
+): FontFamilyOption[] {
   const seen = new Set<string>();
   const options: FontFamilyOption[] = [];
-  for (const offering of getBuiltInToolbarFontOfferings()) {
+  for (const offering of getBuiltInToolbarFontOfferings(activation)) {
     const key = normalizeKey(offering.logicalFamily);
     if (seen.has(key)) continue;
     seen.add(key);
diff --git a/shared/font-system/src/font-offerings.test.ts b/shared/font-system/src/font-offerings.test.ts
index 4239f2276a..0a9ad4c873 100644
--- a/shared/font-system/src/font-offerings.test.ts
+++ b/shared/font-system/src/font-offerings.test.ts
@@ -1,4 +1,5 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { BASELINE_BUNDLED, FULLY_ACTIVE_BUNDLED, createBundledActivation } from './activation';
 import {
   FONT_OFFERINGS,
   fontOfferingRenderStack,
@@ -6,9 +7,13 @@ import {
   getBuiltInToolbarFontOfferings,
   getDefaultFontFamilyOptions,
   getDefaultFontOfferings,
+  warnUnknownBundledSelection,
 } from './font-offerings';
 import { SUBSTITUTION_EVIDENCE } from './substitution-evidence';
 
+/** No-pack toolbar baseline: one common Word font per CSS generic, each with a generic CSS fallback. */
+const EXPECTED_BASELINE = ['Arial', 'Courier New', 'Times New Roman'];
+
 const EXPECTED_DEFAULTS = ['Arial', 'Calibri', 'Courier New', 'Helvetica', 'Times New Roman'];
 const EXPECTED_BUILT_IN_TOOLBAR = [
   'Arial',
@@ -85,13 +90,36 @@ describe('font offerings', () => {
     }
   });
 
-  it('built-in toolbar offerings include advertised bundled rows without reclassifying them as defaults', () => {
-    expect(getBuiltInToolbarFontOfferings().map((o) => o.logicalFamily)).toEqual(EXPECTED_BUILT_IN_TOOLBAR);
-    expect(getBuiltInToolbarFontOfferings().find((o) => o.logicalFamily === 'Cooper Black')).toMatchObject({
-      offering: 'qualified',
-      verdict: 'visual_only',
-      bundled: true,
-    });
+  it('built-in toolbar offerings default to the conservative no-pack baseline', () => {
+    // No activation (and the explicit BASELINE_BUNDLED) = no pack configured = the baseline (one per generic).
+    expect(getBuiltInToolbarFontOfferings().map((o) => o.logicalFamily)).toEqual(EXPECTED_BASELINE);
+    expect(getBuiltInToolbarFontOfferings(BASELINE_BUNDLED).map((o) => o.logicalFamily)).toEqual(EXPECTED_BASELINE);
+  });
+
+  it('built-in toolbar offerings show the full advertised set when the pack is configured', () => {
+    expect(getBuiltInToolbarFontOfferings(FULLY_ACTIVE_BUNDLED).map((o) => o.logicalFamily)).toEqual(
+      EXPECTED_BUILT_IN_TOOLBAR,
+    );
+    expect(
+      getBuiltInToolbarFontOfferings(FULLY_ACTIVE_BUNDLED).find((o) => o.logicalFamily === 'Cooper Black'),
+    ).toMatchObject({ offering: 'qualified', verdict: 'visual_only', bundled: true });
+  });
+
+  it('curation narrows the configured toolbar set by logical Word name', () => {
+    const excluded = getBuiltInToolbarFontOfferings(
+      createBundledActivation({ packConfigured: true, exclude: ['Cooper Black', 'Verdana'] }),
+    ).map((o) => o.logicalFamily);
+    expect(excluded).not.toContain('Cooper Black');
+    expect(excluded).not.toContain('Verdana');
+    expect(excluded).toContain('Calibri');
+    expect(excluded.length).toBe(EXPECTED_BUILT_IN_TOOLBAR.length - 2);
+
+    // include is an allow-list, applied within the offered set (names outside it stay non-default
+    // toolbar options - use modules.toolbar.fonts for those).
+    const included = getBuiltInToolbarFontOfferings(
+      createBundledActivation({ packConfigured: true, include: ['Calibri', 'Georgia', 'Arial'] }),
+    ).map((o) => o.logicalFamily);
+    expect(included).toEqual(['Arial', 'Calibri', 'Georgia']);
   });
 
   it('classifies the qualified and category rows distinctly (carried for the later fidelity layer)', () => {
@@ -211,8 +239,16 @@ describe('font offerings', () => {
     });
   });
 
-  it('getDefaultFontFamilyOptions returns logical label + logical stack', () => {
+  it('getDefaultFontFamilyOptions returns the baseline by default (logical label + logical stack)', () => {
     expect(getDefaultFontFamilyOptions()).toEqual([
+      { label: 'Arial', value: 'Arial, sans-serif' },
+      { label: 'Courier New', value: 'Courier New, monospace' },
+      { label: 'Times New Roman', value: 'Times New Roman, serif' },
+    ]);
+  });
+
+  it('getDefaultFontFamilyOptions returns the full set when the pack is configured', () => {
+    expect(getDefaultFontFamilyOptions(FULLY_ACTIVE_BUNDLED)).toEqual([
       { label: 'Arial', value: 'Arial, sans-serif' },
       { label: 'Arial Black', value: 'Arial Black, sans-serif' },
       { label: 'Arial Narrow', value: 'Arial Narrow, sans-serif' },
@@ -253,3 +289,48 @@ describe('font offerings', () => {
     }
   });
 });
+
+describe('warnUnknownBundledSelection', () => {
+  it('stays silent for valid bundled families or no selection', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    warnUnknownBundledSelection(undefined);
+    warnUnknownBundledSelection({ exclude: ['Cooper Black', 'Verdana'] });
+    warnUnknownBundledSelection({ include: ['Calibri', 'Cambria'] });
+    expect(warn).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it('warns once per unknown name, suggesting the closest bundled family for a near typo', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    warnUnknownBundledSelection({ exclude: ['Calibrii'] });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0][0]).toMatch(/"Calibrii" is not a bundled font/);
+    expect(warn.mock.calls[0][0]).toMatch(/did you mean "Calibri"\?/);
+    warn.mockRestore();
+  });
+
+  it('warns for a real-but-unbundled Word font (no clone shipped), so curating it is a no-op', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    warnUnknownBundledSelection({ include: ['Aptos'] });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0][0]).toMatch(/"Aptos" is not a bundled font/);
+    warn.mockRestore();
+  });
+
+  it('warns when include and exclude are both set', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    warnUnknownBundledSelection({ include: ['Calibri'], exclude: ['Cambria'] });
+    expect(warn).toHaveBeenCalledWith(expect.stringMatching(/not both/));
+    warn.mockRestore();
+  });
+
+  it('coerces a non-array include (raw JS) - warns about the shape, never spreads it into characters', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    // A bare string must warn once about the wrong shape, not a per-character "unknown font" warning.
+    warnUnknownBundledSelection({ include: 'Calibri' as unknown as string[] });
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0][0]).toMatch(/fonts\.bundled\.include must be an array/);
+    expect(warn.mock.calls[0][0]).not.toMatch(/is not a bundled font/);
+    warn.mockRestore();
+  });
+});
diff --git a/shared/font-system/src/font-offerings.ts b/shared/font-system/src/font-offerings.ts
index b0da75d2c8..3804290e14 100644
--- a/shared/font-system/src/font-offerings.ts
+++ b/shared/font-system/src/font-offerings.ts
@@ -15,6 +15,7 @@
  * Derived from `SUBSTITUTION_EVIDENCE` x `BUNDLED_MANIFEST`. Adding/retiring a font is an evidence
  * edit, never a hand-maintained toolbar list.
  */
+import { type BundledActivation, type BundledFontSelection, BASELINE_BUNDLED } from './activation';
 import { BUNDLED_MANIFEST } from './bundled-manifest';
 import { type CssGeneric, SUBSTITUTION_EVIDENCE, type SubstituteVerdict } from './substitution-evidence';
 
@@ -53,6 +54,21 @@ export interface FontOffering {
 
 const BUNDLED_FAMILIES: ReadonlySet<string> = new Set(BUNDLED_MANIFEST.map((f) => f.family));
 const SUPPORTED_ALIAS_FAMILIES: ReadonlySet<string> = new Set(['Arial MT', 'Courier', 'Times']);
+
+/**
+ * The conservative toolbar baseline shown when the bundled pack is NOT configured: one common
+ * Word-facing font per CSS generic - Arial (sans-serif), Times New Roman (serif), Courier New
+ * (monospace). Each has a metric-safe bundled clone that activates only once the pack is configured;
+ * the richer set (Georgia and the rest) is pack-enabled, see {@link ADVERTISED_BUILT_IN_TOOLBAR_FAMILIES}.
+ */
+const BUILT_IN_TOOLBAR_BASELINE_FAMILIES: ReadonlySet<string> = new Set(['Arial', 'Courier New', 'Times New Roman']);
+
+/**
+ * The richer set advertised ON TOP of the clean defaults when the bundled pack IS configured.
+ * Bundled qualified / category-fallback families the product has chosen to surface. Inert without a
+ * configured pack (they would not render), and individually removable via `createSuperDocFonts`
+ * curation.
+ */
 const ADVERTISED_BUILT_IN_TOOLBAR_FAMILIES: ReadonlySet<string> = new Set([
   'Arial Black',
   'Arial Narrow',
@@ -128,17 +144,31 @@ export function getDefaultFontOfferings(): FontOffering[] {
 }
 
 /**
- * Built-in font picker options SuperDoc can render from its bundled assets. Includes clean defaults plus
- * explicitly advertised qualified/category fallbacks. Consumers that need strict metric-safe choices
- * should use {@link getDefaultFontOfferings}.
+ * Built-in font picker options for a document, gated on its bundled-font {@link BundledActivation}:
+ *
+ *  - pack NOT configured (the default): the conservative {@link BUILT_IN_TOOLBAR_BASELINE_FAMILIES}
+ *    baseline - only fonts that render acceptably with no pack served. SuperDoc does not advertise
+ *    bundled fonts it would have to fetch from an unconfigured location.
+ *  - pack configured: the clean defaults plus the advertised qualified / category fallbacks, minus
+ *    any the consumer curated out (`createSuperDocFonts({ include / exclude })`).
+ *
+ * Documents still RESOLVE the full reviewed substitute table through the resolver when their pack is
+ * active; this governs only what the picker ADVERTISES. Consumers that need strict metric-safe
+ * choices should use {@link getDefaultFontOfferings}.
  */
-export function getBuiltInToolbarFontOfferings(): FontOffering[] {
+export function getBuiltInToolbarFontOfferings(activation: BundledActivation = BASELINE_BUNDLED): FontOffering[] {
+  if (!activation.packConfigured) {
+    return FONT_OFFERINGS.filter((o) => o.bundled && BUILT_IN_TOOLBAR_BASELINE_FAMILIES.has(o.logicalFamily)).sort(
+      compareLogicalFamily,
+    );
+  }
   return FONT_OFFERINGS.filter(
     (o) =>
-      o.offering === 'default' ||
-      (o.bundled &&
-        ADVERTISED_BUILT_IN_TOOLBAR_FAMILIES.has(o.logicalFamily) &&
-        (o.offering === 'qualified' || o.offering === 'category_fallback')),
+      (o.offering === 'default' ||
+        (o.bundled &&
+          ADVERTISED_BUILT_IN_TOOLBAR_FAMILIES.has(o.logicalFamily) &&
+          (o.offering === 'qualified' || o.offering === 'category_fallback'))) &&
+      activation.isActive(o.logicalFamily),
   ).sort(compareLogicalFamily);
 }
 
@@ -162,9 +192,120 @@ export function fontOfferingRenderStack(offering: FontOffering): string {
  * built-in (Vue) toolbar builds its own richer `FontConfig` from
  * {@link getBuiltInToolbarFontOfferings}.
  */
-export function getDefaultFontFamilyOptions(): readonly { label: string; value: string }[] {
-  return getBuiltInToolbarFontOfferings().map((offering) => ({
+export function getDefaultFontFamilyOptions(
+  activation: BundledActivation = BASELINE_BUNDLED,
+): readonly { label: string; value: string }[] {
+  return getBuiltInToolbarFontOfferings(activation).map((offering) => ({
     label: offering.logicalFamily,
     value: fontOfferingStack(offering),
   }));
 }
+
+/** Normalize a family name for keying: trim, strip surrounding quotes, lowercase. */
+function normalizeFamilyKey(family: string): string {
+  return family
+    .trim()
+    .replace(/^["']|["']$/g, '')
+    .toLowerCase();
+}
+
+/** Every logical Word family SuperDoc ships a bundled substitute for - the set curation can target. */
+const BUNDLED_LOGICAL_FAMILIES: readonly string[] = [
+  ...new Set(FONT_OFFERINGS.filter((o) => o.bundled).map((o) => o.logicalFamily)),
+].sort((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }));
+const BUNDLED_LOGICAL_KEYS: ReadonlySet<string> = new Set(BUNDLED_LOGICAL_FAMILIES.map(normalizeFamilyKey));
+
+/**
+ * The Word family names a document can curate (`include` / `exclude`): every logical family the
+ * resolver substitutes to a bundled face, including category fallbacks like Verdana. The single
+ * source of truth for the curation surface - {@link warnUnknownBundledSelection} validates against it
+ * and `@superdoc-dev/fonts` generates its committed list from it. Distinct from the asset manifest's
+ * `replaces`, which omits category fallbacks (the reason curation keys on offerings, not `replaces`).
+ */
+export function getBundledFamilyNames(): string[] {
+  return [...BUNDLED_LOGICAL_FAMILIES];
+}
+
+/** Bounded Levenshtein distance between two short strings, for a "did you mean" curation hint. */
+function editDistance(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  if (Math.abs(m - n) > 2) return 3; // cannot be within the suggestion threshold
+  let prev = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i += 1) {
+    const curr = [i];
+    for (let j = 1; j <= n; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    prev = curr;
+  }
+  return prev[n];
+}
+
+/** The closest bundled family within edit distance 2, or null - so a typo gets a concrete suggestion. */
+function closestBundledFamily(name: string): string | null {
+  const key = normalizeFamilyKey(name);
+  let best: string | null = null;
+  let bestDist = 3;
+  for (const family of BUNDLED_LOGICAL_FAMILIES) {
+    const dist = editDistance(key, normalizeFamilyKey(family));
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = family;
+    }
+  }
+  return best;
+}
+
+/**
+ * Coerce a raw `fonts.bundled.include`/`exclude` value to a string array. Raw config is hand-written
+ * JS that may be malformed (a bare `include: 'Calibri'`, a number, ...); a non-array is reported once
+ * and dropped, so it can neither crash init nor spread a string into per-character "unknown font"
+ * warnings. createSuperDocFonts is the strict path that rejects malformed curation outright.
+ */
+function coerceCurationList(value: unknown, field: 'include' | 'exclude'): string[] {
+  if (value == null) return [];
+  if (!Array.isArray(value)) {
+    console.warn(
+      `[superdoc] fonts.bundled.${field} must be an array of font names; ignoring it. ` +
+        'Prefer createSuperDocFonts(), which rejects malformed curation.',
+    );
+    return [];
+  }
+  return value.filter((name): name is string => typeof name === 'string');
+}
+
+/**
+ * Warn (once per name) at config time when a `fonts.bundled` curation entry is not a bundled family,
+ * so curating it silently does nothing - and when both `include` and `exclude` are set. The safety
+ * net for `fonts.bundled` set DIRECTLY: `createSuperDocFonts` already rejects unknown names and
+ * structural errors in the consumer's setup code, but a hand-written `fonts.bundled` bypasses it. Warn
+ * (not throw) here because this runs at editor init, where a font-name typo must not crash the editor.
+ */
+export function warnUnknownBundledSelection(selection: BundledFontSelection | undefined): void {
+  if (!selection) return;
+  const include = coerceCurationList(selection.include, 'include');
+  const exclude = coerceCurationList(selection.exclude, 'exclude');
+  if (include.length && exclude.length) {
+    console.warn(
+      '[superdoc] fonts.bundled: set `include` OR `exclude`, not both. ' +
+        'Using `include` (the allow-list) and ignoring `exclude`. Prefer createSuperDocFonts(), which rejects this.',
+    );
+  }
+  const seen = new Set<string>();
+  for (const name of [...include, ...exclude]) {
+    const trimmed = typeof name === 'string' ? name.trim() : '';
+    if (!trimmed) continue;
+    const key = normalizeFamilyKey(trimmed);
+    if (BUNDLED_LOGICAL_KEYS.has(key) || seen.has(key)) continue;
+    seen.add(key);
+    const suggestion = closestBundledFamily(trimmed);
+    console.warn(
+      `[superdoc] fonts.bundled: "${trimmed}" is not a bundled font, so curating it has no effect` +
+        `${suggestion ? ` (did you mean "${suggestion}"?)` : ''}. ` +
+        'Curate by Word family name, e.g. Calibri, Cambria, Times New Roman. ' +
+        'Docs: https://docs.superdoc.dev/getting-started/fonts',
+    );
+  }
+}
diff --git a/shared/font-system/src/index.ts b/shared/font-system/src/index.ts
index 3f18d615e0..f2d4f0a277 100644
--- a/shared/font-system/src/index.ts
+++ b/shared/font-system/src/index.ts
@@ -49,9 +49,26 @@ export {
 
 export { getFontConfigVersion, bumpFontConfigVersion, __resetFontConfigVersion } from './epoch';
 
+// Per-document bundled-font activation (config-presence gate + curation). The resolver and offerings
+// consume it; the editor derives it from `fonts` config via `deriveBundledActivation`.
+export type {
+  BundledFontSelection,
+  BundledActivation,
+  BundledActivationInput,
+  FontAssetConfigLike,
+} from './activation';
+export { createBundledActivation, deriveBundledActivation, FULLY_ACTIVE_BUNDLED, BASELINE_BUNDLED } from './activation';
+
 // The bundled-asset base setter is also exported here (not only the ./bundled subpath) so
 // the CDN entry can resolve it through the bare `@superdoc/font-system` specifier.
-export { setBundledFontAssetBase, getBundledFontAssetBase, DEFAULT_BUNDLED_FONT_BASE } from './bundled';
+export {
+  setBundledFontAssetBase,
+  getBundledFontAssetBase,
+  DEFAULT_BUNDLED_FONT_BASE,
+  markBundledPackPresent,
+  isBundledPackPresent,
+  __resetBundledPackPresent,
+} from './bundled';
 
 export type { FontResolutionRecord, UsedFace } from './report';
 export { buildFontReport, buildFaceReport } from './report';
@@ -76,6 +93,8 @@ export {
   getDefaultFontFamilyOptions,
   fontOfferingStack,
   fontOfferingRenderStack,
+  warnUnknownBundledSelection,
+  getBundledFamilyNames,
 } from './font-offerings';
 
 export type { DocumentFontOption, FontFamilyOption } from './document-font-options';
diff --git a/shared/font-system/src/registry.test.ts b/shared/font-system/src/registry.test.ts
index 7563160073..524b9e12e7 100644
--- a/shared/font-system/src/registry.test.ts
+++ b/shared/font-system/src/registry.test.ts
@@ -480,7 +480,7 @@ describe('bundled-substitute load-failure warning', () => {
     expect(result.status).toBe('failed');
     const warnings = bundledWarnings();
     expect(warnings).toHaveLength(1);
-    expect(warnings[0]).toContain('@superdoc/fonts');
+    expect(warnings[0]).toContain('@superdoc-dev/fonts');
     expect(warnings[0]).toContain('fonts.assetBaseUrl');
   });
 
diff --git a/shared/font-system/src/registry.ts b/shared/font-system/src/registry.ts
index cd51509257..025100c914 100644
--- a/shared/font-system/src/registry.ts
+++ b/shared/font-system/src/registry.ts
@@ -13,7 +13,7 @@ import { BUNDLED_MANIFEST } from './bundled-manifest';
 /**
  * Physical family NAMES SuperDoc ships as bundled substitutes (Carlito, Liberation Sans, ...). When a
  * face under one of these fails to load, it is almost always the bundled `.woff2` not being served - a
- * setup problem with one clear fix - so we route it to the actionable "install @superdoc/fonts / set
+ * setup problem with one clear fix - so we route it to the actionable "install @superdoc-dev/fonts / set
  * assetBaseUrl" warning. This is a NAME match, not true provenance: a customer `fonts.add` face that
  * happens to be named e.g. "Carlito" would route here too. That collision is rare and the guidance is
  * still reasonable, so the simpler name check is preferred over threading a provenance flag through
@@ -650,8 +650,8 @@ export class FontRegistry {
     console.warn(
       `[superdoc] Bundled fallback fonts failed to load (e.g. "${family}"). Text will render with ` +
         `system fallbacks, so some fonts may look unchanged on machines that lack them. Fix one of:\n` +
-        `  - install @superdoc/fonts and pass it:\n` +
-        `      import { superdocFonts } from '@superdoc/fonts';\n` +
+        `  - install @superdoc-dev/fonts and pass it:\n` +
+        `      import { superdocFonts } from '@superdoc-dev/fonts';\n` +
         `      new SuperDoc({ /* ... */ fonts: superdocFonts });\n` +
         `  - or set fonts.assetBaseUrl / fonts.resolveAssetUrl to where the bundled .woff2 are served.\n` +
         `Docs: https://docs.superdoc.dev/getting-started/fonts`,
diff --git a/shared/font-system/src/resolver.test.ts b/shared/font-system/src/resolver.test.ts
index 646da950c0..30aa68f73e 100644
--- a/shared/font-system/src/resolver.test.ts
+++ b/shared/font-system/src/resolver.test.ts
@@ -1,5 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import {
+  BASELINE_BUNDLED,
+  FULLY_ACTIVE_BUNDLED,
+  createBundledActivation,
   createFontResolver,
   resolveFontFamily,
   resolvePhysicalFamilies,
@@ -367,6 +370,112 @@ describe('FontResolver (per-document context)', () => {
   });
 });
 
+describe('FontResolver (bundled activation gating)', () => {
+  const norm = (f: string) => f.replace(/^["']|["']$/g, '').toLowerCase();
+
+  it('no pack configured: bundled substitutes are inert and pass through as_requested', () => {
+    const r = createFontResolver(BASELINE_BUNDLED);
+    expect(r.resolvePrimaryPhysicalFamily('Calibri')).toBe('Calibri');
+    expect(r.resolvePhysicalFamily('Calibri, sans-serif')).toBe('Calibri, sans-serif');
+    expect(r.resolveFontFamily('Calibri')).toEqual({
+      logicalFamily: 'Calibri',
+      physicalFamily: 'Calibri',
+      reason: 'as_requested',
+    });
+    // Even the baseline families render with system fonts when no pack is served.
+    expect(r.resolvePrimaryPhysicalFamily('Arial')).toBe('Arial');
+  });
+
+  it('pack configured: substitutes apply, matching the default fully-active resolver', () => {
+    const r = createFontResolver(FULLY_ACTIVE_BUNDLED);
+    expect(r.resolvePrimaryPhysicalFamily('Calibri')).toBe('Carlito');
+    expect(r.resolveFontFamily('Cambria')).toEqual({
+      logicalFamily: 'Cambria',
+      physicalFamily: 'Caladea',
+      reason: 'bundled_substitute',
+    });
+  });
+
+  it('curation gates substitution per logical family', () => {
+    const excluded = createFontResolver(createBundledActivation({ packConfigured: true, exclude: ['Cooper Black'] }));
+    expect(excluded.resolvePrimaryPhysicalFamily('Cooper Black')).toBe('Cooper Black'); // excluded -> inert
+    expect(excluded.resolvePrimaryPhysicalFamily('Calibri')).toBe('Carlito'); // others still substitute
+
+    const only = createFontResolver(createBundledActivation({ packConfigured: true, include: ['Calibri'] }));
+    expect(only.resolvePrimaryPhysicalFamily('Calibri')).toBe('Carlito');
+    expect(only.resolvePrimaryPhysicalFamily('Cambria')).toBe('Cambria'); // not included -> inert
+  });
+
+  it('an explicit fonts.map override is honored even with no pack (customer instruction, not a suggestion)', () => {
+    const r = createFontResolver(BASELINE_BUNDLED);
+    r.map('Calibri', 'MyCalibri');
+    expect(r.resolveFontFamily('Calibri')).toEqual({
+      logicalFamily: 'Calibri',
+      physicalFamily: 'MyCalibri',
+      reason: 'custom_mapping',
+    });
+  });
+
+  it('a registered real face is honored with no pack; an inactive bundled clone is treated as no provider', () => {
+    const r = createFontResolver(BASELINE_BUNDLED);
+    const face = { weight: '400', style: 'normal' } as const;
+    // Customer fonts.add registered a real Calibri face -> render it (registered_face).
+    expect(r.resolveFace('Calibri', face, (f) => norm(f) === 'calibri')).toMatchObject({
+      physicalFamily: 'Calibri',
+      reason: 'registered_face',
+    });
+    // No registered face and no pack: the clone is inert, so the family passes through as_requested
+    // (NOT fallback_face_absent - an inactive clone is no provider, not a present-but-faceless one).
+    expect(r.resolveFace('Calibri', face, () => false)).toMatchObject({
+      physicalFamily: 'Calibri',
+      reason: 'as_requested',
+    });
+  });
+
+  it('activation is folded into the signature: no-pack and curated are isolated; full-pack == default', () => {
+    const baseline = createFontResolver(BASELINE_BUNDLED);
+    const full = createFontResolver(FULLY_ACTIVE_BUNDLED);
+    const def = createFontResolver(); // defaults to fully active
+    const excl = createFontResolver(createBundledActivation({ packConfigured: true, exclude: ['Calibri'] }));
+
+    // A configured full-pack document shares the empty (cache-sharing) signature with the default.
+    expect(full.signature).toBe('');
+    expect(def.signature).toBe('');
+    // No-pack and curated documents get distinct, non-empty signatures, so their measures never
+    // collide with a full-pack document's.
+    expect(baseline.signature).not.toBe('');
+    expect(excl.signature).not.toBe('');
+    expect(new Set([baseline.signature, full.signature, excl.signature]).size).toBe(3);
+  });
+
+  it('setActivation re-gates resolution and busts the signature; re-applying the same is a no-op', () => {
+    const r = createFontResolver(); // fully active
+    expect(r.resolvePrimaryPhysicalFamily('Calibri')).toBe('Carlito');
+    expect(r.signature).toBe('');
+
+    r.setActivation(BASELINE_BUNDLED);
+    expect(r.resolvePrimaryPhysicalFamily('Calibri')).toBe('Calibri'); // now inert
+    expect(r.signature).not.toBe('');
+
+    const v = r.version;
+    r.setActivation(createBundledActivation({ packConfigured: false })); // same signature -> no bump
+    expect(r.version).toBe(v);
+  });
+
+  it('signature composes activation with overrides', () => {
+    const a = createFontResolver(BASELINE_BUNDLED);
+    a.map('Georgia', 'Gelasio');
+    const b = createFontResolver(BASELINE_BUNDLED);
+    b.map('Georgia', 'Tinos');
+    // Same activation, different overrides -> distinct signatures.
+    expect(a.signature).not.toBe(b.signature);
+    // Same override under a DIFFERENT activation -> distinct signature (activation folded in).
+    const c = createFontResolver(FULLY_ACTIVE_BUNDLED);
+    c.map('Georgia', 'Gelasio');
+    expect(a.signature).not.toBe(c.signature);
+  });
+});
+
 describe('face-aware resolution (resolveFace / resolvePhysicalFamilyForFace)', () => {
   const norm = (f: string) => f.replace(/^["']|["']$/g, '').toLowerCase();
   // Realistic registries: the bundled CLONE (Carlito) is registered but the logical Calibri is NOT -
diff --git a/shared/font-system/src/resolver.ts b/shared/font-system/src/resolver.ts
index d9e7728b31..bc2cb66b84 100644
--- a/shared/font-system/src/resolver.ts
+++ b/shared/font-system/src/resolver.ts
@@ -23,6 +23,7 @@
 
 import { getFallbackDecisionForFace, getRenderableFallback } from '@docfonts/fallbacks';
 
+import { type BundledActivation, FULLY_ACTIVE_BUNDLED } from './activation';
 import { BUNDLED_MANIFEST } from './bundled-manifest';
 import { SUBSTITUTION_EVIDENCE, type FaceSlot } from './substitution-evidence';
 
@@ -252,6 +253,36 @@ export class FontResolver {
   #version = 0;
   /** Memoized {@link signature}; null = stale, recomputed on next read. Invalidated on every mutation. */
   #cachedSignature: string | null = null;
+  /**
+   * This document's bundled-font activation: which bundled families it may substitute to and
+   * advertise (config-presence + optional curation). Set once at config time via {@link setActivation}
+   * (the editor's `fonts` config is stable across document swaps), then effectively constant. Folded
+   * into {@link signature} so a no-pack / curated document never reuses a full-pack document's measure
+   * cache. Defaults to fully active, so the module-level resolver and any `createFontResolver()` with
+   * no activation keep the prior global substitution behavior.
+   */
+  #activation: BundledActivation;
+
+  constructor(activation: BundledActivation = FULLY_ACTIVE_BUNDLED) {
+    this.#activation = activation;
+  }
+
+  /**
+   * Apply this document's bundled-font activation, derived from the editor's `fonts` config.
+   * Config-time only: the document font controller calls this before the first measure. Busts the
+   * cached {@link signature} (and bumps {@link version}) so the new activation is reflected in both
+   * resolution and the measure-cache key; a no-op when the activation signature is unchanged, so
+   * re-applying the same config on a document swap neither reflows nor drops the cache.
+   */
+  setActivation(activation: BundledActivation): void {
+    if (this.#activation.signature === activation.signature) {
+      this.#activation = activation;
+      return;
+    }
+    this.#activation = activation;
+    this.#version += 1;
+    this.#cachedSignature = null;
+  }
 
   /**
    * Map a logical family to a physical render family for this document, overriding the
@@ -358,19 +389,33 @@ export class FontResolver {
   get signature(): string {
     if (this.#cachedSignature !== null) return this.#cachedSignature;
     // JSON of sorted [logical, physical] pairs: deterministic and collision-safe even when a font name
-    // contains punctuation (a delimited "logical=physical|..." form would not be). Empty (no overrides
-    // AND no embedded bindings) is '' so all default documents share cache. Embedded physical names are
-    // document-unique, so folding them in gives two embedded-Calibri documents distinct signatures
-    // (cache isolation). Format is unchanged when there are no embedded fonts (the common case keeps its
-    // existing identity). Memoized until the next mutation.
-    if (this.#overrides.size === 0 && this.#embedded.size === 0) {
+    // contains punctuation (a delimited "logical=physical|..." form would not be). Embedded physical
+    // names are document-unique, so folding them in gives two embedded-Calibri documents distinct
+    // signatures (cache isolation). The activation signature ('' when FULLY active) is folded in too,
+    // so a no-pack / curated document never reuses a full-pack document's measures. Memoized until the
+    // next mutation.
+    const activation = this.#activation.signature;
+    const hasOverrides = this.#overrides.size > 0;
+    const hasEmbedded = this.#embedded.size > 0;
+    // Fully default AND fully active is '' so all default full-pack documents share cache and match
+    // the global resolver - the existing common-case identity is preserved exactly.
+    if (!hasOverrides && !hasEmbedded && activation === '') {
       this.#cachedSignature = '';
+      return this.#cachedSignature;
+    }
+    const overridePairs = sortPairs([...this.#overrides.entries()]);
+    if (activation === '') {
+      // Legacy format preserved exactly when activation does not narrow this document (override-only,
+      // or override + embedded), so existing signatures/cache identities are unchanged.
+      this.#cachedSignature = !hasEmbedded
+        ? JSON.stringify(overridePairs)
+        : JSON.stringify({ o: overridePairs, e: sortPairs([...this.#embedded.entries()]) });
     } else {
-      const overridePairs = sortPairs([...this.#overrides.entries()]);
-      this.#cachedSignature =
-        this.#embedded.size === 0
-          ? JSON.stringify(overridePairs)
-          : JSON.stringify({ o: overridePairs, e: sortPairs([...this.#embedded.entries()]) });
+      // Activation narrows this document (no pack, or curated): include it under a distinct `a` key.
+      const obj: { o?: Array<[string, string]>; e?: Array<[string, string]>; a: string } = { a: activation };
+      if (hasOverrides) obj.o = overridePairs;
+      if (hasEmbedded) obj.e = sortPairs([...this.#embedded.entries()]);
+      this.#cachedSignature = JSON.stringify(obj);
     }
     return this.#cachedSignature;
   }
@@ -379,11 +424,18 @@ export class FontResolver {
   #physicalFor(bareFamily: string): { physical: string; reason: FontResolutionReason } {
     const key = normalizeFamilyKey(bareFamily);
     const override = this.#overrides.get(key);
+    // An explicit `fonts.map` override is always honored - it is a customer instruction, not a
+    // bundled-pack suggestion, so it is NOT gated by activation.
     if (override) return { physical: override, reason: 'custom_mapping' };
-    const bundled = BUNDLED_SUBSTITUTES[key];
-    if (bundled) return { physical: bundled, reason: 'bundled_substitute' };
-    const category = CATEGORY_FALLBACKS[key];
-    if (category) return { physical: category, reason: 'category_fallback' };
+    // Bundled substitutes / category fallbacks only apply when this document's pack is active. With
+    // no pack configured (baseline), the logical family passes through to system fonts so nothing
+    // fetches a substitute that is not being served; curation narrows which families are active.
+    if (this.#activation.isActive(bareFamily)) {
+      const bundled = BUNDLED_SUBSTITUTES[key];
+      if (bundled) return { physical: bundled, reason: 'bundled_substitute' };
+      const category = CATEGORY_FALLBACKS[key];
+      if (category) return { physical: category, reason: 'category_fallback' };
+    }
     return { physical: bareFamily, reason: 'as_requested' };
   }
 
@@ -425,16 +477,22 @@ export class FontResolver {
     if (hasFace(primary, face.weight, face.style)) {
       return { physical: primary, reason: 'registered_face' };
     }
-    // 3/4. docfonts fallback: either a bundled substitute or a lower-fidelity category fallback.
-    //      Query the face-aware docfonts helper instead of checking the requested face directly:
-    //      rows may explicitly allow synthetic faces (e.g. Cooper Black Bold -> Caprasimo Regular),
-    //      in which case the load gate must await the source face while paint keeps the requested
-    //      bold/italic style for browser synthesis.
-    const docfonts = resolveDocfontsFace(primary, face, hasFace);
-    if (docfonts) return docfonts;
-    // 5. a configured provider (an override or a bundled clone) was known but none could supply this
-    //    face: pass the logical family through, reported non-metric, never faux-styled.
-    const bundled = BUNDLED_SUBSTITUTES[key];
+    // 3/4. docfonts fallback: either a bundled substitute or a lower-fidelity category fallback - but
+    //      ONLY when this document's bundled pack is active for this family (config-presence +
+    //      curation). With no pack configured, the family passes through to system fonts so nothing
+    //      fetches a substitute that is not served. Query the face-aware docfonts helper instead of
+    //      checking the requested face directly: rows may explicitly allow synthetic faces (e.g.
+    //      Cooper Black Bold -> Caprasimo Regular), in which case the load gate must await the source
+    //      face while paint keeps the requested bold/italic style for browser synthesis.
+    const active = this.#activation.isActive(primary);
+    if (active) {
+      const docfonts = resolveDocfontsFace(primary, face, hasFace);
+      if (docfonts) return docfonts;
+    }
+    // 5. a configured provider (an override, or - when active - a bundled clone) was known but none
+    //    could supply this face: pass the logical family through, reported non-metric, never
+    //    faux-styled. An inactive bundled clone is treated as no provider (step 6), not an absent face.
+    const bundled = active ? BUNDLED_SUBSTITUTES[key] : undefined;
     if (override || bundled) {
       return { physical: primary, reason: 'fallback_face_absent' };
     }
@@ -536,9 +594,13 @@ export class FontResolver {
   }
 }
 
-/** Create a per-document resolver seeded with bundled DocFonts fallbacks. */
-export function createFontResolver(): FontResolver {
-  return new FontResolver();
+/**
+ * Create a per-document resolver seeded with bundled DocFonts fallbacks. Pass the document's
+ * {@link BundledActivation} (from `deriveBundledActivation`) so substitution is gated on the pack
+ * being configured and on any curation; omit it for the prior fully-active behavior.
+ */
+export function createFontResolver(activation?: BundledActivation): FontResolver {
+  return new FontResolver(activation);
 }
 
 /**
diff --git a/tests/behavior/harness/main.ts b/tests/behavior/harness/main.ts
index 010bdc4ac1..3e6aa1cc12 100644
--- a/tests/behavior/harness/main.ts
+++ b/tests/behavior/harness/main.ts
@@ -188,6 +188,10 @@ function init(file?: File, content?: ContentOverrideInput) {
     selector: '#editor',
     useLayoutEngine: layout,
     telemetry: { enabled: false },
+    // Configure the bundled pack so the harness exercises the FULL toolbar + substitution (the
+    // product's rich experience). Without a configured pack the toolbar is the conservative
+    // baseline; font specs assert the rich list, so the harness opts in here.
+    fonts: { assetBaseUrl: '/fonts/' },
     onReady: ({ superdoc }: SuperDocReadyPayload) => {
       harnessWindow.superdoc = superdoc;
       if (comments === 'panel' && commentsPanel) {
diff --git a/vitest.config.mjs b/vitest.config.mjs
index 231bd5ca83..2de1985fba 100644
--- a/vitest.config.mjs
+++ b/vitest.config.mjs
@@ -17,6 +17,7 @@ export default defineConfig({
       './packages/super-editor',
       './packages/superdoc',
       './shared/font-system',
+      './packages/fonts',
       './packages/ai',
       './packages/collaboration-yjs',
       './packages/layout-engine/contracts',