@diviops/mcp-server 1.5.12 → 1.5.13

package/README.md

@@ -91,6 +91,7 @@ run it directly. Current commands:
 |---|---|
 | `diviops-preset button [options]` | `divi/button` group preset |
 | `diviops-preset heading-font [options]` | `divi/font` group preset for `divi/heading` (Pattern A — Google Fonts — or Pattern B — local-hosted) |
+| `diviops-preset text-body-font [options]` | `divi/font-body` group preset for `divi/text` — **Pattern A (Google Fonts) only**; Pattern B for body-text has no registered canonical shape and is refused |
 
 ```bash
 diviops-preset button --name "Primary" --bg-color gcid-primary-color \
@@ -100,6 +101,10 @@ diviops-preset button --name "Primary" --bg-color gcid-primary-color \
 diviops-preset heading-font --name "Heading H1" --pattern google \
   --font-family Inter --font-weight 700 \
   --font-color gcid-heading-color --font-size 48px
+
+diviops-preset text-body-font --name "Body Text" --pattern google \
+  --font-family Inter --font-weight 400 \
+  --font-color gcid-body-color --font-size 16px
 ```
 
 `--dry-run` (the default) composes and prints the canonical JSON with no

package/dist/preset-cli/__tests__/cli.test.js

@@ -319,6 +319,210 @@ test("heading-font --apply without credentials exits 1 with a credentials hint",
             process.env.WP_APP_PASSWORD = saved.WP_APP_PASSWORD;
     }
 });
+// ------------------------------------------------------------------
+// text-body-font command — CLI integration (parse → emit → dry-run JSON)
+// Track 6: Pattern A only; Pattern B refused via registry-absence.
+// ------------------------------------------------------------------
+test("--help advertises the text-body-font command (Pattern A only)", async () => {
+    const io = capture();
+    const code = await run(["--help"], io);
+    assert.equal(code, EXIT.OK);
+    const help = io.stdout.join("\n");
+    assert.match(help, /text-body-font/);
+    assert.match(help, /Pattern A/);
+});
+test("text-body-font dry-run (Pattern A) emits canonical JSON, exit 0", async () => {
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--pattern",
+        "google",
+        "--font-family",
+        "Inter",
+        "--font-weight",
+        "400",
+        "--font-color",
+        "gcid-body-color",
+        "--font-size",
+        "16px",
+    ], io);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    assert.equal(parsed.type, "group");
+    assert.equal(parsed.dry_run, true);
+    assert.equal(parsed.module_name, "divi/text");
+    assert.equal(parsed.group_name, "divi/font-body");
+    assert.equal(parsed.group_id, "designText");
+    const value = parsed.attrs.content.decoration.bodyFont.body.font.desktop.value;
+    assert.equal(value.family, "Inter");
+    assert.equal(value.weight, "400");
+    assert.equal(value.size, "16px");
+    assert.equal(value.color, '$variable({"type":"color","value":{"name":"gcid-body-color","settings":{}}})$');
+});
+test("text-body-font dry-run omits weight/size/lineHeight keys when not specified", async () => {
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--pattern",
+        "google",
+        "--font-family",
+        "Inter",
+    ], io);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    const value = parsed.attrs.content.decoration.bodyFont.body.font.desktop.value;
+    assert.deepEqual(Object.keys(value), ["family"]);
+});
+test("text-body-font without --pattern exits 1 (invalid input)", async () => {
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--font-family",
+        "Inter",
+        "--font-weight",
+        "400",
+    ], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /--pattern/);
+    assert.match(io.stderr.join("\n"), /google\|local/);
+});
+test("text-body-font without --name exits 1", async () => {
+    const io = capture();
+    const code = await run(["text-body-font", "--pattern", "google", "--font-family", "Inter"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /requires --name/);
+});
+test("text-body-font --pattern local is refused (registry-absence), exit 2", async () => {
+    // Track 6 contract: Pattern B has NO registry entry for `divi/font-body`.
+    // The CLI must exit non-zero. The registry-absence throw is NOT an
+    // EvidenceGateError (no resolution constructed) — it surfaces as a
+    // plain Error and the CLI's fallback branch returns INVALID_INPUT (1).
+    // What matters here is: (a) non-zero exit; (b) the error message names
+    // both family and variant so the operator can file the gap.
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--pattern",
+        "local",
+        "--font-family",
+        "Inter",
+        "--font-color",
+        "#666666",
+    ], io);
+    assert.notEqual(code, EXIT.OK, "refusal MUST exit non-zero");
+    const err = io.stderr.join("\n");
+    assert.match(err, /absent from verified-attrs\.json/);
+    assert.match(err, /divi\/font-body/);
+    assert.match(err, /local_hosted_pattern_b/);
+});
+test("text-body-font --pattern local --font-weight is ALSO refused (compound input)", async () => {
+    // Compound-input parity: adding --font-weight (or any other field) does
+    // NOT change the refusal — the gate fires on the missing variant entry
+    // regardless of which other fields are set.
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--pattern",
+        "local",
+        "--font-family",
+        "Inter",
+        "--font-weight",
+        "700",
+    ], io);
+    assert.notEqual(code, EXIT.OK);
+    const err = io.stderr.join("\n");
+    assert.match(err, /absent from verified-attrs\.json/);
+    assert.match(err, /local_hosted_pattern_b/);
+});
+test("text-body-font --pattern with an invalid value exits 1", async () => {
+    const io = capture();
+    const code = await run([
+        "text-body-font",
+        "--name",
+        "Body",
+        "--pattern",
+        "auto",
+        "--font-family",
+        "Inter",
+    ], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /--pattern must be/);
+});
+test("text-body-font dry-run requires no credentials and no network", async () => {
+    const saved = {
+        WP_URL: process.env.WP_URL,
+        WP_USER: process.env.WP_USER,
+        WP_APP_PASSWORD: process.env.WP_APP_PASSWORD,
+    };
+    delete process.env.WP_URL;
+    delete process.env.WP_USER;
+    delete process.env.WP_APP_PASSWORD;
+    try {
+        const io = capture();
+        const code = await run([
+            "text-body-font",
+            "--name",
+            "Body",
+            "--pattern",
+            "google",
+            "--font-family",
+            "Inter",
+        ], io);
+        assert.equal(code, EXIT.OK);
+        assert.equal(io.stderr.length, 0, "no error output on credential-free dry-run");
+    }
+    finally {
+        if (saved.WP_URL !== undefined)
+            process.env.WP_URL = saved.WP_URL;
+        if (saved.WP_USER !== undefined)
+            process.env.WP_USER = saved.WP_USER;
+        if (saved.WP_APP_PASSWORD !== undefined)
+            process.env.WP_APP_PASSWORD = saved.WP_APP_PASSWORD;
+    }
+});
+test("text-body-font --apply without credentials exits 1 with a credentials hint", async () => {
+    const saved = {
+        WP_URL: process.env.WP_URL,
+        WP_USER: process.env.WP_USER,
+        WP_APP_PASSWORD: process.env.WP_APP_PASSWORD,
+    };
+    delete process.env.WP_URL;
+    delete process.env.WP_USER;
+    delete process.env.WP_APP_PASSWORD;
+    try {
+        const io = capture();
+        const code = await run([
+            "text-body-font",
+            "--name",
+            "Body",
+            "--pattern",
+            "google",
+            "--font-family",
+            "Inter",
+            "--apply",
+        ], io);
+        assert.equal(code, EXIT.INVALID_INPUT);
+        assert.match(io.stderr.join("\n"), /requires WordPress credentials/);
+    }
+    finally {
+        if (saved.WP_URL !== undefined)
+            process.env.WP_URL = saved.WP_URL;
+        if (saved.WP_USER !== undefined)
+            process.env.WP_USER = saved.WP_USER;
+        if (saved.WP_APP_PASSWORD !== undefined)
+            process.env.WP_APP_PASSWORD = saved.WP_APP_PASSWORD;
+    }
+});
 test("dry-run output includes the bypass corner when requested", async () => {
     const io = capture();
     const code = await run(["button", "--name", "P", "--bg-color", "#111", "--bypass-hover-padding-gate"], io);

package/dist/preset-cli/__tests__/registry.test.js

@@ -147,3 +147,29 @@ test("variant-aware lookup selects the correct entry by pattern_variant", () =>
     // A bogus variant under a known family throws — no silent fallback.
     assert.throws(() => resolveEvidence(reg, "divi/heading", "divi/font", "no_such_variant"), /absent from verified-attrs\.json/);
 });
+test("variant-aware lookup: divi/font-body Pattern A on divi/text clears the write threshold", () => {
+    // Track 6 contract: the shipped registry MUST carry one cleared
+    // `divi/font-body` + `google_fonts_pattern_a` entry on `divi/text`
+    // (effective level = VB_PRESET_STORAGE_VERIFIED). If a registry edit
+    // ever drops it, this canary fires.
+    const reg = loadRegistry();
+    const a = resolveEvidence(reg, "divi/text", "divi/font-body", "google_fonts_pattern_a");
+    assert.equal(a.patternVariant, "google_fonts_pattern_a");
+    assert.equal(a.effectiveLevel, 4, "divi/font-body Pattern A on divi/text must clear VB_PRESET_STORAGE_VERIFIED");
+    // gateWriteAttr must not throw at this cell.
+    gateWriteAttr(reg, "divi/text", "divi/font-body", "google_fonts_pattern_a");
+});
+test("variant-aware lookup: divi/font-body Pattern B is absent from the registry (refused)", () => {
+    // Track 6 contract: the shipped registry MUST NOT carry a
+    // `divi/font-body` + `local_hosted_pattern_b` entry. Pattern B for
+    // body-text was deliberately deferred per round-2 _meta — there is no
+    // captured evidence. resolveEvidence MUST throw the standard
+    // registry-absence error.
+    const reg = loadRegistry();
+    assert.throws(() => resolveEvidence(reg, "divi/text", "divi/font-body", "local_hosted_pattern_b"), (err) => {
+        assert.match(err.message, /absent from verified-attrs\.json/);
+        assert.match(err.message, /divi\/font-body/);
+        assert.match(err.message, /local_hosted_pattern_b/);
+        return true;
+    });
+});

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

@@ -0,0 +1,14 @@
+/**
+ * `divi/font-body` text-body-font emitter shape + gating coverage:
+ *  - fixture-based shape assertion against round-2 (Pattern A) canonical
+ *    capture for the captured fields;
+ *  - emit-on-specification: omitted size / lineHeight / weight produce no
+ *    key in the output;
+ *  - no renderAttrs on the in-memory entry (mirror happens at route layer);
+ *  - Pattern B refusal: selecting `--pattern local` resolves to a
+ *    registry-absence refusal (no `divi/font-body` + `local_hosted_pattern_b`
+ *    entry exists in verified-attrs.json);
+ *  - variant-aware registry gating: Pattern A evidence does NOT vouch for
+ *    Pattern B and vice versa.
+ */
+export {};

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

@@ -0,0 +1,191 @@
+/**
+ * `divi/font-body` text-body-font emitter shape + gating coverage:
+ *  - fixture-based shape assertion against round-2 (Pattern A) canonical
+ *    capture for the captured fields;
+ *  - emit-on-specification: omitted size / lineHeight / weight produce no
+ *    key in the output;
+ *  - no renderAttrs on the in-memory entry (mirror happens at route layer);
+ *  - Pattern B refusal: selecting `--pattern local` resolves to a
+ *    registry-absence refusal (no `divi/font-body` + `local_hosted_pattern_b`
+ *    entry exists in verified-attrs.json);
+ *  - variant-aware registry gating: Pattern A evidence does NOT vouch for
+ *    Pattern B and vice versa.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { emitTextBodyFontGroupPreset, composeTextBodyFontAttrs, buildTextBodyFontPresetCreateBody, TEXT_BODY_FONT_MODULE, TEXT_BODY_FONT_GROUP_NAME, TEXT_BODY_FONT_GROUP_ID, TEXT_BODY_FONT_PATTERN_VARIANTS, } from "../text-body-font-emitter.js";
+import { loadRegistry } from "../registry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..");
+const FIXTURE_DIR = join(REPO_ROOT, "docs/verification/evidence/canonical-shape-dumps-2026-05-18");
+const FIXTURE_ROUND_2 = join(FIXTURE_DIR, "round-2-body-text-pattern-a.json");
+const registry = loadRegistry();
+test("emitter byte-matches round-2 (Pattern A — Google Fonts) fixture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE_ROUND_2, "utf8"));
+    const canonicalAttrs = fixture.preset_entry.attrs;
+    const entry = emitTextBodyFontGroupPreset({
+        name: "canonical-body-text-vb-2026-05-18",
+        pattern: "google",
+        family: "Inter",
+        weight: "400",
+        color: '$variable({"type":"color","value":{"name":"gcid-body-color","settings":{}}})$',
+        size: "16px",
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the Pattern A canonical capture");
+    assert.equal(entry.type, "group");
+    assert.equal(entry.group_name, TEXT_BODY_FONT_GROUP_NAME);
+    assert.equal(entry.group_id, TEXT_BODY_FONT_GROUP_ID);
+    assert.equal(entry.module_name, TEXT_BODY_FONT_MODULE);
+    assert.equal(entry.pattern_variant, TEXT_BODY_FONT_PATTERN_VARIANTS.google);
+});
+test("emit-on-specification: only specified keys produce keys (no defaults)", () => {
+    const attrs = composeTextBodyFontAttrs({
+        name: "minimal",
+        pattern: "google",
+        family: "Inter",
+    });
+    const value = attrs.content.decoration.bodyFont.body.font.desktop
+        .value;
+    assert.deepEqual(Object.keys(value), ["family"], "ONLY the touched key emitted — no defaulted weight/color/size/lineHeight");
+});
+test("omitted weight / size / lineHeight produce no keys", () => {
+    const attrs = composeTextBodyFontAttrs({
+        name: "fc",
+        pattern: "google",
+        family: "Inter",
+        color: "#666666",
+    });
+    const value = attrs.content.decoration.bodyFont.body.font.desktop
+        .value;
+    assert.equal("weight" in value, false, "weight omitted → no key");
+    assert.equal("size" in value, false, "size omitted → no key");
+    assert.equal("lineHeight" in value, false, "lineHeight omitted → no key");
+    assert.deepEqual(Object.keys(value).sort(), ["color", "family"]);
+});
+test("entry carries no renderAttrs key (mirror happens at route layer)", () => {
+    const entry = emitTextBodyFontGroupPreset({
+        name: "no-renderattrs",
+        pattern: "google",
+        family: "Inter",
+        weight: "400",
+    }, registry);
+    assert.equal("renderAttrs" in entry, false, "renderAttrs must NOT appear on the in-memory entry — the plugin's " +
+        "/preset/create route mirrors attrs into styleAttrs/renderAttrs at " +
+        "the write layer");
+    assert.equal("styleAttrs" in entry, false, "same for styleAttrs");
+});
+test("variable color tokens get the {name,settings} object shape + trailing )$", () => {
+    const attrs = composeTextBodyFontAttrs({
+        name: "v",
+        pattern: "google",
+        color: "gcid-body-color",
+    });
+    const color = attrs.content.decoration.bodyFont.body.font.desktop
+        .value.color;
+    assert.ok(color.endsWith(")$"));
+    assert.match(color, /^\$variable\(/);
+    const payload = JSON.parse(color.slice("$variable(".length, -2));
+    assert.deepEqual(payload, {
+        type: "color",
+        value: { name: "gcid-body-color", settings: {} },
+    });
+});
+test("literal hex color is emitted verbatim, not wrapped", () => {
+    const attrs = composeTextBodyFontAttrs({
+        name: "h",
+        pattern: "google",
+        color: "#666666",
+    });
+    assert.equal(attrs.content.decoration.bodyFont.body.font.desktop.value.color, "#666666");
+});
+test("lineHeight is emitted only when specified", () => {
+    const withLH = composeTextBodyFontAttrs({
+        name: "lh+",
+        pattern: "google",
+        family: "Inter",
+        lineHeight: "1.5",
+    });
+    assert.equal(withLH.content.decoration.bodyFont.body.font.desktop.value
+        .lineHeight, "1.5");
+    const without = composeTextBodyFontAttrs({
+        name: "lh-",
+        pattern: "google",
+        family: "Inter",
+    });
+    assert.equal("lineHeight" in
+        without.content.decoration.bodyFont.body.font.desktop.value, false);
+});
+test("emitter rejects an invalid `pattern` value", () => {
+    assert.throws(() => emitTextBodyFontGroupPreset(
+    // @ts-expect-error — exercising runtime validation
+    { name: "x", pattern: "auto", family: "Inter" }, registry), /pattern.*google.*local/i);
+});
+test("emitter rejects an empty preset (no styling specified)", () => {
+    assert.throws(() => emitTextBodyFontGroupPreset({ name: "empty", pattern: "google" }, registry), /empty preset/);
+});
+test("emitter rejects a missing name", () => {
+    assert.throws(() => emitTextBodyFontGroupPreset({ name: "", pattern: "google", family: "Inter" }, registry), /requires a non-empty `name`/);
+});
+test("Pattern B (local) is refused — registry-absence for divi/font-body", () => {
+    // Track 6 contract: NO `divi/font-body` + `local_hosted_pattern_b` entry
+    // exists in verified-attrs.json. `resolveEvidence`'s standard "absent
+    // from verified-attrs.json" throw fires natively — no special-case branch
+    // in the emitter. The error message MUST name the family AND the variant
+    // so operators can file the gap correctly.
+    assert.throws(() => emitTextBodyFontGroupPreset({
+        name: "body-local",
+        pattern: "local",
+        family: "Inter",
+        color: "#666666",
+    }, registry), (err) => {
+        assert.match(err.message, /absent from verified-attrs\.json/, "missing variant must fail with the canonical registry-absence message");
+        assert.match(err.message, /divi\/font-body/, "error names the pattern family");
+        assert.match(err.message, /local_hosted_pattern_b/, "error names the missing variant");
+        return true;
+    });
+});
+test("Pattern B refusal fires even with compound input (e.g. --font-weight)", () => {
+    // Compound-input parity: passing additional fields alongside
+    // --pattern local does NOT change the refusal — the gate fires on the
+    // missing registry entry regardless of which other fields are set.
+    assert.throws(() => emitTextBodyFontGroupPreset({
+        name: "body-local-weight",
+        pattern: "local",
+        family: "Inter",
+        weight: "700",
+        color: "#666666",
+        size: "16px",
+    }, registry), /absent from verified-attrs\.json/);
+});
+test("real registry: Pattern A on divi/text clears the write threshold", () => {
+    // Sanity guard: if a registry edit ever drops the (divi/font-body,
+    // google_fonts_pattern_a, divi/text) cell below VB_PRESET_STORAGE_VERIFIED
+    // (4), this test is the canary.
+    const entry = emitTextBodyFontGroupPreset({
+        name: "canary",
+        pattern: "google",
+        family: "Inter",
+        weight: "400",
+    }, registry);
+    assert.equal(entry.pattern_variant, TEXT_BODY_FONT_PATTERN_VARIANTS.google);
+});
+test("buildTextBodyFontPresetCreateBody mirrors the diviops_preset_create body shape", () => {
+    const entry = emitTextBodyFontGroupPreset({ name: "Body", pattern: "google", family: "Inter", weight: "400" }, registry);
+    const body = buildTextBodyFontPresetCreateBody(entry, { dry_run: true });
+    assert.deepEqual(body, {
+        module_name: TEXT_BODY_FONT_MODULE,
+        name: "Body",
+        attrs: entry.attrs,
+        type: "group",
+        group_name: TEXT_BODY_FONT_GROUP_NAME,
+        group_id: TEXT_BODY_FONT_GROUP_ID,
+        dry_run: true,
+    });
+    // pattern_variant is in-memory metadata; it must NOT leak into the wire body.
+    assert.equal("pattern_variant" in body, false, "pattern_variant is client-side gating metadata; it must not be sent over the wire");
+    const noDry = buildTextBodyFontPresetCreateBody(entry);
+    assert.equal("dry_run" in noDry, false);
+});

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

@@ -7,9 +7,10 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { applyButtonPreset, applyHeadingFontPreset, assertStorageCapability, buildClientFromEnv, CapabilityMissingError, CredentialsMissingError, STORAGE_CAPABILITY, PRESET_CREATE_ROUTE, } from "../write-path.js";
+import { applyButtonPreset, applyHeadingFontPreset, applyTextBodyFontPreset, assertStorageCapability, buildClientFromEnv, CapabilityMissingError, CredentialsMissingError, STORAGE_CAPABILITY, PRESET_CREATE_ROUTE, } from "../write-path.js";
 import { emitButtonGroupPreset } from "../button-emitter.js";
 import { emitHeadingFontGroupPreset } from "../heading-font-emitter.js";
+import { emitTextBodyFontGroupPreset } from "../text-body-font-emitter.js";
 import { loadRegistry } from "../registry.js";
 const registry = loadRegistry();
 function handshake(capabilities) {
@@ -155,6 +156,60 @@ test("applyHeadingFontPreset threads dry_run into the body when requested", asyn
     const options = client.calls[0].options;
     assert.equal(options.body.dry_run, true);
 });
+// ------------------------------------------------------------------
+// text-body-font apply-mode — mocked only (Track 6).
+// Mirrors the heading-font apply-mode coverage. pattern_variant is
+// in-memory metadata and must NOT appear in the wire body. Pattern B is
+// refused at the emitter level (registry-absence) — apply-mode is never
+// reached for `--pattern local`, so it has no mocked test here.
+// ------------------------------------------------------------------
+test("applyTextBodyFontPreset gates capability BEFORE issuing the write", async () => {
+    const client = mockClient({ capabilities: {} });
+    const entry = emitTextBodyFontGroupPreset({ name: "Body", pattern: "google", family: "Inter", weight: "400" }, registry);
+    await assert.rejects(() => applyTextBodyFontPreset(client, entry, {
+        serverVersion: TEST_SERVER_VERSION,
+    }), CapabilityMissingError);
+    assert.equal(client.calls.length, 0, "no write issued when capability is absent");
+});
+test("applyTextBodyFontPreset posts to /preset/create with the canonical body", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitTextBodyFontGroupPreset({
+        name: "Body",
+        pattern: "google",
+        family: "Inter",
+        weight: "400",
+        color: "gcid-body-color",
+        size: "16px",
+    }, registry);
+    const result = await applyTextBodyFontPreset(client, entry, {
+        serverVersion: TEST_SERVER_VERSION,
+    });
+    assert.equal(client.handshakeVersions[0], TEST_SERVER_VERSION);
+    assert.equal(client.calls.length, 1);
+    const call = client.calls[0];
+    assert.equal(call.endpoint, PRESET_CREATE_ROUTE);
+    const options = call.options;
+    assert.equal(options.method, "POST");
+    assert.equal(options.body.type, "group");
+    assert.equal(options.body.module_name, "divi/text");
+    assert.equal(options.body.group_name, "divi/font-body");
+    assert.equal(options.body.group_id, "designText");
+    assert.equal(options.body.name, "Body");
+    assert.deepEqual(options.body.attrs, entry.attrs);
+    assert.equal("pattern_variant" in options.body, false, "pattern_variant is client-side gating metadata; it must not be on the wire");
+    assert.equal("dry_run" in options.body, false);
+    assert.deepEqual(result, { ok: true, data: { preset_id: "mocked123" } });
+});
+test("applyTextBodyFontPreset threads dry_run into the body when requested", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitTextBodyFontGroupPreset({ name: "Body", pattern: "google", family: "Inter" }, registry);
+    await applyTextBodyFontPreset(client, entry, {
+        serverVersion: TEST_SERVER_VERSION,
+        dry_run: true,
+    });
+    const options = client.calls[0].options;
+    assert.equal(options.body.dry_run, true);
+});
 test("buildClientFromEnv throws CredentialsMissingError when env vars are absent", () => {
     assert.throws(() => buildClientFromEnv({}), (err) => {
         assert.ok(err instanceof CredentialsMissingError);

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

@@ -24,6 +24,7 @@
  */
 import { type ButtonEmitterInput } from "./button-emitter.js";
 import { type HeadingFontEmitterInput } from "./heading-font-emitter.js";
+import { type TextBodyFontEmitterInput } from "./text-body-font-emitter.js";
 export declare const EXIT: {
     readonly OK: 0;
     readonly INVALID_INPUT: 1;
@@ -53,6 +54,8 @@ export declare class UsageError extends Error {
 export declare function buildButtonInput(parsed: ParsedArgs): ButtonEmitterInput;
 /** Map parsed `heading-font` options into the heading-font emitter input shape. */
 export declare function buildHeadingFontInput(parsed: ParsedArgs): HeadingFontEmitterInput;
+/** Map parsed `text-body-font` options into the text-body-font emitter input shape. */
+export declare function buildTextBodyFontInput(parsed: ParsedArgs): TextBodyFontEmitterInput;
 /**
  * Run the CLI. Returns the structured exit code (does NOT call
  * `process.exit` — the thin bin wrapper does). `io` is injectable so

package/dist/preset-cli/cli.js

@@ -24,8 +24,9 @@
  */
 import { emitButtonGroupPreset, buildPresetCreateBody, } from "./button-emitter.js";
 import { emitHeadingFontGroupPreset, buildHeadingFontPresetCreateBody, UnsupportedVariantCombinationError, } from "./heading-font-emitter.js";
+import { emitTextBodyFontGroupPreset, buildTextBodyFontPresetCreateBody, } from "./text-body-font-emitter.js";
 import { EvidenceGateError } from "./registry.js";
-import { applyButtonPreset, applyHeadingFontPreset, buildClientFromEnv, CredentialsMissingError, CapabilityMissingError, } from "./write-path.js";
+import { applyButtonPreset, applyHeadingFontPreset, applyTextBodyFontPreset, buildClientFromEnv, CredentialsMissingError, CapabilityMissingError, } from "./write-path.js";
 export const EXIT = {
     OK: 0,
     INVALID_INPUT: 1,
@@ -40,10 +41,12 @@ const realIO = {
 const HELP = `diviops-preset — Divi 5.5.x canonical preset-emitter CLI
 
 USAGE
-  diviops-preset button [options]         Emit a divi/button group preset
-  diviops-preset heading-font [options]   Emit a divi/font group preset for
-                                          divi/heading
-  diviops-preset --help                   Show this help
+  diviops-preset button [options]           Emit a divi/button group preset
+  diviops-preset heading-font [options]     Emit a divi/font group preset for
+                                            divi/heading
+  diviops-preset text-body-font [options]   Emit a divi/font-body group preset
+                                            for divi/text (Pattern A only)
+  diviops-preset --help                     Show this help
 
 MODE
   --dry-run            Compose + print canonical JSON only (DEFAULT).
@@ -99,6 +102,27 @@ heading-font OPTIONS (all styling fields optional; emit-on-specification only)
   --font-size <v>          Font size (e.g. "48px").
   --font-line-height <v>   Font line-height (e.g. "1.1").
 
+text-body-font OPTIONS (all styling fields optional; emit-on-specification only)
+  --name <string>          Preset display name (required).
+  --pattern <google|local> Required. Example: --pattern google.
+                           Pattern A is the only supported variant for now:
+                             google — Pattern A: plain family + optional
+                                      numeric weight (e.g. family "Inter",
+                                      weight "400"). Verified against
+                                      round-2 body-text fixture.
+                             local  — Pattern B for divi/font-body is NOT
+                                      registered (no canonical-shape
+                                      capture exists yet). Selecting it
+                                      lands on a registry-absence refusal.
+                           There is NO default; omitting --pattern is
+                           invalid input.
+  --font-family <string>   Font family (plain name, e.g. "Inter").
+  --font-weight <string>   Font weight (e.g. "400").
+  --font-color <value>     Font color. Hex literal, bare gcid-*/gvid-*
+                           token, or already-formed $variable(...)$ token.
+  --font-size <v>          Font size (e.g. "16px").
+  --font-line-height <v>   Font line-height (e.g. "1.5").
+
 EXIT CODES
   0 success   1 invalid input   2 evidence-gate refusal
   3 capability missing   4 write error
@@ -117,6 +141,10 @@ EXAMPLES
   diviops-preset heading-font --name "Heading H1 (local)" --pattern local \\
     --font-family "Sora 700" \\
     --font-color gcid-heading-color --font-size 48px
+
+  diviops-preset text-body-font --name "Body Text" --pattern google \\
+    --font-family Inter --font-weight 400 \\
+    --font-color gcid-body-color --font-size 16px
 `;
 const VALUE_FLAGS = new Set([
     "--name",
@@ -201,7 +229,7 @@ export class UsageError extends Error {
     }
 }
 /** Known CLI commands. The CLI rejects anything else with EXIT.INVALID_INPUT. */
-const KNOWN_COMMANDS = new Set(["button", "heading-font"]);
+const KNOWN_COMMANDS = new Set(["button", "heading-font", "text-body-font"]);
 /** Map parsed `button` options into the emitter input shape. */
 export function buildButtonInput(parsed) {
     const opt = (k) => {
@@ -324,6 +352,48 @@ export function buildHeadingFontInput(parsed) {
         input.lineHeight = lineHeight;
     return input;
 }
+/** Map parsed `text-body-font` options into the text-body-font emitter input shape. */
+export function buildTextBodyFontInput(parsed) {
+    const opt = (k) => {
+        const v = parsed.options.get(k);
+        return typeof v === "string" ? v : undefined;
+    };
+    const name = opt("--name");
+    if (!name) {
+        throw new UsageError("text-body-font command requires --name <string>.");
+    }
+    // --pattern is REQUIRED — there is no safe default. Pattern A only;
+    // passing "local" lands on the registry-absence refusal downstream
+    // (no Pattern B entry exists for `divi/font-body`).
+    const patternRaw = opt("--pattern");
+    if (patternRaw === undefined) {
+        throw new UsageError("text-body-font command requires --pattern <google|local>. " +
+            "Example: --pattern google. Pattern A (google) is the only " +
+            "supported variant for now; Pattern B (local) has no registry " +
+            "entry for `divi/font-body` and will be refused.");
+    }
+    if (patternRaw !== "google" && patternRaw !== "local") {
+        throw new UsageError(`--pattern must be "google" or "local"; got ${JSON.stringify(patternRaw)}.`);
+    }
+    const pattern = patternRaw;
+    const input = { name, pattern };
+    const family = opt("--font-family");
+    if (family !== undefined)
+        input.family = family;
+    const weight = opt("--font-weight");
+    if (weight !== undefined)
+        input.weight = weight;
+    const color = opt("--font-color");
+    if (color !== undefined)
+        input.color = color;
+    const size = opt("--font-size");
+    if (size !== undefined)
+        input.size = size;
+    const lineHeight = opt("--font-line-height");
+    if (lineHeight !== undefined)
+        input.lineHeight = lineHeight;
+    return input;
+}
 /**
  * Run the CLI. Returns the structured exit code (does NOT call
  * `process.exit` — the thin bin wrapper does). `io` is injectable so
@@ -365,13 +435,27 @@ export async function run(argv, io = realIO, serverVersion) {
             dryRunBody = buildPresetCreateBody(entry, { dry_run: true });
             applyFn = (client, sv) => applyButtonPreset(client, entry, { serverVersion: sv });
         }
-        else {
-            // heading-font
+        else if (parsed.command === "heading-font") {
             const input = buildHeadingFontInput(parsed);
             const entry = emitHeadingFontGroupPreset(input);
             dryRunBody = buildHeadingFontPresetCreateBody(entry, { dry_run: true });
             applyFn = (client, sv) => applyHeadingFontPreset(client, entry, { serverVersion: sv });
         }
+        else if (parsed.command === "text-body-font") {
+            // text-body-font (Pattern A only; Pattern B lands on the
+            // registry-absence refusal in emitTextBodyFontGroupPreset).
+            const input = buildTextBodyFontInput(parsed);
+            const entry = emitTextBodyFontGroupPreset(input);
+            dryRunBody = buildTextBodyFontPresetCreateBody(entry, { dry_run: true });
+            applyFn = (client, sv) => applyTextBodyFontPreset(client, entry, { serverVersion: sv });
+        }
+        else {
+            // Defensive: a new entry in KNOWN_COMMANDS without a dispatch
+            // branch here would silently break dry-run/apply. parseArgs
+            // already gates on KNOWN_COMMANDS upstream, so reaching this is a
+            // programmer error in the dispatch wiring.
+            throw new UsageError(`Unhandled command: ${parsed.command}`);
+        }
     }
     catch (err) {
         if (err instanceof EvidenceGateError) {

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,7 @@ 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";
 /** 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 +73,18 @@ 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>>;

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

@@ -17,6 +17,7 @@
 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";
 /** 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 +109,24 @@ 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,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diviops/mcp-server",
-  "version": "1.5.12",
+  "version": "1.5.13",
   "description": "MCP server exposing Divi 5 Visual Builder as tools for Claude",
   "type": "module",
   "main": "dist/index.js",