uniweb 0.56.2 → 0.56.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.56.2",
+  "version": "0.56.3",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,15 +41,16 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/core": "^0.29.3",
-    "@uniweb/kit": "^0.19.1",
+    "@uniweb/core": "^0.29.4",
+    "@uniweb/kit": "^0.19.2",
+    "@uniweb/schemas": "^0.2.14",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/runtime": "^0.26.3"
+    "@uniweb/runtime": "^0.26.4"
   },
   "peerDependencies": {
+    "@uniweb/build": "^0.52.2",
     "@uniweb/content-reader": "^1.2.5",
-    "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/build": "^0.52.1"
+    "@uniweb/semantic-parser": "^1.4.0"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -236,10 +236,32 @@ cat <foundation>/sections/Hero/meta.js       # what one expects and accepts
 
 > **A site-relative URL (`/effects/entry.js`) only works where the site serves its own files** — `uniweb export` and `uniweb deploy --host=<adapter>`. A site published to Uniweb hosting ships no JS, so nothing serves that path, and `uniweb publish` rejects it with a pointer to the catalog-ref form. Register the extension (`uniweb register` in its directory) and reference it like any other foundation. When you reference a workspace-local extension, `uniweb publish` brings it along exactly as it does the primary — releasing it if its code changed, and pinning the released version on the published site.
 
-Each `meta.js` is a catalog entry: `description` (what the type is for), `content:` (what markdown it expects), `params:` (what frontmatter it accepts, with defaults), `presets:` (named param bundles). Read them as a menu — that is what they are. There is no CLI command that lists them; reading the folder *is* the discovery step.
+Each `meta.js` is a catalog entry: `description` (what the type is for), `content:` (what markdown it expects), `params:` (what frontmatter it accepts, with defaults), `presets:` (named param bundles), and optionally `family:` (the standard section family it belongs to). Read them as a menu — that is what they are. There is no CLI command that lists them; reading the folder *is* the discovery step.
 
 > **Never write a `type:` or a param you haven't confirmed exists.** Both failures are silent (Part 0) — invisible from the terminal, visible only on the page.
 
+#### `family:` — so an editor can draw your section
+
+An editor showing an author a section picker has to know what each section type
+**is**, to pick its illustration and a label it can translate. Two ways to tell
+it, in this order:
+
+1. **Name the component for its family.** Run `uniweb families`, and use one of
+   those names when it fits — `Hero`, `Footer`, `Pricing`, `FAQ`, `CardGrid`.
+   Then there is nothing to declare: the name resolves on its own.
+2. **Declare `family:`** when the name is yours — a variant, or your own
+   vocabulary:
+   ```js
+   // sections/ProfileHero/meta.js
+   export default { title: 'Researcher Profile', family: 'profile' }
+   ```
+   One value, the dominant shape: a `HeroWithEstimate` is `family: 'hero'`.
+
+**Leave it off when nothing fits.** A section that is genuinely specific to this
+site gets a generic illustration, and that is the right outcome — do not force it
+into the nearest family. `uniweb doctor` shows what each of your sections
+resolved to, and suggests a family for any it recognises by another name.
+
 ### 3. Find your lane
 
 The architecture exists to keep content and code separate. Your task sits in one of them. Decide before you edit, then stay there.

package/src/commands/docs.js

@@ -175,8 +175,12 @@ Component metadata in <foundation>/components/[Name]/meta.js (or sections/[Name]
 ${colors.bright}Identity:${colors.reset}
   ${colors.cyan}title${colors.reset}             Display name in editor
   ${colors.cyan}description${colors.reset}       What the component does
-  ${colors.cyan}category${colors.reset}          Grouping: "impact", "showcase", "structure"
-  ${colors.cyan}purpose${colors.reset}           Single verb: Introduce, Express, Explain
+  ${colors.cyan}family${colors.reset}            The standard section family this is — "hero", "pricing",
+                    "faq". Picks the editor's illustration and a translated
+                    label. Only needed when the component NAME is not already
+                    one: \`Hero\` resolves on its own, \`ProfileHero\` does not.
+                    An unrecognized value is legal and falls back.
+                    ${colors.dim}uniweb families${colors.reset}
   ${colors.cyan}hidden${colors.reset}            If true, not selectable in frontmatter
 
 ${colors.bright}Content Expectations:${colors.reset}
@@ -202,7 +206,7 @@ ${colors.bright}Example:${colors.reset}
   ${colors.dim}export default {
     title: 'Hero Banner',
     description: 'Bold hero section with headline and CTA',
-    category: 'impact',
+    family: 'hero',
     background: true,
 
     content: {

package/src/commands/doctor.js

@@ -27,6 +27,8 @@ import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { checkSiteInstall } from '../utils/install-integrity.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import { DATA_DIR } from '@uniweb/core/data-paths'
+import { FAMILIES, resolveFamily } from '@uniweb/schemas/families'
+import { suggestFamily } from '@uniweb/schemas/family-aliases'
 
 /**
  * Parse the `--fix [<issue-id>]` flag.
@@ -99,10 +101,21 @@ function loadFoundationJs(dir) {
 }
 
 /**
- * Load built schema.json from a directory
+ * Load a foundation's built schema.json.
+ *
+ * ⛔ THE PATH IS `dist/meta/schema.json`, and it read `dist/schema.json` from
+ * 2026-02-06 until 2026-09-15 — a file the build has never written. So this
+ * returned `null` every time, and its one caller (the extension `vars`/layouts
+ * warning, which `framework/CLAUDE.md` gotcha #18 says doctor performs) could
+ * not fire at all.
+ *
+ * ⭐ THE CLASS IS WORTH MORE THAN THE BUG: a wrong PATH returns empty, it does
+ * not throw. `existsSync` said no, the function returned `null`, every caller
+ * used `?.` and skipped — and a check that never fires looks exactly like a
+ * codebase with nothing to report.
  */
 function loadSchemaJson(dir) {
-  const schemaPath = join(dir, 'dist', 'schema.json')
+  const schemaPath = join(dir, 'dist', 'meta', 'schema.json')
   if (!existsSync(schemaPath)) return null
   try {
     return JSON.parse(readFileSync(schemaPath, 'utf8'))
@@ -498,6 +511,175 @@ export async function checkFoundationSupports({
   log(`    ${colors.dim}uniweb doctor --fix ${id}${colors.reset}`)
 }
 
+/**
+ * Every section type's standard family — what it resolved to, and HOW.
+ *
+ * ⭐ THIS IS WHERE THE TAXONOMY IS ACTUALLY LEARNED. Nobody reads a word list in
+ * advance; they read the warning that names their own component and proposes the
+ * edit. A foundation developer sees their own picker here before an author does.
+ *
+ * ⛔ AN UNRECOGNIZED NAME IS NOT AN ERROR, and this check must never imply it is.
+ * A foundation with its own vocabulary is a supported choice: the section falls
+ * back to a generic illustration and nothing breaks. What is reported is the
+ * OPPORTUNITY — and only where there is a concrete suggestion to act on.
+ *
+ * ⚠️ READS THE BUILT `schema.json`, so it says nothing before a build. That is
+ * deliberate: schema.json is what a picker actually receives, and inferring from
+ * unbuilt source would report on a state no consumer sees.
+ */
+export function checkSectionFamilies({
+  foundationName,
+  folderName,
+  foundationDir,
+  issues,
+  shouldFixExplicitly,
+  fixed,
+}) {
+  const schema = loadSchemaJson(foundationDir)
+  if (!schema) return
+
+  const familyIds = FAMILIES.map((f) => f.id)
+  const sections = Object.entries(schema)
+    .filter(([key, value]) => !key.startsWith('_') && key !== 'dataSchemas' && value && typeof value === 'object')
+    .map(([name, entry]) => ({ name, entry, ...resolveFamily({ name, family: entry.family }) }))
+
+  if (sections.length === 0) return
+
+  const declared = sections.filter((s) => s.source === 'declared')
+  const byName = sections.filter((s) => s.source === 'name')
+  const misses = sections.filter((s) => !s.id)
+
+  info(
+    `${folderName}: ${sections.length - misses.length}/${sections.length} sections have a standard family ` +
+      `${colors.dim}(${declared.length} declared, ${byName.length} from the name)${colors.reset}`
+  )
+
+  // ── a `family:` that names nothing we know ────────────────────────────────
+  const bogus = misses.filter((s) => s.unknown)
+  for (const s of bogus) {
+    const id = 'section-family-unknown'
+    const near = suggestFamily(s.unknown, familyIds)
+    issues.push({
+      id,
+      type: 'warning',
+      foundation: foundationName,
+      message: `${s.name} declares family '${s.unknown}', which is not a standard family`,
+    })
+    warn(`[${id}] ${folderName}/${s.name}: family '${s.unknown}' is not a standard family`)
+    if (near.id) log(`    Did you mean ${colors.blue}${near.id}${colors.reset}?`)
+    log(`    ${colors.dim}An unrecognized value is legal — it falls back to a generic illustration.${colors.reset}`)
+    log(`    ${colors.dim}uniweb families${colors.reset}`)
+  }
+
+  // ── a name we do not know, WITH something to suggest ──────────────────────
+  const undeclared = misses.filter((s) => !s.unknown)
+  const proposals = undeclared
+    .map((s) => ({ ...s, suggestion: suggestFamily(s.name, familyIds) }))
+    .filter((s) => s.suggestion.id || s.suggestion.ambiguous)
+  if (proposals.length === 0) return
+
+  const id = 'section-family-unrecognized'
+  const writable = proposals.filter((p) => p.suggestion.fixable && p.suggestion.id)
+
+  // ⛔ EXPLICIT ID ONLY — never a bare `--fix`. Every id below is a GUESS from a
+  // table that exists here, rather than in the resolver, precisely so a person
+  // approves it. A bare `--fix` writing them would put the silent-wrong-guess
+  // failure back, one directory deeper.
+  if (shouldFixExplicitly?.(id) && writable.length > 0) {
+    const srcDir = resolveFoundationSrcPath(foundationDir)
+    for (const p of writable) {
+      const metaPath = join(srcDir, p.entry.path || '', 'meta.js')
+      const written = writeFamilyIntoMeta(metaPath, p.suggestion.id)
+      if (written) fixed?.(`${folderName}/${p.entry.path}/meta.js now declares family: '${p.suggestion.id}'`)
+      else warn(`[${id}] could not write ${p.name}'s meta.js — add \`family: '${p.suggestion.id}'\` by hand`)
+    }
+    return
+  }
+
+  issues.push({
+    id,
+    type: 'info',
+    foundation: foundationName,
+    message: `${proposals.length} section(s) in ${foundationName} could declare a standard family`,
+    details: proposals.map((p) => ({ name: p.name, suggested: p.suggestion.id, via: p.suggestion.via })),
+    fixable: writable.length > 0,
+  })
+
+  warn(`[${id}] ${folderName}: ${proposals.length} section(s) have no standard family`)
+  const width = Math.max(...proposals.map((p) => p.name.length))
+  for (const p of proposals) {
+    const { id: hit, via, ambiguous } = p.suggestion
+    if (ambiguous) {
+      log(`    ${p.name.padEnd(width)}  ${colors.dim}ambiguous — ${ambiguous}${colors.reset}`)
+    } else {
+      const how = via === 'near' ? 'possible typo' : via === 'suffix' ? 'name + shape suffix' : 'known alias'
+      log(`    ${p.name.padEnd(width)}  → ${colors.blue}${hit}${colors.reset} ${colors.dim}(${how})${colors.reset}`)
+    }
+  }
+  log(`    ${colors.dim}Nothing is broken — an unrecognized name falls back to a generic illustration.${colors.reset}`)
+  if (writable.length > 0) {
+    log(`    ${colors.dim}uniweb doctor --fix ${id}${colors.reset} ${colors.dim}— writes ${writable.length} \`family:\` line(s). Read the diff: these are guesses.${colors.reset}`)
+  }
+}
+
+/**
+ * Insert `family: '<id>'` as the first key of a meta.js default export.
+ *
+ * ⛔ REFUSES ANYTHING IT DOES NOT RECOGNIZE. A meta.js is hand-written source,
+ * and a half-understood rewrite of someone's file is far worse than telling them
+ * to add one line. A `false` return is reported as "could not write", never as
+ * fixed.
+ */
+function writeFamilyIntoMeta(metaPath, familyId) {
+  if (!existsSync(metaPath)) return false
+  try {
+    const src = readFileSync(metaPath, 'utf8')
+    if (/^\s*family\s*:/m.test(src)) return false // already has one — never overwrite
+    const m = src.match(/export\s+default\s*\{[ \t]*\r?\n/)
+    if (!m) return false
+    const at = m.index + m[0].length
+    const indent = src.slice(at).match(/^([ \t]+)/)?.[1] ?? '  '
+    writeFileSync(metaPath, `${src.slice(0, at)}${indent}family: '${familyId}',\n${src.slice(at)}`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * `category:` and `purpose:` were retired when `family:` landed.
+ *
+ * ⚖️ INFO, NOT A WARNING. Both are inert — nothing in the build, the runtime or
+ * the wire has ever read either — so a foundation carrying one is not broken and
+ * does not need to hurry. It is worth saying once, because a developer who sees
+ * `category:` in a neighbour's meta.js will reasonably copy it.
+ */
+export function checkRetiredMetaKeys({ foundationName, folderName, foundationDir, issues }) {
+  const schema = loadSchemaJson(foundationDir)
+  if (!schema) return
+  const stale = Object.entries(schema)
+    .filter(([key, v]) => !key.startsWith('_') && key !== 'dataSchemas' && v && typeof v === 'object')
+    .filter(([, v]) => v.category !== undefined || v.purpose !== undefined)
+  if (stale.length === 0) return
+
+  const id = 'section-retired-meta-key'
+  const keys = [...new Set(stale.flatMap(([, v]) => [
+    v.category !== undefined ? 'category' : null,
+    v.purpose !== undefined ? 'purpose' : null,
+  ].filter(Boolean)))]
+  issues.push({
+    id,
+    type: 'info',
+    foundation: foundationName,
+    message: `${stale.length} section(s) still declare ${keys.join(' / ')}`,
+  })
+  info(
+    `[${id}] ${folderName}: ${stale.length} section(s) still declare ` +
+      `${colors.dim}${keys.join(' / ')}${colors.reset} — retired, and read by nothing`
+  )
+  log(`    ${colors.dim}\`family:\` replaced them. Removing them changes no behaviour.${colors.reset}`)
+}
+
 /**
  * The gates kit exposes for a host service, and the field that IS the gate.
  *
@@ -888,6 +1070,11 @@ export async function doctor(args = []) {
   // each diagnostic below so the rewrite happens with full context.
   const fixFlag = parseFixFlag(args)
   const shouldFix = (id) => fixFlag === 'all' || fixFlag === id
+  // ⛔ SOME FIXES MUST NOT RIDE A BARE `--fix`. A fix derived from a GUESS — the
+  // family aliases, which exist in the CLI precisely so a human approves each
+  // one — becomes a silent write the moment `--fix` alone applies it, which is
+  // the failure the guess was moved here to avoid. Those checks ask for the id.
+  const shouldFixExplicitly = (id) => fixFlag === id
   const fixed = (msg) =>
     console.log(`  ${colors.green}↳ Fixed:${colors.reset} ${msg}`)
 
@@ -1054,6 +1241,26 @@ export async function doctor(args = []) {
     log(`      ${colors.dim}@import "@uniweb/kit/prose-tokens.css";${colors.reset}`)
   }
 
+  // ⛔ SAY WHEN A CHECK DID NOT RUN. Every foundation check below reads the
+  // BUILT `dist/meta/schema.json` — what a consumer actually receives — and
+  // returns silently when there is none. In a workspace with a site, "Foundation
+  // not built yet" turns up later under that site; in a FOUNDATION-ONLY
+  // workspace, which is the normal shape when a foundation is the product, it
+  // never does. The report then looks clean because nothing ran.
+  //
+  // That is the same class as the `dist/schema.json` path bug (a check that
+  // never fires is indistinguishable from a codebase with nothing to report),
+  // so it is named here rather than left to be rediscovered.
+  for (const f of foundations) {
+    if (!loadSchemaJson(f.path)) {
+      info(
+        `${f.folderName}: not built, so nothing was checked here ` +
+          `${colors.dim}(services, section families, retired keys)${colors.reset}`
+      )
+      log(`    ${colors.dim}Run \`uniweb build\` in ${f.folderName}, then doctor again.${colors.reset}`)
+    }
+  }
+
   // ── uniweb.supports — the services this foundation says it is built against ──
   for (const f of foundations) {
     await checkFoundationSupports({
@@ -1071,6 +1278,20 @@ export async function doctor(args = []) {
       srcDir: resolveFoundationSrcPath(f.path),
       issues
     })
+    checkSectionFamilies({
+      foundationName: f.name,
+      folderName: f.folderName,
+      foundationDir: f.path,
+      issues,
+      shouldFixExplicitly,
+      fixed
+    })
+    checkRetiredMetaKeys({
+      foundationName: f.name,
+      folderName: f.folderName,
+      foundationDir: f.path,
+      issues
+    })
   }
 
   // Extensions carry `uniweb.supports` too — same key, same field, and a site's
@@ -1093,6 +1314,22 @@ export async function doctor(args = []) {
       srcDir: resolveFoundationSrcPath(e.path),
       issues
     })
+    // An extension contributes section types by URL and lands in the same
+    // picker, so its sections need a family for exactly the same reason.
+    checkSectionFamilies({
+      foundationName: e.name,
+      folderName: e.folderName,
+      foundationDir: e.path,
+      issues,
+      shouldFixExplicitly,
+      fixed
+    })
+    checkRetiredMetaKeys({
+      foundationName: e.name,
+      folderName: e.folderName,
+      foundationDir: e.path,
+      issues
+    })
   }
 
   if (extensions.length > 0) {

package/src/commands/families.js

@@ -0,0 +1,82 @@
+/**
+ * `uniweb families` — the standard section families this CLI knows.
+ *
+ * ⭐ NAMED AFTER THE FIELD, not after the things it lists. A developer's question
+ * is "what can I put in `family:`?", and they will type the word they just read
+ * in a `meta.js` or a doctor warning.
+ *
+ * ⚠️ IT REPORTS THE ROSTER THIS CLI SHIPS WITH, not a live fetch — the list comes
+ * from the `@uniweb/schemas` version this CLI resolved. That is the right answer,
+ * because it is also the list `uniweb doctor` matched against. A newer family
+ * than your CLI will not appear, and declaring one is not fatal either way: an
+ * unrecognized value falls back to a generic illustration.
+ */
+
+import { FAMILIES, GROUPS } from '@uniweb/schemas/families'
+import { getCliVersion } from '../versions.js'
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m'
+}
+
+export async function families(args = []) {
+  if (args.includes('--json')) {
+    // ⛔ stdout carries JSON and nothing else, so it pipes. Every human-facing
+    // line in this command goes to stdout only in the non-JSON branch.
+    process.stdout.write(
+      JSON.stringify(
+        { cliVersion: getCliVersion(), count: FAMILIES.length, groups: GROUPS, families: FAMILIES },
+        null,
+        2
+      ) + '\n'
+    )
+    return
+  }
+
+  const filter = args.find((a) => !a.startsWith('-'))
+  const shown = filter
+    ? FAMILIES.filter(
+        (f) =>
+          f.id.includes(filter.toLowerCase()) ||
+          f.label.toLowerCase().includes(filter.toLowerCase()) ||
+          f.group === filter.toLowerCase()
+      )
+    : FAMILIES
+
+  console.log('')
+  console.log(
+    `${colors.bright}Section families${colors.reset} ${colors.dim}(uniweb ${getCliVersion()})${colors.reset}`
+  )
+
+  if (shown.length === 0) {
+    console.log('')
+    console.log(`  ${colors.dim}Nothing matches "${filter}".${colors.reset}`)
+    console.log(
+      `  ${colors.dim}A name of your own is fine — it falls back to a generic illustration.${colors.reset}`
+    )
+    console.log('')
+    return
+  }
+
+  const width = Math.max(...shown.map((f) => f.id.length))
+  for (const group of GROUPS) {
+    const rows = shown.filter((f) => f.group === group.id)
+    if (rows.length === 0) continue
+    console.log('')
+    console.log(`  ${colors.bright}${group.label}${colors.reset} ${colors.dim}— ${group.move}${colors.reset}`)
+    for (const f of rows) {
+      console.log(`    ${colors.cyan}${f.id.padEnd(width)}${colors.reset}  ${colors.dim}${f.label}${colors.reset}`)
+    }
+  }
+
+  console.log('')
+  console.log(`  ${colors.dim}Declare one in a section's meta.js:  family: 'hero'${colors.reset}`)
+  console.log(
+    `  ${colors.dim}A component already named for its family needs no declaration.${colors.reset}`
+  )
+  console.log(`  ${colors.dim}--json for scripts. uniweb doctor reports what your sections resolved to.${colors.reset}`)
+  console.log('')
+}

package/src/framework-index.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-09-15T03:16:10.815Z",
+  "generatedAt": "2026-09-16T03:38:43.897Z",
   "packages": {
     "@uniweb/api": {
       "version": "0.3.6",
@@ -10,7 +10,7 @@
       ]
     },
     "@uniweb/build": {
-      "version": "0.52.1",
+      "version": "0.52.2",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -34,7 +34,7 @@
       "deps": []
     },
     "@uniweb/core": {
-      "version": "0.29.3",
+      "version": "0.29.4",
       "path": "framework/core",
       "deps": [
         "@uniweb/semantic-parser",
@@ -54,7 +54,7 @@
       ]
     },
     "@uniweb/kit": {
-      "version": "0.19.1",
+      "version": "0.19.2",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core",
@@ -82,7 +82,7 @@
       ]
     },
     "@uniweb/runtime": {
-      "version": "0.26.3",
+      "version": "0.26.4",
       "path": "framework/runtime",
       "deps": [
         "@uniweb/core",
@@ -95,7 +95,7 @@
       "deps": []
     },
     "@uniweb/schemas": {
-      "version": "0.2.13",
+      "version": "0.2.14",
       "path": "framework/schemas",
       "deps": []
     },
@@ -110,7 +110,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.14.3",
+      "version": "0.14.4",
       "path": "framework/templates",
       "deps": []
     },

package/src/index.js

@@ -956,6 +956,13 @@ async function main() {
     return
   }
 
+  // Handle families command — the standard section families this CLI ships with
+  if (command === 'families') {
+    const { families } = await import('./commands/families.js')
+    await families(args.slice(1))
+    return
+  }
+
   // Handle template command
   if (command === 'template') {
     await template(args.slice(1))
@@ -1705,6 +1712,33 @@ ${colors.cyan}${colors.bright}uniweb handoff${colors.reset} ${colors.dim}— (re
 
 The site-handoff flow was retired with the legacy backend.
 Manage client sites from the Uniweb app for now.
+`,
+    families: `
+${colors.cyan}${colors.bright}uniweb families${colors.reset} ${colors.dim}— The standard section families${colors.reset}
+
+${colors.bright}Usage:${colors.reset}
+  uniweb families                List them, grouped
+  uniweb families <filter>       Match an id, a label or a group name
+  uniweb families --json         Machine-readable (for scripts)
+
+${colors.bright}What a family is for:${colors.reset}
+  It tells an editor which illustration to show for a section type, and gives
+  it a label it can translate. Declare it in a section's meta.js:
+
+    ${colors.dim}export default { title: 'Researcher Profile', family: 'profile' }${colors.reset}
+
+  ${colors.bright}Most components need no declaration.${colors.reset} The section type IS the component
+  name, so \`Hero\`, \`Footer\` and \`Pricing\` already resolve. \`family:\` is for the
+  ones whose name does not give it away — \`ProfileHero\`, \`CvEntry\`.
+
+  An unrecognized value is legal: it falls back to a generic illustration and
+  nothing breaks, so a foundation with its own vocabulary is never blocked.
+
+  \`uniweb doctor\` reports what each of your sections resolved to, and suggests
+  a family for the ones it recognizes by another name.
+
+${colors.bright}Note:${colors.reset} this is the roster ${colors.bright}this CLI ships with${colors.reset}, not a live fetch — and it is
+  the same list \`doctor\` matches against.
 `,
     template: `
 ${colors.cyan}${colors.bright}uniweb template${colors.reset} ${colors.dim}— Official templates${colors.reset}
@@ -1835,6 +1869,7 @@ ${colors.bright}Commands:${colors.reset}
   status             Show a site's sync state (unpushed content, foundation)
   inspect <path>     Inspect parsed content shape of a markdown file or folder
   docs               Generate component documentation
+  families           List the standard section families (for meta.js family:)
   doctor             Diagnose project configuration issues
   validate           Check your content against your foundation's data schemas
   update             Align workspace deps + AGENTS.md to the running CLI

package/starter/foundation/sections/Section/meta.js

@@ -1,8 +1,6 @@
 export default {
   title: 'Section',
   description: 'A versatile content section for headings, text, and links',
-  category: 'content',
-  purpose: 'Inform',
 
   content: {
     pretitle: 'Eyebrow text',