@diviops/mcp-server 1.5.11 → 1.5.13

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

@@ -0,0 +1,249 @@
+/**
+ * `divi/font` heading emitter shape + gating coverage:
+ *  - fixture-based shape assertion against round-1a (Pattern A) and
+ *    round-1b (Pattern B) canonical captures;
+ *  - Pattern B no-weight discriminator: omitted `weight` produces no key;
+ *  - Pattern B + explicit weight refused as unverified/out-of-scope;
+ *  - variant-aware registry gating: missing applicability or under-
+ *    verified evidence on the chosen variant throws with attr / pattern /
+ *    effective-level / source in the message; 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 { emitHeadingFontGroupPreset, composeHeadingFontAttrs, buildHeadingFontPresetCreateBody, UnsupportedVariantCombinationError, HEADING_FONT_MODULE, HEADING_FONT_GROUP_NAME, HEADING_FONT_GROUP_ID, HEADING_FONT_PATTERN_VARIANTS, } from "../heading-font-emitter.js";
+import { loadRegistry, EvidenceGateError, } 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_1A = join(FIXTURE_DIR, "round-1a-heading-h1-pattern-a-google.json");
+const FIXTURE_1B = join(FIXTURE_DIR, "round-1b-heading-h1-pattern-b-local.json");
+const registry = loadRegistry();
+test("emitter byte-matches round-1a (Pattern A — Google Fonts) fixture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE_1A, "utf8"));
+    const canonicalAttrs = fixture.preset_entry.attrs;
+    const canonicalStyleAttrs = fixture.preset_entry.styleAttrs;
+    const entry = emitHeadingFontGroupPreset({
+        name: "canonical-heading-h1-vb-google-2026-05-18",
+        pattern: "google",
+        family: "Inter",
+        weight: "700",
+        color: '$variable({"type":"color","value":{"name":"gcid-heading-color","settings":{}}})$',
+        size: "48px",
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the Pattern A canonical capture");
+    // Round 1a observation: attrs and styleAttrs are byte-identical. The
+    // emitter only emits `attrs`; the plugin's /preset/create route mirrors
+    // into styleAttrs. So `attrs` must equal the fixture's styleAttrs too.
+    assert.deepEqual(entry.attrs, canonicalStyleAttrs, "attrs must equal styleAttrs (mirror at /preset/create layer)");
+    assert.equal(entry.type, "group");
+    assert.equal(entry.group_name, HEADING_FONT_GROUP_NAME);
+    assert.equal(entry.group_id, HEADING_FONT_GROUP_ID);
+    assert.equal(entry.module_name, HEADING_FONT_MODULE);
+    assert.equal(entry.pattern_variant, HEADING_FONT_PATTERN_VARIANTS.google);
+});
+test("emitter byte-matches round-1b (Pattern B — local-hosted) fixture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE_1B, "utf8"));
+    const canonicalAttrs = fixture.preset_entry.attrs;
+    const canonicalStyleAttrs = fixture.preset_entry.styleAttrs;
+    const entry = emitHeadingFontGroupPreset({
+        name: "canonical-heading-h1-vb-local-2026-05-18",
+        pattern: "local",
+        family: "Sora 700",
+        // weight intentionally absent — Pattern B encodes the weight in the
+        // family string itself.
+        color: '$variable({"type":"color","value":{"name":"gcid-heading-color","settings":{}}})$',
+        size: "48px",
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the Pattern B canonical capture");
+    assert.deepEqual(entry.attrs, canonicalStyleAttrs, "attrs must equal styleAttrs (mirror at /preset/create layer)");
+    assert.equal(entry.pattern_variant, HEADING_FONT_PATTERN_VARIANTS.local);
+});
+test("Pattern B discriminator: omitted weight produces NO weight key", () => {
+    const attrs = composeHeadingFontAttrs({
+        name: "B",
+        pattern: "local",
+        family: "Sora 700",
+        color: "#666666",
+        size: "48px",
+    });
+    const value = attrs.title.decoration.font.font.desktop.value;
+    assert.equal("weight" in value, false, "Pattern B canonical shape has no `weight` key in attrs.title.decoration.font.font.desktop.value");
+    // The exact set of structural keys, no more, no less. Order is not
+    // semantically meaningful (deep-equal is order-insensitive on objects)
+    // — sort here for a stable assertion.
+    assert.deepEqual(Object.keys(value).sort(), ["color", "family", "size"], "Pattern B emits ONLY the keys the user specified — no defaulted weight");
+});
+test("Pattern A discriminator: weight emitted when specified, absent when not", () => {
+    const withWeight = composeHeadingFontAttrs({
+        name: "A+w",
+        pattern: "google",
+        family: "Inter",
+        weight: "700",
+    });
+    const withoutWeight = composeHeadingFontAttrs({
+        name: "A-w",
+        pattern: "google",
+        family: "Inter",
+    });
+    const wv = withWeight.title.decoration.font.font.desktop.value;
+    const wov = withoutWeight.title.decoration.font.font.desktop.value;
+    assert.equal(wv.weight, "700");
+    assert.equal("weight" in wov, false, "weight absent when not specified");
+});
+test("Pattern B + explicit --font-weight is refused as out-of-scope", () => {
+    assert.throws(() => emitHeadingFontGroupPreset({
+        name: "B-with-weight",
+        pattern: "local",
+        family: "Sora 700",
+        weight: "700",
+    }, registry), (err) => {
+        assert.ok(err instanceof UnsupportedVariantCombinationError);
+        assert.match(err.message, /Pattern B/);
+        assert.match(err.message, /weight/);
+        return true;
+    });
+});
+test("emit-on-specification: only specified keys produce keys (Pattern A)", () => {
+    const attrs = composeHeadingFontAttrs({
+        name: "minimal",
+        pattern: "google",
+        family: "Inter",
+    });
+    const value = attrs.title.decoration.font.font.desktop.value;
+    assert.deepEqual(Object.keys(value), ["family"], "ONLY the touched key emitted — no defaulted weight/color/size/lineHeight");
+});
+test("variable color tokens get the {name,settings} object shape + trailing )$", () => {
+    const attrs = composeHeadingFontAttrs({
+        name: "v",
+        pattern: "google",
+        color: "gcid-heading-color",
+    });
+    const color = attrs.title.decoration.font.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-heading-color", settings: {} },
+    });
+});
+test("literal hex color is emitted verbatim, not wrapped", () => {
+    const attrs = composeHeadingFontAttrs({
+        name: "h",
+        pattern: "google",
+        color: "#666666",
+    });
+    assert.equal(attrs.title.decoration.font.font.desktop.value.color, "#666666");
+});
+test("lineHeight is emitted only when specified", () => {
+    const withLH = composeHeadingFontAttrs({
+        name: "lh+",
+        pattern: "google",
+        family: "Inter",
+        lineHeight: "1.1",
+    });
+    assert.equal(withLH.title.decoration.font.font.desktop.value.lineHeight, "1.1");
+    const without = composeHeadingFontAttrs({
+        name: "lh-",
+        pattern: "google",
+        family: "Inter",
+    });
+    assert.equal("lineHeight" in without.title.decoration.font.font.desktop.value, false);
+});
+test("emitter rejects an invalid `pattern` value", () => {
+    assert.throws(() => emitHeadingFontGroupPreset(
+    // @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(() => emitHeadingFontGroupPreset({ name: "empty", pattern: "google" }, registry), /empty preset/);
+});
+test("emitter rejects a missing name", () => {
+    assert.throws(() => emitHeadingFontGroupPreset({ name: "", pattern: "google", family: "Inter" }, registry), /requires a non-empty `name`/);
+});
+test("variant-aware gate: missing applicability throws with attr+variant+source", () => {
+    // Build a synthetic registry where the Pattern A entry's applicability
+    // for divi/heading is REMOVED — Pattern B still verified. Confirms a
+    // missing applicability cell on the chosen variant is caught at the
+    // gate (not silently inherited from the pattern level), and that the
+    // error message names the variant and the registry source.
+    const real = loadRegistry();
+    const synthetic = JSON.parse(JSON.stringify(real));
+    const t2 = synthetic.tier2 ?? [];
+    const a = t2.find((e) => e.pattern_family === "divi/font" &&
+        e.pattern_variant === HEADING_FONT_PATTERN_VARIANTS.google);
+    assert.ok(a, "test prereq: Pattern A entry must exist in the real registry");
+    // Strip the divi/heading applicability cell from the Pattern A variant.
+    delete a.applicability["divi/heading"];
+    assert.throws(() => emitHeadingFontGroupPreset({
+        name: "missing-applic",
+        pattern: "google",
+        family: "Inter",
+        weight: "700",
+    }, synthetic), (err) => {
+        assert.ok(err instanceof EvidenceGateError);
+        assert.match(err.message, /divi\/font/);
+        assert.match(err.message, /google_fonts_pattern_a/);
+        assert.match(err.message, /UNVERIFIED \(0\)/);
+        assert.match(err.message, /absent from the registry entry/);
+        return true;
+    });
+});
+test("variant isolation: Pattern A evidence does NOT vouch for Pattern B (and vice versa)", () => {
+    // Build a synthetic registry containing ONLY the Pattern A divi/font
+    // entry (Pattern B variant removed). A Pattern-B caller must be
+    // refused — its variant is entirely absent — even though a Pattern A
+    // entry under the same `pattern_family` is fully verified.
+    const real = loadRegistry();
+    const synthetic = JSON.parse(JSON.stringify(real));
+    synthetic.tier2 = (synthetic.tier2 ?? []).filter((e) => !(e.pattern_family === "divi/font" &&
+        e.pattern_variant === HEADING_FONT_PATTERN_VARIANTS.local));
+    assert.throws(() => emitHeadingFontGroupPreset({
+        name: "B-without-its-entry",
+        pattern: "local",
+        family: "Sora 700",
+    }, synthetic), (err) => {
+        // Variant absent entirely → resolveEvidence throws the
+        // "absent from verified-attrs.json" error (not EvidenceGateError).
+        assert.match(err.message, /absent from verified-attrs\.json/, "missing variant must NOT silently fall back to the other variant's evidence");
+        assert.match(err.message, /local_hosted_pattern_b/);
+        return true;
+    });
+    // The reverse: stripping Pattern A and asking for Pattern A.
+    const synthetic2 = JSON.parse(JSON.stringify(real));
+    synthetic2.tier2 = (synthetic2.tier2 ?? []).filter((e) => !(e.pattern_family === "divi/font" &&
+        e.pattern_variant === HEADING_FONT_PATTERN_VARIANTS.google));
+    assert.throws(() => emitHeadingFontGroupPreset({ name: "A-without-its-entry", pattern: "google", family: "Inter" }, synthetic2), /google_fonts_pattern_a/);
+});
+test("buildHeadingFontPresetCreateBody mirrors the diviops_preset_create body shape", () => {
+    const entry = emitHeadingFontGroupPreset({ name: "H1", pattern: "google", family: "Inter", weight: "700" }, registry);
+    const body = buildHeadingFontPresetCreateBody(entry, { dry_run: true });
+    assert.deepEqual(body, {
+        module_name: HEADING_FONT_MODULE,
+        name: "H1",
+        attrs: entry.attrs,
+        type: "group",
+        group_name: HEADING_FONT_GROUP_NAME,
+        group_id: HEADING_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 = buildHeadingFontPresetCreateBody(entry);
+    assert.equal("dry_run" in noDry, false);
+});
+test("real registry: both divi/font variants on divi/heading clear the write threshold", () => {
+    // The verified-attrs.json shipped in-repo MUST keep both Pattern A and
+    // Pattern B at effective-evidence VB_PRESET_STORAGE_VERIFIED (4) for
+    // divi/heading. If a registry edit ever drops one below 4, this test
+    // is the canary.
+    const reg = loadRegistry();
+    const a = emitHeadingFontGroupPreset({ name: "A", pattern: "google", family: "Inter", weight: "700" }, reg);
+    assert.equal(a.pattern_variant, HEADING_FONT_PATTERN_VARIANTS.google);
+    const b = emitHeadingFontGroupPreset({ name: "B", pattern: "local", family: "Sora 700" }, reg);
+    assert.equal(b.pattern_variant, HEADING_FONT_PATTERN_VARIANTS.local);
+});

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

@@ -132,3 +132,44 @@ test("real registry: divi/button styling families clear the write threshold", ()
         gateWriteAttr(reg, "divi/button", fam);
     }
 });
+test("variant-aware lookup selects the correct entry by pattern_variant", () => {
+    // The real registry carries TWO `divi/font` entries that share a
+    // pattern_family but differ on pattern_variant. resolveEvidence must
+    // honor the variant — a Pattern A query must NOT match the Pattern B
+    // entry (and vice versa), even though both share the `divi/font` family.
+    const reg = loadRegistry();
+    const a = resolveEvidence(reg, "divi/heading", "divi/font", "google_fonts_pattern_a");
+    assert.equal(a.patternVariant, "google_fonts_pattern_a");
+    assert.equal(a.effectiveLevel, 4, "Pattern A on divi/heading must clear VB_PRESET_STORAGE_VERIFIED in the shipped registry");
+    const b = resolveEvidence(reg, "divi/heading", "divi/font", "local_hosted_pattern_b");
+    assert.equal(b.patternVariant, "local_hosted_pattern_b");
+    assert.equal(b.effectiveLevel, 4, "Pattern B on divi/heading must clear VB_PRESET_STORAGE_VERIFIED in the shipped registry");
+    // 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,8 +7,10 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { applyButtonPreset, 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) {
@@ -101,6 +103,113 @@ test("applyButtonPreset threads dry_run into the body when requested", async ()
     const options = client.calls[0].options;
     assert.equal(options.body.dry_run, true);
 });
+// ------------------------------------------------------------------
+// heading-font apply-mode — mocked only.
+// Mirrors the button apply-mode coverage: capability gate first, then a
+// single POST to /preset/create with the canonical body. pattern_variant
+// is in-memory only and must NOT appear in the wire body.
+// ------------------------------------------------------------------
+test("applyHeadingFontPreset gates capability BEFORE issuing the write", async () => {
+    const client = mockClient({ capabilities: {} });
+    const entry = emitHeadingFontGroupPreset({ name: "H1", pattern: "google", family: "Inter", weight: "700" }, registry);
+    await assert.rejects(() => applyHeadingFontPreset(client, entry, {
+        serverVersion: TEST_SERVER_VERSION,
+    }), CapabilityMissingError);
+    assert.equal(client.calls.length, 0, "no write issued when capability is absent");
+});
+test("applyHeadingFontPreset posts to /preset/create with the canonical body", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitHeadingFontGroupPreset({
+        name: "H1",
+        pattern: "google",
+        family: "Inter",
+        weight: "700",
+        color: "gcid-heading-color",
+        size: "48px",
+    }, registry);
+    const result = await applyHeadingFontPreset(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/heading");
+    assert.equal(options.body.group_name, "divi/font");
+    assert.equal(options.body.group_id, "designTitleText");
+    assert.equal(options.body.name, "H1");
+    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("applyHeadingFontPreset threads dry_run into the body when requested", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitHeadingFontGroupPreset({ name: "H1", pattern: "local", family: "Sora 700" }, registry);
+    await applyHeadingFontPreset(client, entry, {
+        serverVersion: TEST_SERVER_VERSION,
+        dry_run: true,
+    });
+    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

@@ -23,6 +23,8 @@
  *   4  write / network error
  */
 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;
@@ -50,6 +52,10 @@ export declare class UsageError extends Error {
 }
 /** Map parsed `button` options into the emitter input shape. */
 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