@getvitops/generator 8.3.0-alpha.1 → 8.3.0-alpha.3

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @getvitops/generator
 
+## 8.3.0-alpha.3
+
+### Patch Changes
+
+- @getvitops/config@8.3.0-alpha.3
+- @getvitops/utils@8.3.0-alpha.3
+
+## 8.3.0-alpha.2
+
+### Minor Changes
+
+- 0a47856: Build correctness and gaps from the second upstream round.
+
+  - **`@getvitops/emdash`: fixes a circular import that emptied the plugin block map in the static build.** `Section.astro` and `WidgetArea.astro` imported `emdash/ui` statically, which imports `virtual:emdash/block-components`, which is `@getvitops/emdash/astro` again. Depending on import order, every `vitops_*` block inside a section body was dropped from prerendered pages with only a `PortableText [components.type] is missing …` warning. Both now import it lazily, and a test fails if any renderer imports `emdash/ui` statically. No code change needed in sites.
+  - **`@getvitops/cli`: `vitops emdash build`** runs `astro build` and then `check-prerender`, and fails when the build reports a block type with no component (reported once per type). The template's `build`, `deploy` and `deploy:dev` scripts use it; existing sites replace `astro build && vitops emdash check-prerender` with `vitops emdash build`. `check-prerender` also warns (fails with `--strict`) on a page without exactly one `<h1>`.
+  - **`@getvitops/emdash`: `vitops_hero` and `vitops_section` heading level** accepts `h1`–`h6` and `p` (a heading that is styled but not in the outline). The hero defaults to `h1`; set the level to `2` on a page whose layout already renders an `h1` (the template's seed does).
+  - **`@getvitops/emdash`: `vitops_logos`** shows an entry's name as text (`.logos__name`) when it has no image. `@getvitops/core` adds the rule (all formats).
+  - **`@getvitops/emdash`: an empty content widget** (no text, no blocks) no longer renders its title, and an area whose widgets are all empty renders nothing.
+  - **`@getvitops/create`:** the template's `pages` collection gets `urlPattern: "/{slug}"` (the sitemap listed `/pages/<slug>`, which 404s; existing sites change it under Content Types), and `.gitignore` ignores only `src/styles/tailwind.css` and `tokens.json`, so site CSS kept in `src/styles/` is committed.
+  - **`@getvitops/emdash`: per-item colour.** The rows of `vitops_cards`, `vitops_stats`, `vitops_steps` and the hero's `cards` take their own `tone` / `color` (blank inherits the block's), so one block can hold a pine item and an amber one. Hero cards also take an `eyebrow` and a button (`ctaLabel` / `ctaHref`; with a button the card is no longer a stretched link).
+  - **`@getvitops/generator` / `@getvitops/emdash`: solid fills read.** The generator emits `--color-<hue>-<step>-on` for every step of every hue, the foreground for a fill at that step picked by the same APCA rule as `text-on-<role>` (css and tailwind formats, a plain `:root`, not `@theme`). A block fill chosen by `color` (hue and step) uses it instead of a fixed white..
+  - **`@getvitops/core`: `.counter__value.sr-only`** hides itself, so a build that never emitted the `.sr-only` utility no longer shows a counting figure twice (all formats).
+  - **`@getvitops/astro` / `@getvitops/core`: `SiteFooter` groups.** A top-level item of the `footer-sitemap` menu with children becomes a column (its label is the heading, its children the links, one level only); childless items stay in the flat list. Each column is a named `<nav>`.
+  - **`@getvitops/astro`: planned links and header buttons.** A menu item with `draft` in its CSS classes stays in the menu but is not rendered (at every level, in the header and the footer). `<SiteNav>` has an `actions` slot for header buttons that are not menu items, and an item with `cta` in its CSS classes renders as a button.
+  - **`@getvitops/cli`: `check-prerender` warnings** (fail with `--strict`): links to pages the build did not produce, a form with no delivery address (no `site.notifications.email`, location `email` or `site.crm`), and form fields missing from every `site.templates` form entry (the generated privacy policy reads those). It reads `./site.json`, or `--site=<path>`. `vitops setup … --dry-run` is accepted as `--dry`.
+  - **`@getvitops/emdash` / `@getvitops/astro`: "tick any number" form field** (`vitops_form` field kind `checkboxes`): a fieldset of checkboxes sharing one name. The conversion route joins repeated values (`IT, Marketing`) instead of keeping the last. The "required" toggle is not applied to the group (HTML cannot require one of several).
+  - **`@getvitops/core`: size hooks.** `.steps__title`, `.stats__figure` and `.card__title` read `--steps-title-size` (default one step below `heading`), `--stats-figure-size` and `--card-title-size`, set on the block through its `style` field. They set the `--heading-fs` / `--display-fs` properties the type-role utilities already read, so no extra class or prop is needed (all formats).
+  - **`@getvitops/create`:** the template's `site.json` lists its contact form under `site.templates`, so the privacy policy inventory and the new check agree.
+  - **`@getvitops/emdash`: `theme` on every block, on widget areas and on your own markup.** A `theme` select (`<role>` tinted, `<role>:solid` filled, populated from the site's roles by a new `themes/list` route) is a common field on every `vitops_*` block, applied to the block's own root with the role's computed readable text. `<VitopsWidgetArea theme="…">` takes the same, and `themeAttrs('surface')` gives `{ class, style }` for a layout `<body>`. `vitops_section`'s existing `theme` now goes through the same path.
+  - **`@getvitops/cli` / `@getvitops/emdash`: pages with a dropped block fail the build.** `vitops_section` and widget areas emit an invisible `<template data-vitops-unrendered="…">` for any body block with no renderer, and `check-prerender` fails the page naming the types (nested bodies only; `vitops emdash build` also scans the build log, which covers top-level bodies). A regression test imports the plugin entry first with a mock of the real virtual module, so the old import cycle fails it.
+  - **`@getvitops/emdash`: `formTemplateFromBlock(block)`** turns a saved `vitops_form` value into a `site.templates` form entry (names as submitted, a `checkboxes` field as a `checkbox` with options), to paste into `site.json` so the generated privacy policy lists what the form collects. The build cannot read the CMS database, so this is run by hand; `check-prerender` warns when fields are missing.
+  - **`@getvitops/utils`: `hasFormDelivery`** (`@getvitops/utils/notify`): the one test for "has this form anywhere to go", used by `check-prerender`.
+  - **`@getvitops/emdash`:** a `color` hue tint now flips with the colour scheme (`light-dark()`); hero option cards sit at `h2` under an `h1` hero; menu items also accept `hidden: true` (same as the `draft` class); `vitops docs blocks` documents `theme`, the per-row colours, the `--<role>-fs` type-size hook and the form checks.
+  - **`@getvitops/create`:** the template redirects `/home` to `/`, and the guides use `vp exec` instead of `vpx`.
+
+### Patch Changes
+
+- 0a47856: **Breaking: every block type is now `vitops_<name>`** (`vitops_cards`, `vitops_hero`, `vitops_actionLink`, …), where the Portable Text blocks were `vitops.<name>` and the section block type was already `vitops_section`. EmDash validates a block type's slug as `[a-z][a-z0-9_]*`, so `vitops.section` was never possible and the toolkit had two styles for one kind of thing. Underscore is the one form valid everywhere, so it is now the only one.
+
+  Migration: in stored content and in `seed/seed.json`, rename `_type` values from `vitops.<name>` to `vitops_<name>`; in `PortableText` `components`, rename the keys the same way; the `blocks: { include, exclude }` option takes full type names, so rename those too. `vt_*` names in a site are that site's own types and are unaffected. A search-and-replace of `vitops.(actionLink|imageCompare|copyButton|banner|details|carousel|gallery|cards|accordion|hero|marquee|logos|steps|stats|callout|entries|pricing|embed|form|reviews|nav|badges|widgetArea)` with `vitops_$1` covers it. `vitops emdash build` reports any block left on the old name as having no component.
+
+- Updated dependencies [0a47856]
+  - @getvitops/utils@8.3.0-alpha.2
+  - @getvitops/config@8.3.0-alpha.2
+
 ## 8.3.0-alpha.1
 
 ### Minor Changes

package/assets/css/patterns/card.css

@@ -33,3 +33,9 @@ wc-cards {
 [data-card-link] {
   cursor: pointer;
 }
+
+/* A card's title keeps the heading role's size unless `--card-title-size` is set on the block
+   (its `style` field). The role utility reads --heading-fs; `inherit` passes through the site's. */
+.card__title {
+  --heading-fs: var(--card-title-size, inherit);
+}

package/assets/css/patterns/counter.css

@@ -17,6 +17,11 @@
  * `display: none`/`visibility: hidden` stops contributing to the accessible
  * name, and that name must read the final value for the whole animation, not
  * just at rest.
+ *
+ * The visually-hidden rule is restated here for `.counter__value.sr-only` rather than left to the
+ * utility: a site whose build does not emit `.sr-only` (the tailwind format only generates
+ * utilities it sees used, and does not scan packages) would otherwise show the figure twice
+ * while it counts, once as text and once as the animation.
  */
 @property --_n {
   syntax: '<number>';
@@ -28,6 +33,18 @@
   display: none;
 }
 
+.counter__value.sr-only {
+  position: absolute;
+  inline-size: 1px;
+  block-size: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+
 wc-counter[running] .counter__presentation {
   display: inline;
   animation: counter-run var(--counter-duration, 1.2s) var(--counter-easing, var(--custom-ease-out))

package/assets/css/patterns/logos.css

@@ -6,6 +6,9 @@
  * Each item is a plain image, or a link around one. Marks are normalised to a common
  * height rather than a common width, because logos vary far more in aspect ratio than
  * in how tall they should read. `--grayscale` quiets them until hover or focus.
+ *
+ * An entry with no image is its name set as text (`.logos__name`): a partner without a wordmark
+ * still belongs in the row. The name is sized from the same `--logos-height` so it reads as a mark.
  */
 .logos {
   display: flex;
@@ -30,6 +33,23 @@
     object-fit: contain;
   }
 
+  .logos__name {
+    font-size: calc(var(--logos-height, 2.5rem) * 0.55);
+    line-height: 1.1;
+    font-weight: 600;
+    text-align: center;
+    text-wrap: balance;
+  }
+
+  &.logos--grayscale .logos__item .logos__name {
+    opacity: 0.7;
+    transition: opacity 0.2s;
+  }
+
+  &.logos--grayscale .logos__item:is(:hover, :focus-within) .logos__name {
+    opacity: 1;
+  }
+
   &.logos--grayscale .logos__item img {
     filter: grayscale(1);
     opacity: 0.7;

package/assets/css/patterns/sitenav.css

@@ -536,7 +536,7 @@
   }
 }
 
-/* ── In-page menu (`vitops.nav` block) ─────────────────────────────────────────
+/* ── In-page menu (`vitops_nav` block) ─────────────────────────────────────────
  *
  * A menu read in the body of a page — a site map, a section's links, footer-style columns —
  * as plain nested lists. No disclosure and no drawer: that is the header's job (`.sitenav`).
@@ -613,6 +613,14 @@
   }
 }
 
+/* Header buttons that are not menu items (`<SiteNav><a slot="actions" class="cta">…`). */
+.sitenav__actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.5rem;
+}
+
 /* ── Footer (`<SiteFooter>`) ───────────────────────────────────────────────── */
 .sitefooter {
   margin-block-start: var(--space-2xl, 3rem);
@@ -639,6 +647,16 @@
   gap: 0.25rem 1.25rem;
 }
 
+.sitefooter__heading {
+  margin: 0 0 0.5rem;
+}
+
+/* A column from a menu item with children: a heading over a stacked list. */
+.sitefooter__list--column {
+  flex-direction: column;
+  gap: 0.125rem;
+}
+
 .sitefooter__link {
   color: inherit;
   text-decoration: underline;

package/assets/css/patterns/stats.css

@@ -34,6 +34,9 @@
   }
 
   .stats__figure {
+    /* Display size by default; --stats-figure-size on the block overrides it (the role utility
+       reads --display-fs). `inherit` passes through whatever the site set for the role. */
+    --display-fs: var(--stats-figure-size, inherit);
     color: var(--tone-fg, inherit);
     font-variant-numeric: tabular-nums;
   }

package/assets/css/patterns/steps.css

@@ -69,6 +69,13 @@
   .steps__text {
     margin: 0;
   }
+
+  /* A step title is a sub-heading, not a section heading: one notch down from the role's size.
+     Set --steps-title-size on the block (its `style` field) to change it. The role utility reads
+     --heading-fs, so this sets the property it already consumes rather than fighting its layer. */
+  .steps__title {
+    --heading-fs: var(--steps-title-size, var(--text-l, 1.2rem));
+  }
 }
 
 /* Side by side once there is room: the marker sits above its text and the line runs across. */

package/dist/index.d.mts

@@ -67,7 +67,7 @@ interface GenerateOptions {
    * `tailwind` format only: directories (or globs) Tailwind should scan for class names, written
    * as `@source` lines after `@import "tailwindcss"`. Paths are relative to the emitted
    * `tailwind.css`. Tailwind v4 does not scan `node_modules`, so a utility used only by a package's
-   * own renderer (`font-display` in `vitops.stats`) is otherwise never generated — silently.
+   * own renderer (`font-display` in `vitops_stats`) is otherwise never generated — silently.
    * Ignored by the css and bricks formats, which ship every framework class.
    */
   sources?: string[];
@@ -273,9 +273,9 @@ interface TierEntry {
   bricks?: string;
   /**
    * `@getvitops/emdash` Portable Text block `_type`s that render this pattern, e.g.
-   * `vitops.carousel`. An array because one pattern can have several blocks
+   * `vitops_carousel`. An array because one pattern can have several blocks
    * (`details` has a single disclosure and an accordion group) and one block can span
-   * patterns (`vitops.actionLink` is `link`, `btn` and `cta`).
+   * patterns (`vitops_actionLink` is `link`, `btn` and `cta`).
    *
    * Tier 3, a sibling of `astro` and `bricks`: a block is a platform wrapper that an
    * editor drops into a page, and each one is an adapter over this entry's Astro
@@ -686,7 +686,7 @@ export declare function toHtmlFragment(blocks: Block[]): string;
  * Two deliberate mappings:
  *  - the `# ` heading is **dropped** — in EmDash the page title is a field
  *    (`data.title`), and repeating it as the first content block renders twice;
- *  - the review blockquote becomes a `vitops.banner` with `tone: "warning"`,
+ *  - the review blockquote becomes a `vitops_banner` with `tone: "warning"`,
  *    which is exactly the block the hand-written placeholder pages used.
  *
  * `_key`s are derived from position rather than randomness, so regenerating an

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/generate.ts","../src/docs.ts","../src/tiers.ts","../src/token-refs.ts","../src/legal/providers.ts","../src/legal/derive.ts","../src/legal/templates/cookies.ca.ts","../src/legal/templates/cookies.qc.ts","../src/legal/templates/privacy.ca.ts","../src/legal/templates/privacy.qc.ts","../src/legal/templates/terms.ca.ts","../src/legal/templates/terms.qc.ts","../src/legal/templates/index.ts","../src/legal/render.ts","../src/legal/index.ts","../src/robots.ts","../src/index.ts"],"mappings":";;;;;KAmDY;;;;;;;KAQA,mBAAmB,QAAQ;UAEtB;;;;;;;;;;;;;;;;EAgBf,gBAAgB,eAAe;;EAE/B,SAAS;;EAET;;EAEA;;;;;;EAMA;;;;;EAKA;;;;;;;;EAQA,gBAAgB;;;;;;;;;;EAUhB;;;;;;;;EAQA;;UAGe;EACf,QAAQ;EACR;EACA;;UA0Ce;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;;;wBA6Dc,mBACd,gBAAgB,kBAChB,+BACC;wBAm3DmB,SAAS,SAAS,kBAAkB,QAAQ;UC3rCjD;EACf;EACA;EACA,aAAa,eAAe;EAC5B;EACA,uBAAuB;EACvB,QAAQ;EACR,QAAQ;EACR;;;;;;;;;;;;;;;;;;;;qBA+HW,uBAAwB;UAoBpB;;EAEf;;EAEA;;;;;;;;;;;;;EAaA;;UAGe;;EAEf;;EAEA;EACA;;EAEA;;;;;EAKA;;EAEA;EACA,UAAU;;;;;;;;;;;;;;;;;wBAkBI,gBACd,QAAQ,gBACR,OAAM,oBACL;;;;;wBAqjDa,aAAa,IAAI,cAAc,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UC5oFlD;;;;;;EAMf;;EAEA;;;;;;;;;;;;;EAaA;;UAGe;EACf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;;;;EAKA;;UAGe;EACf,KAAK;EACL,KAAK;;;;;;EAML,QAAQ;;EAER;;;;;;;;;;;;;EAaA;;;;;;;EAOA;;EAEA;;qBAsBW,OAAO,eAAe;;qBAgkBtB;;wBAGG;EAAc;EAAa;EAAqB;;;;;;;;;;;KAepD;;UAGK;EACf;EACA,OAAO;;;;;;;;;;;;;;;;;;wBAmBO,aAAa,MAAM,OAAO;;;;;;;;;wBC/nB1B,YAAY,OAAO,eAAe,YAAY;;UCnF7C;;EAEf;;;;;;;EAOA;;UAGe;;EAEf;;EAEA;;;;;;;;;EASA;;;;;EAKA,UAAU;;;;;;;;;;;EAWV;EACA;;;;;;EAMA;;EAEA;;;;;;qBAOW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkJD,iCAAiC;;;;;;;;wBAgB7B,oBAAoB,KAAK,SAAS;wBA6ClC,kBAAkB,KAAK,SAAS;;;;;;;;;;;;;wBA2EhC,0BAA0B,KAAK;;;;;;;;;UC7U9B;EACf;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;EACA;;EAGA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;EAEA,YAAY;;;;;;;;EAQZ;IAAqB;IAAc;IAAiB;;;;;;;;EAOpD;;;;;EAKA;;;;;;;EAOA;IAAiB;IAAiB;;;;;;;;EAOlC;;;;;;;;EAQA;EACA;EACA;;EAEA;;EAEA;;EAEA;;;;;;EAMA;;EAEA;;wBAyHc,iBAAiB,KAAK,SAAS;iBC1O/B,UAAU,GAAG;iBCDb,UAAU,GAAG;iBCSb,UAAU,GAAG;iBCDb,UAAU,GAAG;iBCHb,QAAQ,GAAG;iBCHX,QAAQ,GAAG;KCKf;KAEA,SAAS,OAAO,WAAW,GAAG;qBAE7B;;;;;;;;;;;;;qBAMA,WAAW;;qBAGX,WAAW,OAAO;UCXd;EACf;EACA;EACA;;KAGU;EACN;EAAiB;EAAkB,OAAO;;EAC1C;EAAmB,OAAO;;EAC1B;EAAc,OAAO;;EACrB;EAAe,OAAO;;;wBA4CZ,cAAc,aAAa;;;;;wBAsE3B,eAAe,QAAQ,UAAU;wBAkBjC,eAAe,QAAQ;;;;;;;;;;;;;;wBAmBvB,eAAe,QAAQ,SAAS;KCrKpC;UAEK;;EAEf,OAAO;;EAEP,SAAS;;;wBAUK,YAAY,KAAK,SAAS;;wBAW1B,eAAe,KAAK,QAAQ,KAAK,UAAU,OAAO;;;;;;wBAclD,YAAY,KAAK,QAAQ,KAAK,WAAW;;;;;;;wBAUzC,cACd,KAAK,QACL,OAAM,uBACL;UCjDc;;EAEf;;;;;;;;;;;;;;wBAwBc,gBAAgB,KAAK,QAAQ,UAAS;;;;;;wBCyItC,iBAAiB;;;;;;;;;;;wBAkPjB,kBAAkB;EAChC;EACA;EACA;IACE"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/generate.ts","../src/docs.ts","../src/tiers.ts","../src/token-refs.ts","../src/legal/providers.ts","../src/legal/derive.ts","../src/legal/templates/cookies.ca.ts","../src/legal/templates/cookies.qc.ts","../src/legal/templates/privacy.ca.ts","../src/legal/templates/privacy.qc.ts","../src/legal/templates/terms.ca.ts","../src/legal/templates/terms.qc.ts","../src/legal/templates/index.ts","../src/legal/render.ts","../src/legal/index.ts","../src/robots.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -6,6 +6,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
 import { transform } from "lightningcss";
+import { pickOn } from "@getvitops/utils/color";
 import { AD_PLATFORMS, AD_PROVIDER_KEYS } from "@getvitops/utils/ads";
 import { generateIconInclude, nodesToHtml, resolveIcon, t } from "@getvitops/utils";
 import { resolveSitemapUrl } from "@getvitops/utils/indexing";
@@ -49,7 +50,7 @@ const TIERS = {
 		use: "`<Tree items={…} />` — it emits `<wc-tree>` itself, so do NOT add your own wrapper."
 	},
 	carousel: {
-		emdash: ["vitops.carousel"],
+		emdash: ["vitops_carousel"],
 		css: c([
 			"carousel",
 			"carousel__track",
@@ -67,7 +68,7 @@ const TIERS = {
 		use: "`<Carousel slides={…} label=\"…\" />` — it emits `<wc-carousel>` itself, so do NOT add your own wrapper. `.carousel` is the shell and `.carousel__track` the scroller; add `loop` for the cloned infinite strip (`autoplay` implies it)."
 	},
 	gallery: {
-		emdash: ["vitops.gallery"],
+		emdash: ["vitops_gallery"],
 		css: c([
 			"gallery",
 			"gallery__item",
@@ -83,7 +84,7 @@ const TIERS = {
 		use: "`<Gallery images={…} label=\"…\" />` — it emits `<wc-gallery>` wrapping a `<Carousel />` (which emits its own `<wc-carousel>`) itself, so do NOT add your own wrapper around either. Each thumbnail is a plain `<a href=\"#slide-id\">` into the carousel's own `<li id=\"slide-id\">` inside a single `<dialog class=\"lightbox-dialog\">` (see `lightbox`), so it is a working modal lightbox — WITH prev/next — before any script runs. Stepping between images is the carousel's job, not the gallery's."
 	},
 	entries: {
-		emdash: ["vitops.entries"],
+		emdash: ["vitops_entries"],
 		css: c([
 			"entries__table",
 			"entries__scroll",
@@ -99,7 +100,7 @@ const TIERS = {
 		use: "`<Entries entries={[{ heading, pairs: [{ term, value }] }]} />` — it emits `<wc-entries>` itself, so do NOT add your own wrapper. By hand: `<wc-entries>` around `<h3>` + `<dl>` pairs. The tier-2 exemplar: semantic pairs with no JS, a table with it."
 	},
 	copy: {
-		emdash: ["vitops.copyButton"],
+		emdash: ["vitops_copyButton"],
 		css: c([
 			"copy",
 			"copy__button",
@@ -115,7 +116,7 @@ const TIERS = {
 		use: "`<wc-copy>` around the content and a `[data-copy]` button."
 	},
 	dismissable: {
-		emdash: ["vitops.banner"],
+		emdash: ["vitops_banner"],
 		css: c(["banner__close", "notification__close"], "patterns/banner.css"),
 		wc: {
 			tag: "wc-dismissable",
@@ -141,7 +142,7 @@ const TIERS = {
 		use: "`<wc-split-panel>` with two children. Unenhanced they simply stack."
 	},
 	"image-compare": {
-		emdash: ["vitops.imageCompare"],
+		emdash: ["vitops_imageCompare"],
 		css: c([
 			"image-compare",
 			"image-compare__before",
@@ -156,7 +157,7 @@ const TIERS = {
 		use: "`<wc-image-compare>` with two images. Both are visible without JS."
 	},
 	marquee: {
-		emdash: ["vitops.marquee"],
+		emdash: ["vitops_marquee"],
 		css: c([
 			"marquee",
 			"marquee__content",
@@ -194,7 +195,7 @@ const TIERS = {
 		use: "`.section.region` > `.centered` > `.section__inner` holding `.section__head` (kicker, heading, sub) and `.section__body`. `.section--split` puts the head beside the body when wide. In EmDash it is a block TYPE (`vitops_section`) with a Portable Text body that accepts any other block — see `vitopsBlockTypes()`."
 	},
 	steps: {
-		emdash: ["vitops.steps"],
+		emdash: ["vitops_steps"],
 		css: c([
 			"steps",
 			"steps__item",
@@ -206,7 +207,7 @@ const TIERS = {
 		use: "`<ol class=\"steps tone\">` of `<li class=\"steps__item\">` each holding a `.steps__body` with a real heading. The number is a CSS counter and the connector line a pseudo-element; `.steps--row` runs it sideways when wide."
 	},
 	stats: {
-		emdash: ["vitops.stats"],
+		emdash: ["vitops_stats"],
 		css: c([
 			"stats",
 			"stats__item",
@@ -219,7 +220,7 @@ const TIERS = {
 		use: "`<ul class=\"stats\">` of `.stats__item`, each figure a `<Counter>`. `.stats--tiles` adds `.stats__group` and `.stats__delta`; `data-state=\"up|down\"` colours the delta through the success/danger roles."
 	},
 	callout: {
-		emdash: ["vitops.callout"],
+		emdash: ["vitops_callout"],
 		css: c([
 			"callout",
 			"callout__body",
@@ -231,16 +232,17 @@ const TIERS = {
 		use: "`.callout.tone` with a `.callout__body` and `.callout__actions`. A call-to-action band that stays on the page — NOT `banner`, which is a dismissible announcement."
 	},
 	logos: {
-		emdash: ["vitops.logos"],
+		emdash: ["vitops_logos"],
 		css: c([
 			"logos",
 			"logos__item",
+			"logos__name",
 			"logos--grayscale"
 		], "patterns/logos.css"),
-		use: "`<ul class=\"logos\">` of `.logos__item` images (alt text = the name). A still grid; `marquee` is the scrolling version."
+		use: "`<ul class=\"logos\">` of `.logos__item` images (alt text = the name), or `.logos__name` text when there is no image. A still grid; `marquee` is the scrolling version."
 	},
 	embed: {
-		emdash: ["vitops.embed"],
+		emdash: ["vitops_embed"],
 		css: c([
 			"embed",
 			"embed__frame",
@@ -249,7 +251,7 @@ const TIERS = {
 		use: "`.embed` around an `<iframe class=\"embed__frame\" data-consent=\"marketing\" data-consent-src=\"…\">` with NO `src`, and a `.embed__placeholder`. The consent runtime assigns the address after the grant; the placeholder holds a real link. Never give the iframe a live `src`."
 	},
 	counter: {
-		emdash: ["vitops.stats"],
+		emdash: ["vitops_stats"],
 		css: c([
 			"counter",
 			"counter__value",
@@ -264,7 +266,7 @@ const TIERS = {
 		use: "`<Counter value=\"94%\" />` — it emits `<wc-counter>` itself, so do NOT add your own wrapper. The final value is parsed from the fallback text, never passed separately."
 	},
 	"multi-field": {
-		emdashExempt: "repeats rows a visitor adds at submit time (several phone numbers, guests); `vitops.form` has a fixed, editor-defined field list and no such field type",
+		emdashExempt: "repeats rows a visitor adds at submit time (several phone numbers, guests); `vitops_form` has a fixed, editor-defined field list and no such field type",
 		css: c([
 			"form-group",
 			"input-group",
@@ -279,14 +281,14 @@ const TIERS = {
 		use: "`<wc-multi-field>` around a field template. One row submits fine with no JS."
 	},
 	turnstile: {
-		emdash: ["vitops.form"],
+		emdash: ["vitops_form"],
 		css: c(["form-group"], "patterns/forms.css"),
 		wc: {
 			tag: "wc-turnstile",
 			registered: true,
 			adds: "loads Cloudflare Turnstile on first interaction with the form and holds a submit until its token arrives"
 		},
-		use: "`<wc-turnstile sitekey=\"…\">` inside a `<form>`, around a paragraph saying the spam check needs JavaScript. Pair it with `createConversionRoute({ turnstile })`; the `vitops.form` block does both."
+		use: "`<wc-turnstile sitekey=\"…\">` inside a `<form>`, around a paragraph saying the spam check needs JavaScript. Pair it with `createConversionRoute({ turnstile })`; the `vitops_form` block does both."
 	},
 	"color-scheme-toggle": {
 		emdashExempt: "site chrome (header/footer), not page content; belongs in the nav/layout",
@@ -375,7 +377,7 @@ const TIERS = {
 		use: "Not shipped. See `color-wheel`."
 	},
 	details: {
-		emdash: ["vitops.details", "vitops.accordion"],
+		emdash: ["vitops_details", "vitops_accordion"],
 		css: c([
 			"details",
 			"details-trigger",
@@ -413,7 +415,7 @@ const TIERS = {
 		use: "`<NavShell>` with a `nav` slot, plus `<NavShellToggle>` if the toggle must live outside the shell."
 	},
 	subgrid: {
-		emdash: ["vitops.pricing"],
+		emdash: ["vitops_pricing"],
 		css: c([
 			"subgrid",
 			"subgrid-card",
@@ -423,8 +425,8 @@ const TIERS = {
 		use: "`<Subgrid>` — emits `<ul class=\"subgrid\" role=\"list\">`; author `<li class=\"card subgrid-card\">` items yourself, so tranches align across the set."
 	},
 	card: {
-		emdash: ["vitops.cards"],
-		css: c(["card"], "patterns/card.css", true),
+		emdash: ["vitops_cards"],
+		css: c(["card", "card__title"], "patterns/card.css", true),
 		wc: {
 			tag: "wc-cards",
 			registered: true,
@@ -444,7 +446,7 @@ const TIERS = {
 		use: "`<Icon name=\"menu\" />`. Names are semantic and resolve per configured set; a name containing `:` passes through."
 	},
 	split: {
-		emdash: ["vitops.hero"],
+		emdash: ["vitops_hero"],
 		css: c([
 			"split",
 			"split-1-2",
@@ -472,9 +474,9 @@ const TIERS = {
 			"navlist--columns"
 		], "patterns/sitenav.css"),
 		astro: [...a("SiteNav", "css"), ...a("SiteFooter", "css")],
-		emdash: ["vitops.nav"],
+		emdash: ["vitops_nav"],
 		bricks: "vitops-sitenav",
-		use: "`.sitenav` with `--bp-*` and a drawer direction. `<details>` + Invoker Commands, no JS. In Astro: `<SiteNav {...await loadNavMenus(getMenu)} />` renders EmDash menu `primary` (the default: dropdowns from `md`, drawer below) and, if they exist, `primary-mobile` (depth-1 nav below `md`) and `primary-mega` (mega panels from `xl`) — adding the menu in the admin is the whole change. An item's `titleAttr` is its description. `<SiteFooter sitemap legal name>` renders `footer-sitemap` + `footer-legal` + the copyright line. For a menu inside page content (a site map, a section's links, footer-style columns) use `.navlist` — plain nested lists, `--inline` / `--columns` — or, in EmDash, the `vitops.nav` block (menu, layout `list|inline|columns|sitenav`, depth 1–3, heading, tone). Name each `<nav>` uniquely: the header is `Primary` and the footer `Site map` / `Legal`, and the block never reuses those."
+		use: "`.sitenav` with `--bp-*` and a drawer direction. `<details>` + Invoker Commands, no JS. In Astro: `<SiteNav {...await loadNavMenus(getMenu)} />` renders EmDash menu `primary` (the default: dropdowns from `md`, drawer below) and, if they exist, `primary-mobile` (depth-1 nav below `md`) and `primary-mega` (mega panels from `xl`) — adding the menu in the admin is the whole change. An item's `titleAttr` is its description. `<SiteFooter sitemap legal name>` renders `footer-sitemap` + `footer-legal` + the copyright line. For a menu inside page content (a site map, a section's links, footer-style columns) use `.navlist` — plain nested lists, `--inline` / `--columns` — or, in EmDash, the `vitops_nav` block (menu, layout `list|inline|columns|sitenav`, depth 1–3, heading, tone). Name each `<nav>` uniquely: the header is `Primary` and the footer `Site map` / `Legal`, and the block never reuses those."
 	},
 	"split-link": {
 		css: c([
@@ -486,17 +488,17 @@ const TIERS = {
 		use: "`.split-link` — a link plus a disclosure toggle. No JS."
 	},
 	btn: {
-		emdash: ["vitops.actionLink"],
+		emdash: ["vitops_actionLink"],
 		css: c(["btn"], void 0, true),
 		use: "`<button>` gets it with no class; `.btn` carries it to other tags. `fill: false`, so states drive `color`."
 	},
 	cta: {
-		emdash: ["vitops.actionLink"],
+		emdash: ["vitops_actionLink"],
 		css: c(["cta", "cta-danger"], void 0, true),
 		use: "`.cta` on any element — usually `<a>`, since a CTA navigates. Filled, with role variants."
 	},
 	link: {
-		emdash: ["vitops.actionLink"],
+		emdash: ["vitops_actionLink"],
 		css: c([
 			"link",
 			"skip-link",
@@ -506,18 +508,18 @@ const TIERS = {
 		use: "`<a>` gets it at zero specificity; `.link` for other tags. `.stretched-link` makes one link cover its positioned ancestor (whole-card click, no JS — but the card text stops being selectable); `.raised` lifts content back above that overlay."
 	},
 	badge: {
-		emdash: ["vitops.badges"],
+		emdash: ["vitops_badges"],
 		css: c(["badge", "badge-indicator"], "patterns/tag.css", true),
 		use: "`.badge` — a STATIC label. Use `tag` if it is dismissable or editable."
 	},
 	"widget-area": {
-		emdash: ["vitops.widgetArea"],
+		emdash: ["vitops_widgetArea"],
 		css: c([
 			"widget-area",
 			"widget__title",
 			"widget__menu"
 		], "patterns/widget-area.css"),
-		use: "Editor-managed regions: `<VitopsWidgetArea name=\"footer-columns\" />` (`@getvitops/emdash/astro`) renders an area from Widgets in the admin — titled groups, a menu as a labelled `<nav>`, content as Portable Text. In a page, the `vitops.widgetArea` block places one. An area holding a `core:*` component widget falls back to EmDash's own renderer, and an area cannot hold another. Prerendered pages show an edit after the next deploy."
+		use: "Editor-managed regions: `<VitopsWidgetArea name=\"footer-columns\" />` (`@getvitops/emdash/astro`) renders an area from Widgets in the admin — titled groups, a menu as a labelled `<nav>`, content as Portable Text. In a page, the `vitops_widgetArea` block places one. An area holding a `core:*` component widget falls back to EmDash's own renderer, and an area cannot hold another. Prerendered pages show an edit after the next deploy."
 	},
 	tag: {
 		css: c([
@@ -581,8 +583,8 @@ const TIERS = {
 			"review__source"
 		], "patterns/review.css", true),
 		astro: a("ReviewCard", "css"),
-		emdash: ["vitops.reviews"],
-		use: "`<ReviewCard review={…} />` — one card, from `vitops reviews`' `.vitops/reviews.json` cache. Put several inside `<Carousel>` slides or `<Marquee>` items; there is no group component and no `wc-review`. In EmDash, `vitops.reviews` is that whole row: it reads the cache as a build-time import (`virtual:getvitops/reviews`, served by `vitops()`; empty when the file is absent), picks reviews with `selectReviews()`, and lays them out as a grid, carousel or marquee. A new review appears after `vitops reviews` is re-run, committed and the site rebuilt."
+		emdash: ["vitops_reviews"],
+		use: "`<ReviewCard review={…} />` — one card, from `vitops reviews`' `.vitops/reviews.json` cache. Put several inside `<Carousel>` slides or `<Marquee>` items; there is no group component and no `wc-review`. In EmDash, `vitops_reviews` is that whole row: it reads the cache as a build-time import (`virtual:getvitops/reviews`, served by `vitops()`; empty when the file is absent), picks reviews with `selectReviews()`, and lays them out as a grid, carousel or marquee. A new review appears after `vitops reviews` is re-run, committed and the site rebuilt."
 	},
 	tabs: {
 		css: c(["tabs"], void 0, true),
@@ -606,7 +608,7 @@ const TIERS = {
 		use: "`.navbar` with `--start/--center/--end`."
 	},
 	banner: {
-		emdash: ["vitops.banner"],
+		emdash: ["vitops_banner"],
 		css: c([
 			"banner",
 			"banner__content",
@@ -2505,7 +2507,7 @@ ${bricks}
 Portable Text block ${code("_type")}s from ${code("@getvitops/emdash")}. Repeating patterns are
 repeater fields. A Portable Text block cannot contain other blocks, so a pattern that must hold
 them is a schema-level block TYPE with a Portable Text body instead — ${code("vitops_section")},
-from ${code("vitopsBlockTypes()")}. Its body accepts every ${code("vitops.*")} block below.
+from ${code("vitopsBlockTypes()")}. Its body accepts every ${code("vitops_*")} block below.
 
 | Block | Pattern | Renders via |
 | --- | --- | --- |
@@ -4429,7 +4431,7 @@ function toHtmlFragment(blocks) {
 * Two deliberate mappings:
 *  - the `# ` heading is **dropped** — in EmDash the page title is a field
 *    (`data.title`), and repeating it as the first content block renders twice;
-*  - the review blockquote becomes a `vitops.banner` with `tone: "warning"`,
+*  - the review blockquote becomes a `vitops_banner` with `tone: "warning"`,
 *    which is exactly the block the hand-written placeholder pages used.
 *
 * `_key`s are derived from position rather than randomness, so regenerating an
@@ -4442,7 +4444,7 @@ function toPortableText(blocks, prefix) {
 		if (b.kind === "heading" && b.level === 1) return;
 		if (b.kind === "quote") {
 			out.push({
-				_type: "vitops.banner",
+				_type: "vitops_banner",
 				_key: key,
 				message: b.spans.map((s) => s.text).join(""),
 				tone: "warning",
@@ -4494,7 +4496,7 @@ const REVIEW_NOTICE = "> Generated from this site's configuration. It is a start
 * designated and is published, that a privacy impact assessment precedes any
 * communication outside Quebec, that consent mechanics match the Act, and — easy
 * to miss — that content directed at Quebec consumers is available in French. It
-* is a second blockquote (a second `vitops.banner` in Portable Text) so it cannot
+* is a second blockquote (a second `vitops_banner` in Portable Text) so it cannot
 * be skimmed past as part of the first.
 */
 const QC_REVIEW_NOTICE = "> Quebec (Law 25): this document is written for the Quebec privacy regime and has NOT been reviewed by counsel. Before publishing, have a lawyer confirm that a person in charge of the protection of personal information is designated, that any transfer of information outside Quebec is preceded by a privacy impact assessment, that your consent and cookie mechanisms match the Act, and whether a French version is required for your audience. It is not legal advice.";
@@ -5234,6 +5236,18 @@ function generateLegal(cfg, opts = {}) {
 */
 const HERE = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_ASSETS = join(HERE, "..", "assets");
+/**
+* `--color-<hue>-<step>-on`: the readable text colour for a fill at that step, computed with the
+* same APCA pick as `text-on-<role>`. A role has one (`--color-text-on-<role>`); a raw hue step
+* did not, so a block filling with `color: amber-500` had no site-defined foreground to use. These
+* live in a plain `:root`, never `@theme`: a `--color-*` theme key would mint `text-<hue>-<step>-on`
+* utilities nobody asked for.
+*/
+function hueOnTokens(palette) {
+	const out = [];
+	for (const [name, hue] of Object.entries(palette)) for (const [n, hex] of Object.entries(hue.numeric)) out.push(`--color-${name}-${n}-on: ${pickOn(hex)};`);
+	return out;
+}
 const UTILITY_PROPS = {
 	bg: "background-color",
 	text: "color",
@@ -5522,6 +5536,8 @@ function build(ds, format, assetsDir, buildOpts = {}) {
 		css += `  color-scheme: ${buildOpts.darkOnly ? "dark" : "light"};\n`;
 		css += `  /* Hue scales (numeric steps, 50 = tinted near-white … 950 = tinted near-black) */\n`;
 		for (const [name, hue] of Object.entries(expandedPalette)) for (const [n, hex] of Object.entries(hue.numeric)) css += `  --color-${name}-${n}: ${hex};\n`;
+		css += `\n  /* Foreground for a fill at a hue step (--color-<hue>-<step>-on) */\n`;
+		for (const line of hueOnTokens(expandedPalette)) css += `  ${line}\n`;
 		css += `\n  /* Role tokens (the public API) */\n`;
 		for (const fr of scaleRoles) for (const [t, val] of Object.entries(fr.light)) css += `  ${tokenVar(fr.role, t)}: ${val};\n`;
 		if (focusRole) {
@@ -6034,6 +6050,7 @@ function emitTailwind(ctx) {
 			fn += `  --surface-glass: color-mix(in oklch, var(--color-bg-surface) 72%, transparent);\n`;
 			fn += `  --overlay: color-mix(in oklch, var(--color-${surface.hue}-950) 45%, transparent);\n`;
 		}
+		for (const line of hueOnTokens(expandedPalette)) fn += `  ${line}\n`;
 		if (ctx.darkOnly) fn = `  color-scheme: dark;\n${fn}`;
 		parts.push(`/* Role tokens (the public API) */\n:root {\n${fn}}\n`);
 	}