@diviops/mcp-server 1.5.12 → 1.5.14

package/dist/preset-cli/spacing-emitter.js

@@ -0,0 +1,276 @@
+/**
+ * `divi/spacing` section group-preset emitter — Track 7b vertical slice.
+ *
+ * Emits a byte-canonical Divi 5.6.0 `type: "group"` `divi/spacing` preset
+ * targeting `divi/section` at
+ * `attrs.module.decoration.spacing.desktop.value.{padding|margin}.*`,
+ * gated by the verified-attrs registry. Canonical shape:
+ * `docs/verification/evidence/canonical-shape-dumps-2026-05-23/round-5-spacing-section.json`.
+ *
+ * Scope: `divi/section` ONLY. Heading / text / button spacing cells remain
+ * `SCHEMA_OBSERVED` and resolve to `EvidenceGateError` here per
+ * `feedback_preset_map_per_module` (no cross-module shape carry-over).
+ *
+ * Shape rules enforced here (brief §4):
+ *  - Sparse-emit per axis — only user-touched corners appear under
+ *    `padding`/`margin`. Untouched corners are absent (not present-as-empty,
+ *    not present-as-null).
+ *  - Paired sync flags per axis — any spacing touch on an axis emits BOTH
+ *    `syncVertical` AND `syncHorizontal` as siblings. Default `"off"` on
+ *    both unless the caller explicitly toggled them.
+ *  - Padding and margin are INDEPENDENT bags — passing only padding flags
+ *    omits the margin bag entirely, and vice versa.
+ *  - `attrs == styleAttrs == renderAttrs` at the route layer (the plugin's
+ *    `/preset/create` route mirrors `attrs` into all three buckets to match
+ *    VB save semantics); the CLI request body only carries `attrs`. The
+ *    Track 7a fixture captures the post-write storage shape — do NOT add
+ *    `styleAttrs` / `renderAttrs` keys to the emitter output.
+ *  - `groupId: "designSpacing"` — the Composable Settings panel id, NOT a
+ *    dotted attr path (the prior schema-inferred `module.decoration.spacing`
+ *    note was a misread, corrected in PR #751).
+ *  - `primaryAttrName: "module"` for section spacing.
+ *  - Variable tokens (`$variable(...)` / bare `gvid-*`) in length flags are
+ *    REFUSED — Track 7a capture exercised literal CSS lengths only;
+ *    variable-token shape needs its own capture before this emitter writes
+ *    it.
+ */
+import { loadRegistry, gateWriteAttr, } from "./registry.js";
+export const SPACING_GROUP_NAME = "divi/spacing";
+export const SPACING_GROUP_ID = "designSpacing";
+export const SPACING_PRIMARY_ATTR_NAME = "module";
+export const SPACING_PATTERN_FAMILY = "divi/spacing";
+/**
+ * The single currently-supported module cell. The `--module` flag accepts
+ * any string and routes through the registry gate (so the surface stays
+ * stable when heading/text/button cells eventually promote), but only
+ * `divi/section` is wired with fixtures + tests + canonical shape today.
+ *
+ * Promoting another module is NOT a free dispatch-clear via the registry
+ * gate — each new cell needs a Track-7a-style canonical capture PR landing
+ * first AND a follow-up implementation/docs PR.
+ */
+export const SPACING_SUPPORTED_MODULES = ["divi/section"];
+/** Detect bare `gvid-*` / `gcid-*` variable token names. */
+const BARE_VARIABLE_TOKEN_RE = /^(gvid|gcid)-/;
+/**
+ * Positive validator for CSS length values. Accepts only the v1 unit set
+ * from the brief: integer or decimal numbers (including a leading minus
+ * sign and bare `0`) followed by `px`, `rem`, `em`, `%`, `vw`, or `vh`.
+ * Track 7a capture exercised literal values only — variable tokens,
+ * `var(...)`, `calc(...)`, and free-form strings like `banana` are all
+ * refused before emission. Adding any new unit requires a brief update
+ * (canonical-capture re-test if the unit changes server-side rendering).
+ */
+const LITERAL_CSS_LENGTH_RE = /^-?(?:\d+\.?\d*|\.\d+)(?:px|rem|em|%|vw|vh)$/;
+/**
+ * Validate that `value` is a literal CSS length and not a deferred-shape
+ * token. The check runs on EVERY length flag before the emission path.
+ *
+ * Three refusal paths:
+ *  1. `$variable(...)` token — deferred shape, needs its own capture.
+ *  2. Bare `gvid-*` / `gcid-*` token name — same deferred shape.
+ *  3. Anything else that does NOT match the v1 literal CSS length grammar
+ *     (`px`, `rem`, `em`, `%`, `vw`, `vh`). Catches `banana`, `var(--x)`,
+ *     `calc(8px + 2vw)`, etc. — none of which Track 7a verified.
+ *
+ * The variable-token branches fire BEFORE the generic literal check so
+ * the operator gets the precise "variable-token support deferred" hint
+ * rather than the generic "not a literal CSS length" message.
+ */
+function assertLiteralLength(value, flagLabel) {
+    // Trim before pattern-matching so leading / trailing whitespace can't
+    // bypass any prefix check (e.g. " gvid-space-1"). The raw value
+    // appears in the error message so the operator sees exactly what was
+    // passed.
+    const trimmed = value.trim();
+    if (trimmed.startsWith("$variable(")) {
+        throw new Error(`${flagLabel} value ${JSON.stringify(value)} is a $variable() token. ` +
+            `Variable-token support deferred — pending canonical capture. ` +
+            `Track 7a exercised literal CSS length values only (px / rem / em / % / vw / vh).`);
+    }
+    if (BARE_VARIABLE_TOKEN_RE.test(trimmed)) {
+        throw new Error(`${flagLabel} value ${JSON.stringify(value)} is a bare ${trimmed.split("-")[0]}-* variable token. ` +
+            `Variable-token support deferred — pending canonical capture. ` +
+            `Track 7a exercised literal CSS length values only (px / rem / em / % / vw / vh).`);
+    }
+    if (!LITERAL_CSS_LENGTH_RE.test(trimmed)) {
+        throw new Error(`${flagLabel} value ${JSON.stringify(value)} is not a literal CSS length. ` +
+            `v1 accepts only \`<number><unit>\` where unit is one of px / rem / em / % / vw / vh ` +
+            `(e.g. "40px", "1.5rem", "100%"). Track 7a canonical capture exercised literal ` +
+            `values only; broader value grammars (var(...), calc(...), etc.) need their own capture.`);
+    }
+}
+/**
+ * Compose a single axis bag (padding or margin) from a corner input.
+ *
+ * Returns `undefined` when the axis input is entirely absent (the axis is
+ * absent from the emitted attrs — sparse-emit at axis level). When ANY
+ * corner is passed, both sync flags are emitted as paired siblings
+ * (default `"off"` on each side unless the caller explicitly toggled
+ * them).
+ *
+ * Sync-flag-only input on an axis with no touched corner is REFUSED with
+ * an explicit error — silently no-op'ing a passed sync flag would be a
+ * surprising footgun. If the caller wants to toggle sync, they must also
+ * pass at least one corner on the same axis to anchor it.
+ */
+function composeAxis(input, flagPrefix) {
+    if (!input)
+        return undefined;
+    const corners = ["top", "right", "bottom", "left"].filter((c) => input[c] !== undefined);
+    if (corners.length === 0) {
+        // Sync flag passed without any corner on the same axis → explicit
+        // refusal. The paired sync flags only have meaning anchored to at
+        // least one corner; emitting them alone would silently drop them.
+        if (input.syncVertical !== undefined ||
+            input.syncHorizontal !== undefined) {
+            throw new Error(`--${flagPrefix}-sync-vertical / --${flagPrefix}-sync-horizontal require at ` +
+                `least one --${flagPrefix}-{top,right,bottom,left} corner on the same axis. ` +
+                `Sync flags are paired-sibling metadata anchored to corners; emitting them ` +
+                `alone would silently no-op.`);
+        }
+        return undefined;
+    }
+    const bag = {};
+    for (const c of corners) {
+        const v = input[c];
+        if (typeof v !== "string" || v.length === 0) {
+            throw new Error(`--${flagPrefix}-${c} requires a non-empty CSS length value.`);
+        }
+        assertLiteralLength(v, `--${flagPrefix}-${c}`);
+        bag[c] = v;
+    }
+    bag.syncVertical = input.syncVertical ?? "off";
+    bag.syncHorizontal = input.syncHorizontal ?? "off";
+    return bag;
+}
+/**
+ * Compose the canonical
+ * `attrs.module.decoration.spacing.desktop.value.{padding|margin}` bag.
+ * Sparse-emit per axis; padding and margin are independent.
+ *
+ * Returns BOTH the full `attrs` tree (what the emitter ships) AND the
+ * inner `value` bag — the caller does empty-preset validation against
+ * `value` without re-walking the nested attrs tree (no `as any` deep
+ * casts).
+ */
+export function composeSpacingAttrs(input) {
+    const padding = composeAxis(input.padding, "padding");
+    const margin = composeAxis(input.margin, "margin");
+    const value = {};
+    if (padding)
+        value.padding = padding;
+    if (margin)
+        value.margin = margin;
+    const attrs = {
+        [SPACING_PRIMARY_ATTR_NAME]: {
+            decoration: {
+                spacing: {
+                    desktop: {
+                        value,
+                    },
+                },
+            },
+        },
+    };
+    return { attrs, value };
+}
+/**
+ * Emit a canonical `divi/spacing` section group preset.
+ *
+ * 1. Validate input shape (name, module, at least one corner across either
+ *    axis).
+ * 2. Reject variable-token values in any length flag (deferred until a
+ *    canonical capture lands).
+ * 3. Compose sparse-emit `attrs.module.decoration.spacing.desktop.value.*`
+ *    with paired sync flags.
+ * 4. Gate `(divi/spacing, <module>)` against the verified-attrs registry —
+ *    throws `EvidenceGateError` when effective evidence is below
+ *    `VB_PRESET_STORAGE_VERIFIED`.
+ *
+ * `styleAttrs` and `renderAttrs` are intentionally NOT part of this entry:
+ * the plugin's `/preset/create` route mirrors the single `attrs` bag into
+ * all three buckets at write time. The Track 7a fixture captures the
+ * post-write storage shape (which is why both `attrs` and `styleAttrs`
+ * appear there byte-identical); the CLI emits the request shape only.
+ */
+export function emitSpacingGroupPreset(input, registry = loadRegistry()) {
+    if (!input.name || typeof input.name !== "string") {
+        throw new Error("spacing emitter requires a non-empty `name`.");
+    }
+    if (!input.module || typeof input.module !== "string") {
+        throw new Error("spacing emitter requires `module` — currently only `divi/section` is " +
+            "wired (other module cells are SCHEMA_OBSERVED in the registry; " +
+            "promoting them requires a Track-7a-style canonical capture PR + a " +
+            "follow-up implementation/docs PR).");
+    }
+    const { attrs, value } = composeSpacingAttrs(input);
+    // Empty-input rejection: at least one corner across either axis MUST be
+    // specified. An empty value bag is a usage error — there is nothing to
+    // write, and the resulting preset would be the empty-shell VB authoring
+    // footgun documented in the Track 7a capture.
+    if (Object.keys(value).length === 0) {
+        throw new Error("spacing emitter produced an empty preset — pass at least one " +
+            "padding or margin corner (--padding-top, --margin-bottom, etc.).");
+    }
+    // Registry gate: dispatches off `(divi/spacing, <module>)`. Cells below
+    // VB_PRESET_STORAGE_VERIFIED (currently divi/heading, divi/text,
+    // divi/button — all SCHEMA_OBSERVED) throw EvidenceGateError natively
+    // here. Unknown modules with no applicability cell resolve to
+    // UNVERIFIED (0) and also throw.
+    gateWriteAttr(registry, input.module, SPACING_PATTERN_FAMILY);
+    // Implementation-supported-modules guard: even if a future registry-only
+    // PR promotes another cell to VB_PRESET_STORAGE_VERIFIED, this emitter
+    // must NOT silently start emitting it — heading/text/button cells need
+    // their own per-module wrapper (the section cell uses `module.*`, but a
+    // heading-spacing capture might surface `title.*` or a different
+    // primaryAttrName). Per `feedback_preset_map_per_module`, never assume
+    // cross-module shape carry-over. Promoting another module requires
+    // adding it to `SPACING_SUPPORTED_MODULES` alongside the fixture +
+    // tests + README updates that prove the per-module shape.
+    if (!SPACING_SUPPORTED_MODULES.includes(input.module)) {
+        throw new Error(`spacing emitter does not yet implement module "${input.module}". ` +
+            `Registry evidence cleared the cell, but the per-module wrapper + ` +
+            `attr shape have not been verified against a canonical capture ` +
+            `(this emitter hard-codes the divi/section wrapper "module" and ` +
+            `primaryAttrName "module"). Supported modules: ` +
+            `${SPACING_SUPPORTED_MODULES.join(", ")}. Adding a new module ` +
+            `requires a Track-7a-style canonical capture PR landing first AND ` +
+            `a follow-up implementation PR extending this constant alongside ` +
+            `fixtures + tests + README updates.`);
+    }
+    return {
+        type: "group",
+        module_name: input.module,
+        group_name: SPACING_GROUP_NAME,
+        group_id: SPACING_GROUP_ID,
+        primary_attr_name: SPACING_PRIMARY_ATTR_NAME,
+        name: input.name,
+        attrs,
+    };
+}
+/**
+ * Build the `POST /diviops/v1/preset/create` request body from a spacing
+ * preset entry. Matches the body shape the `diviops_preset_create` MCP
+ * tool posts — the CLI reuses the existing route, it does not add one.
+ *
+ * `primary_attr_name` IS sent on the wire (the plugin's `/preset/create`
+ * route accepts it as an optional snake_case param and stores it as
+ * `primaryAttrName` in the preset). Tracks 4/5/6 emitters omit it because
+ * their preset types do not carry it; the divi/spacing cell does, per the
+ * Track 7a capture's load-bearing finding #2.
+ */
+export function buildSpacingPresetCreateBody(entry, opts = {}) {
+    const body = {
+        module_name: entry.module_name,
+        name: entry.name,
+        attrs: entry.attrs,
+        type: entry.type,
+        group_name: entry.group_name,
+        group_id: entry.group_id,
+        primary_attr_name: entry.primary_attr_name,
+    };
+    if (opts.dry_run)
+        body.dry_run = true;
+    return body;
+}

package/dist/preset-cli/text-body-font-emitter.d.ts

@@ -0,0 +1,127 @@
+/**
+ * `divi/font-body` body-text group-preset emitter.
+ *
+ * Emits a byte-canonical Divi 5.5.x `type: "group"` `divi/font-body` preset
+ * targeting `divi/text` at
+ * `attrs.content.decoration.bodyFont.body.font.desktop.value.*`,
+ * gated by the verified-attrs registry. Canonical shape:
+ * `docs/verification/canonical-preset-shapes-per-module-type-2026-05-18.md`
+ * (`divi/font-body` section), cross-checked against
+ * `docs/verification/evidence/canonical-shape-dumps-2026-05-18/round-2-body-text-pattern-a.json`.
+ *
+ * Scope: Pattern A (Google Fonts) ONLY. Pattern B (local-hosted) has NO
+ * registry entry for `divi/font-body` — the heading-vs-body shape
+ * divergence question deferred per round-2 _meta. Selecting
+ * `pattern: "local"` therefore resolves to a missing-variant registry-
+ * absence error from `resolveEvidence` (the standard
+ * `findPatternEntry → undefined → throw` shape). No special-cased
+ * Pattern-B branch lives in this file — the registry IS the gate.
+ *
+ * Shape rules enforced here:
+ *  - Emit-on-specification only — omitted params produce NO keys.
+ *  - `attrs == styleAttrs == renderAttrs` at the route layer (the plugin's
+ *    `/preset/create` route mirrors `attrs` into all three buckets to match
+ *    VB save semantics); the CLI request body only carries `attrs`.
+ *  - Wrapper chain: `content.decoration.bodyFont.body.font.desktop.value.*` —
+ *    note the per-bucket divergence vs `divi/font` (which uses
+ *    `title.decoration.font.font.desktop.value.*`). Sibling buckets do NOT
+ *    share canonical keys (per `feedback_preset_map_per_module`).
+ *  - Link color (`bodyFont.link.font.desktop.value.color`) is OUT OF SCOPE
+ *    for this emitter — no `--link-color` option, no link emission. Needs
+ *    a dedicated capture-backed follow-up before the CLI writes it.
+ *  - Body-text emission on modules OTHER than `divi/text` is OUT OF SCOPE
+ *    — Testimonial / Accordion-item / Slide / Blurb cells are
+ *    `SCHEMA_OBSERVED` in the registry today (under the write threshold)
+ *    and the gate will refuse them.
+ */
+import { type VerifiedAttrsRegistry } from "./registry.js";
+export declare const TEXT_BODY_FONT_MODULE = "divi/text";
+export declare const TEXT_BODY_FONT_GROUP_NAME = "divi/font-body";
+export declare const TEXT_BODY_FONT_GROUP_ID = "designText";
+export declare const TEXT_BODY_FONT_PATTERN_FAMILY = "divi/font-body";
+/**
+ * The verified pattern variants the CLI honors for `divi/font-body`.
+ *
+ * Only Pattern A is supported. Pattern B is included in the type so the
+ * CLI surface mirrors `heading-font` (and so `--pattern local` parses
+ * cleanly enough to reach the registry-gate refusal), but its registry
+ * entry is intentionally absent — `resolveEvidence` will throw a
+ * registry-absence error when the local variant is selected. There is NO
+ * shape-level Pattern B encoding here (no weight-in-family heuristic, no
+ * `weight`-refusal branch beyond what the missing-variant gate produces).
+ */
+export declare const TEXT_BODY_FONT_PATTERN_VARIANTS: {
+    readonly google: "google_fonts_pattern_a";
+    readonly local: "local_hosted_pattern_b";
+};
+export type TextBodyFontPattern = "google" | "local";
+export interface TextBodyFontEmitterInput {
+    /** Required display name for the preset. */
+    name: string;
+    /**
+     * Required pattern selector. There is no default. Only Pattern A is
+     * supported; passing `"local"` resolves to a registry-absence refusal
+     * (no Pattern B entry exists for `divi/font-body` today).
+     */
+    pattern: TextBodyFontPattern;
+    /** Font family (Pattern A: plain family name, e.g. `"Inter"`). */
+    family?: string;
+    /** Font weight (numeric-string, e.g. `"400"`); emit-on-specification. */
+    weight?: string;
+    /** Font color — literal hex or bare/formed variable token. */
+    color?: string;
+    /** Font size — literal (e.g. `"16px"`) or already-formed `$variable(...)$`. */
+    size?: string;
+    /** Line height — optional, emit-on-specification only. */
+    lineHeight?: string;
+}
+/** The composed canonical preset entry shape sent to `/preset/create`. */
+export interface TextBodyFontPresetEntry {
+    type: "group";
+    module_name: string;
+    group_name: string;
+    group_id: string;
+    pattern_variant: string;
+    name: string;
+    attrs: Record<string, unknown>;
+}
+/**
+ * Compose the canonical
+ * `attrs.content.decoration.bodyFont.body.font.desktop.value` bag from the
+ * input. Emit-on-specification: only specified sub-fields produce keys.
+ */
+export declare function composeTextBodyFontAttrs(input: TextBodyFontEmitterInput): Record<string, unknown>;
+/**
+ * Emit a canonical `divi/font-body` body-text group preset for `divi/text`.
+ *
+ * 1. Validate input shape (name, pattern).
+ * 2. Compose `attrs.content.decoration.bodyFont.body.font.desktop.value.*`
+ *    (emit-on-specification).
+ * 3. Gate the chosen `(divi/font-body, pattern_variant)` cell on
+ *    `divi/text` against the verified-attrs registry — throws an Error
+ *    (registry-absence) when the variant is missing (Pattern B is
+ *    missing by design), or `EvidenceGateError` when effective evidence
+ *    is below `VB_PRESET_STORAGE_VERIFIED`.
+ *
+ * `styleAttrs` and `renderAttrs` are intentionally NOT part of this
+ * entry: the plugin's `/preset/create` route mirrors the single `attrs`
+ * bag into all three buckets, writing `attrs == styleAttrs == renderAttrs`
+ * to match VB save semantics. The Round 2 fixture captures the post-write
+ * storage shape (note: round-2 _meta records `renderAttrs_present: false`
+ * for font-styling group presets, which is consistent with rounds 1a/1b —
+ * the mirror happens at the route layer regardless).
+ */
+export declare function emitTextBodyFontGroupPreset(input: TextBodyFontEmitterInput, registry?: VerifiedAttrsRegistry): TextBodyFontPresetEntry;
+/**
+ * Build the `POST /diviops/v1/preset/create` request body from a
+ * text-body-font preset entry. Matches the body shape the
+ * `diviops_preset_create` MCP tool posts — the CLI reuses the existing
+ * route, it does not add one.
+ *
+ * `pattern_variant` is informational metadata on the in-memory entry and
+ * is NOT sent over the wire — the registry-gate decision happens
+ * client-side before the write.
+ */
+export declare function buildTextBodyFontPresetCreateBody(entry: TextBodyFontPresetEntry, opts?: {
+    dry_run?: boolean;
+}): Record<string, unknown>;

package/dist/preset-cli/text-body-font-emitter.js

@@ -0,0 +1,169 @@
+/**
+ * `divi/font-body` body-text group-preset emitter.
+ *
+ * Emits a byte-canonical Divi 5.5.x `type: "group"` `divi/font-body` preset
+ * targeting `divi/text` at
+ * `attrs.content.decoration.bodyFont.body.font.desktop.value.*`,
+ * gated by the verified-attrs registry. Canonical shape:
+ * `docs/verification/canonical-preset-shapes-per-module-type-2026-05-18.md`
+ * (`divi/font-body` section), cross-checked against
+ * `docs/verification/evidence/canonical-shape-dumps-2026-05-18/round-2-body-text-pattern-a.json`.
+ *
+ * Scope: Pattern A (Google Fonts) ONLY. Pattern B (local-hosted) has NO
+ * registry entry for `divi/font-body` — the heading-vs-body shape
+ * divergence question deferred per round-2 _meta. Selecting
+ * `pattern: "local"` therefore resolves to a missing-variant registry-
+ * absence error from `resolveEvidence` (the standard
+ * `findPatternEntry → undefined → throw` shape). No special-cased
+ * Pattern-B branch lives in this file — the registry IS the gate.
+ *
+ * Shape rules enforced here:
+ *  - Emit-on-specification only — omitted params produce NO keys.
+ *  - `attrs == styleAttrs == renderAttrs` at the route layer (the plugin's
+ *    `/preset/create` route mirrors `attrs` into all three buckets to match
+ *    VB save semantics); the CLI request body only carries `attrs`.
+ *  - Wrapper chain: `content.decoration.bodyFont.body.font.desktop.value.*` —
+ *    note the per-bucket divergence vs `divi/font` (which uses
+ *    `title.decoration.font.font.desktop.value.*`). Sibling buckets do NOT
+ *    share canonical keys (per `feedback_preset_map_per_module`).
+ *  - Link color (`bodyFont.link.font.desktop.value.color`) is OUT OF SCOPE
+ *    for this emitter — no `--link-color` option, no link emission. Needs
+ *    a dedicated capture-backed follow-up before the CLI writes it.
+ *  - Body-text emission on modules OTHER than `divi/text` is OUT OF SCOPE
+ *    — Testimonial / Accordion-item / Slide / Blurb cells are
+ *    `SCHEMA_OBSERVED` in the registry today (under the write threshold)
+ *    and the gate will refuse them.
+ */
+import { loadRegistry, gateWriteAttr, } from "./registry.js";
+import { normalizeColorValue } from "./variable-token.js";
+export const TEXT_BODY_FONT_MODULE = "divi/text";
+export const TEXT_BODY_FONT_GROUP_NAME = "divi/font-body";
+export const TEXT_BODY_FONT_GROUP_ID = "designText";
+export const TEXT_BODY_FONT_PATTERN_FAMILY = "divi/font-body";
+/**
+ * The verified pattern variants the CLI honors for `divi/font-body`.
+ *
+ * Only Pattern A is supported. Pattern B is included in the type so the
+ * CLI surface mirrors `heading-font` (and so `--pattern local` parses
+ * cleanly enough to reach the registry-gate refusal), but its registry
+ * entry is intentionally absent — `resolveEvidence` will throw a
+ * registry-absence error when the local variant is selected. There is NO
+ * shape-level Pattern B encoding here (no weight-in-family heuristic, no
+ * `weight`-refusal branch beyond what the missing-variant gate produces).
+ */
+export const TEXT_BODY_FONT_PATTERN_VARIANTS = {
+    google: "google_fonts_pattern_a",
+    local: "local_hosted_pattern_b",
+};
+/**
+ * Compose the canonical
+ * `attrs.content.decoration.bodyFont.body.font.desktop.value` bag from the
+ * input. Emit-on-specification: only specified sub-fields produce keys.
+ */
+export function composeTextBodyFontAttrs(input) {
+    const value = {};
+    if (input.family !== undefined)
+        value.family = input.family;
+    if (input.weight !== undefined)
+        value.weight = input.weight;
+    if (input.color !== undefined)
+        value.color = normalizeColorValue(input.color);
+    if (input.size !== undefined)
+        value.size = input.size;
+    if (input.lineHeight !== undefined)
+        value.lineHeight = input.lineHeight;
+    return {
+        content: {
+            decoration: {
+                bodyFont: {
+                    body: {
+                        font: {
+                            desktop: {
+                                value,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+/**
+ * Emit a canonical `divi/font-body` body-text group preset for `divi/text`.
+ *
+ * 1. Validate input shape (name, pattern).
+ * 2. Compose `attrs.content.decoration.bodyFont.body.font.desktop.value.*`
+ *    (emit-on-specification).
+ * 3. Gate the chosen `(divi/font-body, pattern_variant)` cell on
+ *    `divi/text` against the verified-attrs registry — throws an Error
+ *    (registry-absence) when the variant is missing (Pattern B is
+ *    missing by design), or `EvidenceGateError` when effective evidence
+ *    is below `VB_PRESET_STORAGE_VERIFIED`.
+ *
+ * `styleAttrs` and `renderAttrs` are intentionally NOT part of this
+ * entry: the plugin's `/preset/create` route mirrors the single `attrs`
+ * bag into all three buckets, writing `attrs == styleAttrs == renderAttrs`
+ * to match VB save semantics. The Round 2 fixture captures the post-write
+ * storage shape (note: round-2 _meta records `renderAttrs_present: false`
+ * for font-styling group presets, which is consistent with rounds 1a/1b —
+ * the mirror happens at the route layer regardless).
+ */
+export function emitTextBodyFontGroupPreset(input, registry = loadRegistry()) {
+    if (!input.name || typeof input.name !== "string") {
+        throw new Error("text-body-font emitter requires a non-empty `name`.");
+    }
+    if (input.pattern !== "google" && input.pattern !== "local") {
+        throw new Error(`text-body-font emitter requires \`pattern\` to be "google" or "local"; got ${JSON.stringify(input.pattern)}. ` +
+            `There is no default — Pattern A (google) is the only registry-verified variant for ` +
+            `\`divi/font-body\` today; Pattern B (local) resolves to a registry-absence refusal.`);
+    }
+    const attrs = composeTextBodyFontAttrs(input);
+    // Sanity check: at least one styling field was specified. An empty
+    // value bag is a usage error — there is nothing to write.
+    const value = attrs.content.decoration.bodyFont.body.font.desktop
+        .value;
+    if (!value || Object.keys(value).length === 0) {
+        throw new Error("text-body-font emitter produced an empty preset — pass at least one of " +
+            "family, weight, color, size, or lineHeight.");
+    }
+    // Registry gate: variant-aware. Pattern A evidence must NOT vouch for
+    // Pattern B and vice versa — gateWriteAttr resolves by both family AND
+    // variant, so a missing/under-verified variant entry throws here.
+    // Pattern B has NO registry entry for `divi/font-body`, so
+    // `--pattern local` lands on `resolveEvidence`'s "absent from
+    // verified-attrs.json" throw natively — no special-cased branch needed.
+    const patternVariant = TEXT_BODY_FONT_PATTERN_VARIANTS[input.pattern];
+    gateWriteAttr(registry, TEXT_BODY_FONT_MODULE, TEXT_BODY_FONT_PATTERN_FAMILY, patternVariant);
+    return {
+        type: "group",
+        module_name: TEXT_BODY_FONT_MODULE,
+        group_name: TEXT_BODY_FONT_GROUP_NAME,
+        group_id: TEXT_BODY_FONT_GROUP_ID,
+        pattern_variant: patternVariant,
+        name: input.name,
+        attrs,
+    };
+}
+/**
+ * Build the `POST /diviops/v1/preset/create` request body from a
+ * text-body-font preset entry. Matches the body shape the
+ * `diviops_preset_create` MCP tool posts — the CLI reuses the existing
+ * route, it does not add one.
+ *
+ * `pattern_variant` is informational metadata on the in-memory entry and
+ * is NOT sent over the wire — the registry-gate decision happens
+ * client-side before the write.
+ */
+export function buildTextBodyFontPresetCreateBody(entry, opts = {}) {
+    const body = {
+        module_name: entry.module_name,
+        name: entry.name,
+        attrs: entry.attrs,
+        type: entry.type,
+        group_name: entry.group_name,
+        group_id: entry.group_id,
+    };
+    if (opts.dry_run)
+        body.dry_run = true;
+    return body;
+}

package/dist/preset-cli/write-path.d.ts

@@ -19,6 +19,8 @@ import type { HandshakeResult } from "../compatibility.js";
 import type { DiviopsResponse } from "../envelope.js";
 import type { ButtonPresetEntry } from "./button-emitter.js";
 import type { HeadingFontPresetEntry } from "./heading-font-emitter.js";
+import type { TextBodyFontPresetEntry } from "./text-body-font-emitter.js";
+import type { SpacingPresetEntry } from "./spacing-emitter.js";
 /** The plugin capability the storage-path capability contract ships. */
 export declare const STORAGE_CAPABILITY = "storage_multipath_probe_v1";
 /** The REST route the CLI posts to — same route `diviops_preset_create` uses. */
@@ -72,3 +74,33 @@ export declare function applyHeadingFontPreset(client: PresetWriteClient, entry:
     serverVersion: string;
     dry_run?: boolean;
 }): Promise<DiviopsResponse<unknown>>;
+/**
+ * Apply a `divi/font-body` body-text group preset for `divi/text`:
+ * capability-gate, then POST to `/preset/create`. Mirrors
+ * `applyHeadingFontPreset`'s sequence — the capability check runs BEFORE
+ * the write, and the write reuses the existing storage-routed route (no
+ * plugin route is added).
+ *
+ * The `pattern_variant` metadata is intentionally NOT in the wire body —
+ * variant selection is a client-side registry-gate decision and the
+ * server route accepts only the standard preset-create fields.
+ */
+export declare function applyTextBodyFontPreset(client: PresetWriteClient, entry: TextBodyFontPresetEntry, opts: {
+    serverVersion: string;
+    dry_run?: boolean;
+}): Promise<DiviopsResponse<unknown>>;
+/**
+ * Apply a `divi/spacing` section group preset: capability-gate, then POST
+ * to `/preset/create`. Mirrors `applyTextBodyFontPreset`'s sequence — the
+ * capability check runs BEFORE the write, and the write reuses the
+ * existing storage-routed route (no plugin route is added).
+ *
+ * Unlike the font emitters, the spacing entry carries `primary_attr_name`
+ * (`"module"` for the section cell per Track 7a), which IS sent on the
+ * wire — the `/preset/create` route accepts it as an optional snake_case
+ * param and stores it as `primaryAttrName` in the preset.
+ */
+export declare function applySpacingPreset(client: PresetWriteClient, entry: SpacingPresetEntry, opts: {
+    serverVersion: string;
+    dry_run?: boolean;
+}): Promise<DiviopsResponse<unknown>>;

package/dist/preset-cli/write-path.js

@@ -17,6 +17,8 @@
 import { WPClient } from "../wp-client.js";
 import { buildPresetCreateBody } from "./button-emitter.js";
 import { buildHeadingFontPresetCreateBody } from "./heading-font-emitter.js";
+import { buildTextBodyFontPresetCreateBody } from "./text-body-font-emitter.js";
+import { buildSpacingPresetCreateBody } from "./spacing-emitter.js";
 /** The plugin capability the storage-path capability contract ships. */
 export const STORAGE_CAPABILITY = "storage_multipath_probe_v1";
 /** The REST route the CLI posts to — same route `diviops_preset_create` uses. */
@@ -108,3 +110,45 @@ export async function applyHeadingFontPreset(client, entry, opts) {
         body,
     });
 }
+/**
+ * Apply a `divi/font-body` body-text group preset for `divi/text`:
+ * capability-gate, then POST to `/preset/create`. Mirrors
+ * `applyHeadingFontPreset`'s sequence — the capability check runs BEFORE
+ * the write, and the write reuses the existing storage-routed route (no
+ * plugin route is added).
+ *
+ * The `pattern_variant` metadata is intentionally NOT in the wire body —
+ * variant selection is a client-side registry-gate decision and the
+ * server route accepts only the standard preset-create fields.
+ */
+export async function applyTextBodyFontPreset(client, entry, opts) {
+    await assertStorageCapability(client, opts.serverVersion);
+    const body = buildTextBodyFontPresetCreateBody(entry, {
+        dry_run: opts.dry_run,
+    });
+    return client.requestEnveloped(PRESET_CREATE_ROUTE, {
+        method: "POST",
+        body,
+    });
+}
+/**
+ * Apply a `divi/spacing` section group preset: capability-gate, then POST
+ * to `/preset/create`. Mirrors `applyTextBodyFontPreset`'s sequence — the
+ * capability check runs BEFORE the write, and the write reuses the
+ * existing storage-routed route (no plugin route is added).
+ *
+ * Unlike the font emitters, the spacing entry carries `primary_attr_name`
+ * (`"module"` for the section cell per Track 7a), which IS sent on the
+ * wire — the `/preset/create` route accepts it as an optional snake_case
+ * param and stores it as `primaryAttrName` in the preset.
+ */
+export async function applySpacingPreset(client, entry, opts) {
+    await assertStorageCapability(client, opts.serverVersion);
+    const body = buildSpacingPresetCreateBody(entry, {
+        dry_run: opts.dry_run,
+    });
+    return client.requestEnveloped(PRESET_CREATE_ROUTE, {
+        method: "POST",
+        body,
+    });
+}