@diviops/mcp-server 1.5.10 → 1.5.12

package/README.md

@@ -80,6 +80,40 @@ The server exposes **73 tools** across the categories below. Each category links
 
 See [server-reference.md](../docs/server-reference.md) for per-tool descriptions.
 
+## Bundled CLI — `diviops-preset`
+
+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. 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 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).
+
 ## Response contract
 
 Tools return a standardized envelope. The shape lets clients branch on `ok` and machine-readable `error.code` without parsing freeform messages.

package/dist/preset-cli/__tests__/button-emitter.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `divi/button` emitter shape coverage:
+ *  - fixture-based shape assertion against round-3-button-canonical-complete.json
+ *  - emit-on-specification discriminator (with vs without font.weight)
+ *  - hover shape (NO `value` wrapper), radius vocabulary, variable tokens,
+ *    the do-not-emit list, and the opt-in bypass corner.
+ */
+export {};

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

@@ -0,0 +1,188 @@
+/**
+ * `divi/button` emitter shape coverage:
+ *  - fixture-based shape assertion against round-3-button-canonical-complete.json
+ *  - emit-on-specification discriminator (with vs without font.weight)
+ *  - hover shape (NO `value` wrapper), radius vocabulary, variable tokens,
+ *    the do-not-emit list, and the opt-in bypass corner.
+ */
+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 { emitButtonGroupPreset, composeButtonAttrs, buildPresetCreateBody, } from "../button-emitter.js";
+import { loadRegistry } from "../registry.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..");
+const FIXTURE = join(REPO_ROOT, "docs/verification/evidence/canonical-shape-dumps-2026-05-18/round-3-button-canonical-complete.json");
+const registry = loadRegistry();
+test("emitter byte-matches the round-3 canonical button fixture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE, "utf8"));
+    const canonicalAttrs = fixture.canonical_button_primary_preset.attrs;
+    const entry = emitButtonGroupPreset({
+        name: "canonical-button-primary-vb-2026-05-18",
+        bg_color: "gcid-primary-color",
+        bg_color_hover: "gcid-secondary-color",
+        radius: {
+            topLeft: "8px",
+            topRight: "8px",
+            bottomLeft: "8px",
+            bottomRight: "8px",
+        },
+        font: {
+            family: "Inter",
+            weight: "600",
+            color: "gcid-body-color",
+        },
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the canonical capture");
+    assert.equal(entry.type, "group");
+    assert.equal(entry.group_name, "divi/button");
+    assert.equal(entry.group_id, "button");
+    assert.equal(entry.module_name, "divi/button");
+});
+test("hover bg color emits at desktop.hover.color with NO value wrapper", () => {
+    const attrs = composeButtonAttrs({
+        name: "hover-only",
+        bg_color: "#111111",
+        bg_color_hover: "#222222",
+    });
+    const bg = attrs.button.decoration.background;
+    assert.equal(bg.desktop.value.color, "#111111", "desktop is 3-level (value.color)");
+    assert.equal(bg.desktop.hover.color, "#222222", "hover is 2-level (hover.color)");
+    assert.equal("value" in bg.desktop.hover, false, "hover must NOT carry a `value` wrapper");
+});
+test("emit-on-specification discriminator: font.weight present vs absent", () => {
+    const withWeight = composeButtonAttrs({
+        name: "with-weight",
+        font: { family: "Inter", weight: "600" },
+    });
+    const withoutWeight = composeButtonAttrs({
+        name: "without-weight",
+        font: { family: "Inter" },
+    });
+    const wv = withWeight.button.decoration.font.font.desktop.value;
+    const wov = withoutWeight.button.decoration.font.font.desktop.value;
+    assert.equal(wv.weight, "600", "weight emitted when specified");
+    assert.equal("weight" in wv, true);
+    assert.equal("weight" in wov, false, "weight absent when not specified");
+    assert.deepEqual(Object.keys(wov), ["family"], "ONLY the touched key emitted");
+});
+test("radius vocabulary is {topLeft,topRight,bottomLeft,bottomRight,sync}", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px", bottomRight: "8px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.deepEqual(Object.keys(radius).sort(), [
+        "bottomLeft",
+        "bottomRight",
+        "sync",
+        "topLeft",
+        "topRight",
+    ]);
+    assert.equal(radius.sync, "on", "equal corners derive sync=on");
+});
+test("radius sync derives off when corners differ; partial corners stay absent", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", bottomRight: "4px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.equal(radius.sync, "off");
+    assert.equal("topRight" in radius, false, "untouched corner absent");
+    assert.equal("bottomLeft" in radius, false, "untouched corner absent");
+});
+test("radius sync derives off for a single specified corner (Rule 1a)", () => {
+    // Per Rule 1a in canonical-preset-shapes: a partial corner set must derive
+    // sync="off". A 1-element corner array is trivially "all equal" — auto-
+    // deriving "on" is only correct when all 4 corners are present and identical.
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px" },
+    });
+    const radius = attrs.button.decoration.border.desktop.value.radius;
+    assert.equal(radius.sync, "off", "single corner must NOT derive sync=on");
+    assert.equal("topRight" in radius, false, "untouched corner absent");
+});
+test("radius sync stays off for 3 identical corners; on only with all 4", () => {
+    const three = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px" },
+    });
+    assert.equal(three.button.decoration.border.desktop.value.radius.sync, "off", "3 identical corners is still a partial set — sync=off");
+    const all = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", topRight: "8px", bottomLeft: "8px", bottomRight: "8px" },
+    });
+    assert.equal(all.button.decoration.border.desktop.value.radius.sync, "on", "all 4 identical corners derive sync=on");
+});
+test("explicit radius.sync wins over derivation", () => {
+    const attrs = composeButtonAttrs({
+        name: "r",
+        radius: { topLeft: "8px", sync: "on" },
+    });
+    assert.equal(attrs.button.decoration.border.desktop.value.radius.sync, "on", "an explicitly-passed sync flag is honored regardless of corner count");
+});
+test("variable tokens get the {name,settings} object shape + trailing )$", () => {
+    const attrs = composeButtonAttrs({
+        name: "v",
+        bg_color: "gcid-primary-color",
+    });
+    const color = attrs.button.decoration.background.desktop.value.color;
+    assert.ok(color.endsWith(")$"), "token must end with )$");
+    assert.match(color, /^\$variable\(/);
+    const payload = JSON.parse(color.slice("$variable(".length, -2));
+    assert.deepEqual(payload, {
+        type: "color",
+        value: { name: "gcid-primary-color", settings: {} },
+    });
+});
+test("literal hex color is emitted verbatim, not wrapped", () => {
+    const attrs = composeButtonAttrs({ name: "h", bg_color: "#2563eb" });
+    assert.equal(attrs.button.decoration.background.desktop.value.color, "#2563eb");
+});
+test("do-not-emit list: no attrs.font/spacing top-level, no renderAttrs, no button slot", () => {
+    const entry = emitButtonGroupPreset({
+        name: "clean",
+        bg_color: "#111",
+        font: { family: "Inter" },
+    }, registry);
+    assert.equal("font" in entry.attrs, false, "no top-level attrs.font");
+    assert.equal("spacing" in entry.attrs, false, "no top-level attrs.spacing");
+    assert.equal("renderAttrs" in entry, false, "no renderAttrs");
+    const decoration = entry.attrs.button.decoration;
+    assert.equal("button" in decoration, false, "no button.decoration.button slot by default");
+});
+test("bypass_hover_padding_gate emits ONLY the padding.top corner", () => {
+    const attrs = composeButtonAttrs({
+        name: "bypass",
+        bg_color: "#111",
+        bypass_hover_padding_gate: true,
+    });
+    const buttonSlot = attrs.button.decoration.button;
+    assert.deepEqual(buttonSlot, {
+        desktop: { value: { padding: { top: "0px" } } },
+    });
+});
+test("emitter rejects an empty preset (no styling specified)", () => {
+    assert.throws(() => emitButtonGroupPreset({ name: "empty" }, registry), /empty preset/);
+});
+test("emitter rejects a missing name", () => {
+    assert.throws(() => emitButtonGroupPreset({ name: "" }, registry), /requires a non-empty `name`/);
+});
+test("buildPresetCreateBody mirrors the diviops_preset_create body shape", () => {
+    const entry = emitButtonGroupPreset({ name: "Primary", bg_color: "#111" }, registry);
+    const body = buildPresetCreateBody(entry, { dry_run: true });
+    assert.deepEqual(body, {
+        module_name: "divi/button",
+        name: "Primary",
+        attrs: entry.attrs,
+        type: "group",
+        group_name: "divi/button",
+        group_id: "button",
+        dry_run: true,
+    });
+    const noDry = buildPresetCreateBody(entry);
+    assert.equal("dry_run" in noDry, false, "dry_run omitted when not requested");
+});

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

@@ -0,0 +1,9 @@
+/**
+ * CLI integration coverage: --help, arg parsing, structured exit codes,
+ * dry-run output, evidence-gate exit, capability-missing exit.
+ *
+ * Apply-mode here is exercised through the credential-missing path only
+ * (no live write — #725 AC #8). The mocked write-path proper lives in
+ * write-path.test.ts.
+ */
+export {};

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

@@ -0,0 +1,330 @@
+/**
+ * CLI integration coverage: --help, arg parsing, structured exit codes,
+ * dry-run output, evidence-gate exit, capability-missing exit.
+ *
+ * Apply-mode here is exercised through the credential-missing path only
+ * (no live write — #725 AC #8). The mocked write-path proper lives in
+ * write-path.test.ts.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { run, parseArgs, buildButtonInput, EXIT, UsageError } from "../cli.js";
+/** Capture CLI output without touching real stdio. */
+function capture() {
+    const stdout = [];
+    const stderr = [];
+    return {
+        stdout,
+        stderr,
+        out: (t) => stdout.push(t),
+        err: (t) => stderr.push(t),
+    };
+}
+test("--help prints usage and exits 0", async () => {
+    const io = capture();
+    const code = await run(["--help"], io);
+    assert.equal(code, EXIT.OK);
+    assert.match(io.stdout.join("\n"), /diviops-preset/);
+    assert.match(io.stdout.join("\n"), /EXIT CODES/);
+});
+test("no args prints help and exits 0", async () => {
+    const io = capture();
+    const code = await run([], io);
+    assert.equal(code, EXIT.OK);
+    assert.match(io.stdout.join("\n"), /USAGE/);
+});
+test("unknown command exits 1 (invalid input)", async () => {
+    const io = capture();
+    const code = await run(["section", "--name", "X"], io);
+    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);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /Unknown flag/);
+});
+test("button without --name exits 1", async () => {
+    const io = capture();
+    const code = await run(["button", "--bg-color", "#111"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /requires --name/);
+});
+test("dry-run is the default and prints canonical JSON, exit 0", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "Primary", "--bg-color", "gcid-primary-color"], 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/button");
+    assert.equal(parsed.attrs.button.decoration.background.desktop.value.color, '$variable({"type":"color","value":{"name":"gcid-primary-color","settings":{}}})$');
+});
+test("explicit --dry-run behaves the same as the default", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--bg-color", "#111", "--dry-run"], io);
+    assert.equal(code, EXIT.OK);
+    assert.equal(JSON.parse(io.stdout.join("\n")).dry_run, true);
+});
+test("dry-run requires no credentials and no network", async () => {
+    // No WP_* env vars set in this assertion's expectation: a clean dry-run
+    // run must not throw a CredentialsMissingError.
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--bg-color", "#111"], io);
+    assert.equal(code, EXIT.OK);
+    assert.equal(io.stderr.length, 0, "no error output on a credential-free dry-run");
+});
+test("--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(["button", "--name", "P", "--bg-color", "#111", "--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("--apply and --dry-run together exit 1 (mutually exclusive)", async () => {
+    const io = capture();
+    const code = await run(["button", "--name", "P", "--apply", "--dry-run"], io);
+    assert.equal(code, EXIT.INVALID_INPUT);
+    assert.match(io.stderr.join("\n"), /mutually exclusive/);
+});
+test("parseArgs: --radius shorthand and per-corner overrides", () => {
+    const parsed = parseArgs([
+        "button",
+        "--name",
+        "P",
+        "--radius",
+        "8px",
+        "--radius-top-left",
+        "12px",
+    ]);
+    const input = buildButtonInput(parsed);
+    assert.deepEqual(input.radius, {
+        topLeft: "12px",
+        topRight: "8px",
+        bottomLeft: "8px",
+        bottomRight: "8px",
+    });
+});
+test("parseArgs: --bypass-hover-padding-gate sets the opt-in flag", () => {
+    const parsed = parseArgs(["button", "--name", "P", "--bypass-hover-padding-gate"]);
+    const input = buildButtonInput(parsed);
+    assert.equal(input.bypass_hover_padding_gate, true);
+});
+test("parseArgs: value flag without a value throws UsageError", () => {
+    assert.throws(() => parseArgs(["button", "--name"]), (err) => {
+        assert.ok(err instanceof UsageError);
+        return true;
+    });
+});
+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);
+    assert.equal(code, EXIT.OK);
+    const parsed = JSON.parse(io.stdout.join("\n"));
+    assert.deepEqual(parsed.attrs.button.decoration.button, {
+        desktop: { value: { padding: { top: "0px" } } },
+    });
+});

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 {};