@diviops/mcp-server 1.5.11 → 1.5.12

package/README.md

@@ -85,18 +85,31 @@ See [server-reference.md](../docs/server-reference.md) for per-tool descriptions
 The package also ships a standalone command-line preset emitter, `diviops-preset`,
 that produces byte-canonical Divi 5.5.x preset JSON gated by the verified-attrs
 registry (`data/verified-attrs.json`). It is independent of the MCP stdio server —
-run it directly:
+run it directly. Current commands:
+
+| Command | Emits |
+|---|---|
+| `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) |
 
 ```bash
 diviops-preset button --name "Primary" --bg-color gcid-primary-color \
   --bg-color-hover gcid-secondary-color --radius 8px \
   --font-family Inter --font-weight 600 --font-color gcid-body-color
+
+diviops-preset heading-font --name "Heading H1" --pattern google \
+  --font-family Inter --font-weight 700 \
+  --font-color gcid-heading-color --font-size 48px
 ```
 
 `--dry-run` (the default) composes and prints the canonical JSON with no
 credentials and no network. `--apply` posts to the existing `/preset/create`
 REST route, reusing the same `WP_URL` / `WP_USER` / `WP_APP_PASSWORD` env vars.
-The current scope is one emitter — `divi/button` group presets. See the
+
+The CLI's coverage is intentionally narrow: only the (module, group, variant)
+combinations whose canonical shape is VB-verified in the registry are
+emittable. It is **not** an all-module or all-font-family emitter — each
+additional vertical slice lands with its own verified evidence. See the
 [preset-cli reference](https://github.com/oaris-dev/diviops/blob/main/diviops-server/src/preset-cli/README.md)
 for the full command reference (the `src/` tree is not part of the published
 npm package — this link resolves on the repository).

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

@@ -39,6 +39,14 @@ test("unknown command exits 1 (invalid input)", async () => {
     assert.equal(code, EXIT.INVALID_INPUT);
     assert.match(io.stderr.join("\n"), /Unknown command/);
 });
+test("--help advertises the heading-font command", async () => {
+    const io = capture();
+    const code = await run(["--help"], io);
+    assert.equal(code, EXIT.OK);
+    const help = io.stdout.join("\n");
+    assert.match(help, /heading-font/);
+    assert.match(help, /--pattern <google\|local>/);
+});
 test("unknown flag exits 1 (invalid input)", async () => {
     const io = capture();
     const code = await run(["button", "--name", "X", "--bogus", "y"], io);
@@ -138,6 +146,179 @@ test("parseArgs: --radius-sync rejects values outside on|off", () => {
     const parsed = parseArgs(["button", "--name", "P", "--radius-sync", "maybe"]);
     assert.throws(() => buildButtonInput(parsed), /radius-sync must be/);
 });
+// ------------------------------------------------------------------
+// heading-font command — CLI integration (parse → emit → dry-run JSON)
+// ------------------------------------------------------------------
+test("heading-font dry-run (Pattern A) emits canonical JSON, exit 0", async () => {
+    const io = capture();
+    const code = await run([
+        "heading-font",
+        "--name",
+        "H1",
+        "--pattern",
+        "google",
+        "--font-family",
+        "Inter",
+        "--font-weight",
+        "700",
+        "--font-color",
+        "gcid-heading-color",
+        "--font-size",
+        "48px",
+    ], 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/heading");
+    assert.equal(parsed.group_name, "divi/font");
+    assert.equal(parsed.group_id, "designTitleText");
+    const value = parsed.attrs.title.decoration.font.font.desktop.value;
+    assert.equal(value.family, "Inter");
+    assert.equal(value.weight, "700");
+    assert.equal(value.size, "48px");
+    assert.equal(value.color, '$variable({"type":"color","value":{"name":"gcid-heading-color","settings":{}}})$');
+});
+test("heading-font dry-run (Pattern B) emits no `weight` key", async () => {
+    const io = capture();
+    const code = await run([
+        "heading-font",
+        "--name",
+        "H1-local",
+        "--pattern",
+        "local",
+        "--font-family",
+        "Sora 700",
+        "--font-color",
+        "gcid-heading-color",
+        "--font-size",
+        "48px",
+    ], io);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    const value = parsed.attrs.title.decoration.font.font.desktop.value;
+    assert.equal(value.family, "Sora 700");
+    assert.equal("weight" in value, false, "Pattern B emits no weight key");
+});
+test("heading-font without --pattern exits 1 (invalid input)", async () => {
+    const io = capture();
+    const code = await run([
+        "heading-font",
+        "--name",
+        "H1",
+        "--font-family",
+        "Inter",
+        "--font-weight",
+        "700",
+    ], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /--pattern/);
+    assert.match(io.stderr.join("\n"), /google\|local/);
+});
+test("heading-font without --name exits 1", async () => {
+    const io = capture();
+    const code = await run(["heading-font", "--pattern", "google", "--font-family", "Inter"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /requires --name/);
+});
+test("heading-font --pattern local + --font-weight is refused (exit 1)", async () => {
+    const io = capture();
+    const code = await run([
+        "heading-font",
+        "--name",
+        "H1-bad",
+        "--pattern",
+        "local",
+        "--font-family",
+        "Sora 700",
+        "--font-weight",
+        "700",
+    ], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /Pattern B/);
+});
+test("heading-font --pattern with an invalid value exits 1", async () => {
+    const io = capture();
+    const code = await run([
+        "heading-font",
+        "--name",
+        "H1",
+        "--pattern",
+        "auto",
+        "--font-family",
+        "Inter",
+    ], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /--pattern must be/);
+});
+test("heading-font dry-run requires no credentials and no network", async () => {
+    // Mirrors the dry-run-no-creds button assertion: a heading-font dry-run
+    // must not throw a CredentialsMissingError. Exercises AC: --apply is
+    // the only path that touches credentials/handshake/network.
+    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([
+            "heading-font",
+            "--name",
+            "H1",
+            "--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("heading-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([
+            "heading-font",
+            "--name",
+            "H1",
+            "--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__/heading-font-emitter.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `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.
+ */
+export {};

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,18 @@ 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/);
+});

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

@@ -7,8 +7,9 @@
  */
 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, 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 { loadRegistry } from "../registry.js";
 const registry = loadRegistry();
 function handshake(capabilities) {
@@ -101,6 +102,59 @@ 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);
+});
 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,7 @@
  *   4  write / network error
  */
 import { type ButtonEmitterInput } from "./button-emitter.js";
+import { type HeadingFontEmitterInput } from "./heading-font-emitter.js";
 export declare const EXIT: {
     readonly OK: 0;
     readonly INVALID_INPUT: 1;
@@ -50,6 +51,8 @@ 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;
 /**
  * Run the CLI. Returns the structured exit code (does NOT call
  * `process.exit` — the thin bin wrapper does). `io` is injectable so