@diviops/mcp-server 1.5.13 → 1.5.14

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

@@ -0,0 +1,409 @@
+/**
+ * `divi/spacing` section emitter shape + gating coverage (Track 7b).
+ *
+ * Pins the load-bearing shape contract from the Track 7a canonical
+ * capture (`round-5-spacing-section.json`):
+ *  - Sparse-emit per axis (only user-touched corners emit; others absent);
+ *  - Paired sync flags per axis (BOTH `syncVertical` AND `syncHorizontal`
+ *    emit when an axis is touched; default `"off"` unless explicitly set);
+ *  - Padding and margin are INDEPENDENT bags (passing only padding flags
+ *    omits the margin bag entirely, and vice versa);
+ *  - `groupId: "designSpacing"` + `primaryAttrName: "module"` baked in
+ *    (NOT inferred from a dotted attr path — Track 7a load-bearing finding);
+ *  - `attrs`-only entry + request body (no `styleAttrs` / `renderAttrs` —
+ *    mirror happens at the route layer per Tracks 4/5/6 contract);
+ *  - Variable-token rejection on length flags (`$variable(...)` and bare
+ *    `gvid-*` / `gcid-*` forms) — deferred until canonical capture lands;
+ *  - Registry gate refusal for every non-section module (heading, text,
+ *    button — all SCHEMA_OBSERVED today).
+ */
+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 { emitSpacingGroupPreset, composeSpacingAttrs, buildSpacingPresetCreateBody, SPACING_GROUP_NAME, SPACING_GROUP_ID, SPACING_PRIMARY_ATTR_NAME, } from "../spacing-emitter.js";
+import { EvidenceGateError, 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-23");
+const FIXTURE_ROUND_5 = join(FIXTURE_DIR, "round-5-spacing-section.json");
+const registry = loadRegistry();
+test("emitter byte-matches round-5 (Track 7a) padding capture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE_ROUND_5, "utf8"));
+    const canonicalAttrs = fixture.preset_entry.attrs;
+    const entry = emitSpacingGroupPreset({
+        name: "Track 7a Section Spacing Capture v2",
+        module: "divi/section",
+        padding: { top: "40px" },
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalAttrs, "emitted attrs must byte-match the Track 7a padding canonical capture");
+    assert.equal(entry.type, "group");
+    assert.equal(entry.group_name, SPACING_GROUP_NAME);
+    assert.equal(entry.group_id, SPACING_GROUP_ID);
+    assert.equal(entry.primary_attr_name, SPACING_PRIMARY_ATTR_NAME);
+    assert.equal(entry.module_name, "divi/section");
+});
+test("emitter byte-matches round-5 (Track 7a) margin capture attrs", () => {
+    const fixture = JSON.parse(readFileSync(FIXTURE_ROUND_5, "utf8"));
+    const canonicalMarginAttrs = fixture.preset_entry_margin.attrs;
+    const entry = emitSpacingGroupPreset({
+        name: "Track 7a Section Margin Capture",
+        module: "divi/section",
+        margin: { top: "30px" },
+    }, registry);
+    assert.deepEqual(entry.attrs, canonicalMarginAttrs, "emitted attrs must byte-match the Track 7a margin canonical capture");
+});
+test("padding-only single corner: sparse-emit + paired sync flags, no margin bag", () => {
+    const entry = emitSpacingGroupPreset({ name: "P", module: "divi/section", padding: { top: "40px" } }, registry);
+    const value = entry.attrs.module.decoration.spacing.desktop.value;
+    assert.deepEqual(Object.keys(value), ["padding"], "no margin bag emitted");
+    assert.deepEqual(value.padding, { top: "40px", syncVertical: "off", syncHorizontal: "off" }, "single-corner padding emits exactly that corner + paired off sync flags");
+});
+test("margin-only single corner: sparse-emit + paired sync flags, no padding bag", () => {
+    const entry = emitSpacingGroupPreset({ name: "M", module: "divi/section", margin: { bottom: "80px" } }, registry);
+    const value = entry.attrs.module.decoration.spacing.desktop.value;
+    assert.deepEqual(Object.keys(value), ["margin"], "no padding bag emitted");
+    assert.deepEqual(value.margin, { bottom: "80px", syncVertical: "off", syncHorizontal: "off" });
+});
+test("padding + margin combined: both bags, each with its own paired sync flags", () => {
+    const entry = emitSpacingGroupPreset({
+        name: "Test",
+        module: "divi/section",
+        padding: { top: "40px" },
+        margin: { bottom: "80px" },
+    }, registry);
+    const value = entry.attrs.module.decoration.spacing.desktop.value;
+    assert.deepEqual(value.padding, { top: "40px", syncVertical: "off", syncHorizontal: "off" });
+    assert.deepEqual(value.margin, { bottom: "80px", syncVertical: "off", syncHorizontal: "off" });
+});
+test("all four corners of one axis: sparse-emit holds (all four present)", () => {
+    const entry = emitSpacingGroupPreset({
+        name: "AllCorners",
+        module: "divi/section",
+        padding: {
+            top: "10px",
+            right: "20px",
+            bottom: "30px",
+            left: "40px",
+        },
+    }, registry);
+    const padding = entry.attrs.module.decoration.spacing.desktop.value
+        .padding;
+    assert.deepEqual(padding, {
+        top: "10px",
+        right: "20px",
+        bottom: "30px",
+        left: "40px",
+        syncVertical: "off",
+        syncHorizontal: "off",
+    });
+});
+test("caller-passed sync-flag values are honored verbatim", () => {
+    const entry = emitSpacingGroupPreset({
+        name: "Sync",
+        module: "divi/section",
+        padding: {
+            top: "40px",
+            bottom: "40px",
+            syncVertical: "on",
+            syncHorizontal: "off",
+        },
+    }, registry);
+    const padding = entry.attrs.module.decoration.spacing.desktop.value
+        .padding;
+    assert.equal(padding.syncVertical, "on");
+    assert.equal(padding.syncHorizontal, "off");
+});
+test("entry carries no renderAttrs / styleAttrs key (mirror happens at route layer)", () => {
+    const entry = emitSpacingGroupPreset({ name: "R", module: "divi/section", padding: { top: "40px" } }, 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 per Tracks 4/5/6 contract");
+    assert.equal("styleAttrs" in entry, false, "same for styleAttrs");
+});
+test("request body carries no renderAttrs / styleAttrs key either", () => {
+    const entry = emitSpacingGroupPreset({ name: "R", module: "divi/section", padding: { top: "40px" } }, registry);
+    const body = buildSpacingPresetCreateBody(entry);
+    assert.equal("renderAttrs" in body, false);
+    assert.equal("styleAttrs" in body, false);
+});
+test("compose: omitted corners produce no keys (no pre-populate)", () => {
+    const { value } = composeSpacingAttrs({
+        name: "x",
+        module: "divi/section",
+        padding: { top: "40px" },
+    });
+    const padding = value.padding;
+    assert.deepEqual(Object.keys(padding).sort(), ["syncHorizontal", "syncVertical", "top"], "only `top` + the two paired sync flags — right/bottom/left absent");
+    assert.equal("right" in padding, false);
+    assert.equal("bottom" in padding, false);
+    assert.equal("left" in padding, false);
+});
+test("empty preset is refused (no padding or margin corners)", () => {
+    assert.throws(() => emitSpacingGroupPreset({ name: "Empty", module: "divi/section" }, registry), /empty preset/);
+});
+test("missing name is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({ name: "", module: "divi/section", padding: { top: "40px" } }, registry), /non-empty `name`/);
+});
+test("missing module is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({ name: "X", module: "", padding: { top: "40px" } }, registry), /requires `module`/);
+});
+test("variable-token in padding length: $variable(...) form is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "V",
+        module: "divi/section",
+        padding: {
+            top: '$variable({"type":"length","value":{"name":"gvid-space-1","settings":{}}})$',
+        },
+    }, registry), /Variable-token support deferred/);
+});
+test("variable-token in padding length: bare gvid-* form is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "V",
+        module: "divi/section",
+        padding: { top: "gvid-space-1" },
+    }, registry), /Variable-token support deferred/);
+});
+test("variable-token in margin length: bare gvid-* form is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "V",
+        module: "divi/section",
+        margin: { bottom: "gvid-space-2" },
+    }, registry), /Variable-token support deferred/);
+});
+test("registry gate: divi/heading is refused (SCHEMA_OBSERVED cell)", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "H",
+        module: "divi/heading",
+        padding: { top: "40px" },
+    }, registry), (err) => {
+        assert.ok(err instanceof EvidenceGateError, "must throw EvidenceGateError, not a plain Error");
+        assert.match(err.message, /divi\/heading/);
+        assert.match(err.message, /divi\/spacing/);
+        return true;
+    });
+});
+test("registry gate: divi/text is refused (SCHEMA_OBSERVED cell)", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "T",
+        module: "divi/text",
+        padding: { top: "40px" },
+    }, registry), EvidenceGateError);
+});
+test("registry gate: divi/button is refused (SCHEMA_OBSERVED cell)", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "B",
+        module: "divi/button",
+        padding: { top: "40px" },
+    }, registry), EvidenceGateError);
+});
+test("registry gate: divi/row is refused (no applicability cell → UNVERIFIED)", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "R",
+        module: "divi/row",
+        padding: { top: "40px" },
+    }, registry), EvidenceGateError);
+});
+test("registry gate: divi/column is refused (no applicability cell → UNVERIFIED)", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "C",
+        module: "divi/column",
+        padding: { top: "40px" },
+    }, registry), EvidenceGateError);
+});
+test("registry gate: arbitrary unknown module is refused", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "U",
+        module: "divi/not-a-real-module",
+        padding: { top: "40px" },
+    }, registry), EvidenceGateError);
+});
+test("real registry: divi/section on divi/spacing clears write threshold (canary)", () => {
+    // Sanity guard: if a registry edit ever drops the (divi/spacing,
+    // divi/section) cell below VB_PRESET_STORAGE_VERIFIED (4), this test is
+    // the canary.
+    const entry = emitSpacingGroupPreset({
+        name: "canary",
+        module: "divi/section",
+        padding: { top: "40px" },
+    }, registry);
+    assert.equal(entry.group_id, SPACING_GROUP_ID);
+    assert.equal(entry.primary_attr_name, SPACING_PRIMARY_ATTR_NAME);
+});
+test("buildSpacingPresetCreateBody mirrors the diviops_preset_create body shape", () => {
+    const entry = emitSpacingGroupPreset({
+        name: "Body",
+        module: "divi/section",
+        padding: { top: "40px" },
+    }, registry);
+    const body = buildSpacingPresetCreateBody(entry, { dry_run: true });
+    assert.deepEqual(body, {
+        module_name: "divi/section",
+        name: "Body",
+        attrs: entry.attrs,
+        type: "group",
+        group_name: SPACING_GROUP_NAME,
+        group_id: SPACING_GROUP_ID,
+        primary_attr_name: SPACING_PRIMARY_ATTR_NAME,
+        dry_run: true,
+    });
+    const noDry = buildSpacingPresetCreateBody(entry);
+    assert.equal("dry_run" in noDry, false);
+});
+test("padding axis with sync flags but no corners is refused explicitly", () => {
+    // Sync-flag-only input on an axis with no touched corner is a usage
+    // error: there is no corner to anchor the sync flags to. The emitter
+    // refuses BEFORE the empty-preset check so the operator gets a precise
+    // error pointing at the axis, not the generic "empty preset" message.
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "SyncOnly",
+        module: "divi/section",
+        padding: { syncVertical: "on", syncHorizontal: "off" },
+    }, registry), /--padding-sync-vertical.*require at least one --padding-\{top,right,bottom,left\}/s);
+});
+test("margin sync flag with no margin corner is refused even when padding has corners", () => {
+    // Cross-axis silent-no-op guard (Copilot finding on PR #754): passing
+    // --margin-sync-vertical on alongside --padding-top 40px previously
+    // silently dropped the margin sync flag (composeAxis returned undefined
+    // for margin, and the padding emission succeeded). The refusal now
+    // fires per-axis so the operator catches the misconfiguration.
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "CrossAxis",
+        module: "divi/section",
+        padding: { top: "40px" },
+        margin: { syncVertical: "on" },
+    }, registry), /--margin-sync-vertical.*require at least one --margin-/s);
+});
+test("padding sync flag with no padding corner is refused even when margin has corners", () => {
+    // Symmetric to the previous test — padding sync flag with no padding
+    // corner must refuse even when the margin axis is fully specified.
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "CrossAxisInverse",
+        module: "divi/section",
+        padding: { syncHorizontal: "on" },
+        margin: { bottom: "40px" },
+    }, registry), /--padding-sync-horizontal.*require at least one --padding-/s);
+});
+test("variable-token rejection still works on leading-whitespace value", () => {
+    // Gemini finding on PR #754: the previous startsWith / regex anchor
+    // could be bypassed with leading whitespace (e.g. " gvid-space-1").
+    // The validator now trims before pattern-matching.
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "Whitespace",
+        module: "divi/section",
+        padding: { top: " gvid-space-1" },
+    }, registry), /Variable-token support deferred/);
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "Whitespace2",
+        module: "divi/section",
+        padding: { top: "  $variable({\"x\":1})$" },
+    }, registry), /Variable-token support deferred/);
+});
+// ------------------------------------------------------------------
+// Literal CSS length grammar — codex re-review finding on PR #754.
+// v1 accepts only `<number><unit>` where unit is one of px / rem / em /
+// % / vw / vh. Free-form strings, var(), calc(), and other unverified
+// grammars are refused before emission.
+// ------------------------------------------------------------------
+test("rejects free-form non-length string (e.g. 'banana')", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "B",
+        module: "divi/section",
+        padding: { top: "banana" },
+    }, registry), /not a literal CSS length/);
+});
+test("rejects var(--x) — unverified grammar in v1", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "V",
+        module: "divi/section",
+        padding: { top: "var(--space-1)" },
+    }, registry), /not a literal CSS length/);
+});
+test("rejects calc() — unverified grammar in v1", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "C",
+        module: "divi/section",
+        margin: { bottom: "calc(8px + 2vw)" },
+    }, registry), /not a literal CSS length/);
+});
+test("rejects bare numeric without unit (e.g. '40')", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "N",
+        module: "divi/section",
+        padding: { top: "40" },
+    }, registry), /not a literal CSS length/);
+});
+test("rejects unsupported unit (e.g. 'pt')", () => {
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "U",
+        module: "divi/section",
+        padding: { top: "40pt" },
+    }, registry), /not a literal CSS length/);
+});
+test("accepts the full v1 unit set (px / rem / em / % / vw / vh)", () => {
+    // Smoke: ensure the validator is positive — each supported unit + a
+    // representative numeric form lands in attrs as-emitted.
+    for (const v of ["40px", "1.5rem", "2em", "100%", "10vw", "5.25vh", "0px"]) {
+        const entry = emitSpacingGroupPreset({ name: "v", module: "divi/section", padding: { top: v } }, registry);
+        const padding = entry.attrs.module.decoration.spacing.desktop
+            .value.padding;
+        assert.equal(padding.top, v, `expected ${v} to pass and be emitted verbatim`);
+    }
+});
+// ------------------------------------------------------------------
+// SPACING_SUPPORTED_MODULES second guard — codex re-review finding on
+// PR #754. Even if a future registry-only PR promotes another cell to
+// VB_PRESET_STORAGE_VERIFIED, this emitter must NOT silently start
+// emitting it — heading/text/button cells need their own per-module
+// wrapper (today the emitter hard-codes wrapper="module").
+// ------------------------------------------------------------------
+function buildElevatedRegistryForHeading() {
+    // Clone the real registry and elevate the divi/heading cell on the
+    // divi/spacing pattern to VB_PRESET_STORAGE_VERIFIED. This simulates a
+    // future registry-only promotion landing without the corresponding
+    // implementation PR.
+    const real = loadRegistry();
+    const cloned = JSON.parse(JSON.stringify(real));
+    const spacing = (cloned.tier1 ?? []).find((e) => e.pattern_family === "divi/spacing") ?? (cloned.tier2 ?? []).find((e) => e.pattern_family === "divi/spacing");
+    if (!spacing || !spacing.applicability) {
+        throw new Error("fixture precondition failed: registry has no divi/spacing pattern entry");
+    }
+    const cell = spacing.applicability["divi/heading"];
+    if (!cell) {
+        throw new Error("fixture precondition failed: divi/spacing pattern has no divi/heading cell");
+    }
+    cell.cell_evidence_level = "VB_PRESET_STORAGE_VERIFIED";
+    return cloned;
+}
+test("divi/heading is refused by SPACING_SUPPORTED_MODULES guard even if registry elevates the cell", () => {
+    // Codex finding on PR #754: registry-only promotion must not bypass
+    // implementation. The constant `SPACING_SUPPORTED_MODULES` acts as a
+    // second guard after `gateWriteAttr`, so a future registry-only PR
+    // promoting divi/heading would still land on this refusal until an
+    // explicit code change extends the constant.
+    const elevated = buildElevatedRegistryForHeading();
+    assert.throws(() => emitSpacingGroupPreset({
+        name: "H",
+        module: "divi/heading",
+        padding: { top: "40px" },
+    }, elevated), (err) => {
+        // NOT an EvidenceGateError — that gate was cleared by the elevated
+        // registry. The refusal comes from the implementation-supported-
+        // modules guard with a distinct message naming the constant.
+        assert.ok(!(err instanceof EvidenceGateError), "with an elevated registry the EvidenceGateError must NOT fire — the implementation guard does");
+        assert.match(err.message, /does not yet implement module/, "refusal cites the implementation guard, not the registry gate");
+        assert.match(err.message, /divi\/heading/, "refusal names the module the caller asked for");
+        assert.match(err.message, /Supported modules: divi\/section/, "refusal names the currently-supported module set");
+        return true;
+    });
+});
+test("divi/section is still allowed under the elevated-registry fixture (sanity)", () => {
+    // Sanity guard: the registry clone + elevation logic does not break
+    // the section path. The section cell stays at VB_PRESET_STORAGE_VERIFIED
+    // both before and after the clone, and the implementation guard
+    // includes it in SPACING_SUPPORTED_MODULES.
+    const elevated = buildElevatedRegistryForHeading();
+    const entry = emitSpacingGroupPreset({ name: "S", module: "divi/section", padding: { top: "40px" } }, elevated);
+    assert.equal(entry.module_name, "divi/section");
+});

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

@@ -7,10 +7,11 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { applyButtonPreset, applyHeadingFontPreset, applyTextBodyFontPreset, assertStorageCapability, buildClientFromEnv, CapabilityMissingError, CredentialsMissingError, STORAGE_CAPABILITY, PRESET_CREATE_ROUTE, } from "../write-path.js";
+import { applyButtonPreset, applyHeadingFontPreset, applyTextBodyFontPreset, applySpacingPreset, 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 { emitSpacingGroupPreset } from "../spacing-emitter.js";
 import { loadRegistry } from "../registry.js";
 const registry = loadRegistry();
 function handshake(capabilities) {
@@ -210,6 +211,63 @@ test("applyTextBodyFontPreset threads dry_run into the body when requested", asy
     const options = client.calls[0].options;
     assert.equal(options.body.dry_run, true);
 });
+// ------------------------------------------------------------------
+// applySpacingPreset — Track 7b mocked apply-mode coverage.
+// Mirrors the text-body-font apply-mode coverage. Notably the spacing
+// body DOES carry primary_attr_name on the wire (the section cell needs
+// it per Track 7a load-bearing finding); the other emitters omit it.
+// ------------------------------------------------------------------
+test("applySpacingPreset gates capability BEFORE issuing the write", async () => {
+    const client = mockClient({ capabilities: {} });
+    const entry = emitSpacingGroupPreset({
+        name: "Sec",
+        module: "divi/section",
+        padding: { top: "40px" },
+    }, registry);
+    await assert.rejects(() => applySpacingPreset(client, entry, { serverVersion: TEST_SERVER_VERSION }), CapabilityMissingError);
+    assert.equal(client.calls.length, 0, "no write issued when capability is absent");
+});
+test("applySpacingPreset posts to /preset/create with the canonical body", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitSpacingGroupPreset({
+        name: "Section Rhythm",
+        module: "divi/section",
+        padding: { top: "80px", bottom: "80px" },
+        margin: { bottom: "40px" },
+    }, registry);
+    await applySpacingPreset(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/section");
+    assert.equal(options.body.group_name, "divi/spacing");
+    assert.equal(options.body.group_id, "designSpacing");
+    assert.equal(options.body.primary_attr_name, "module");
+    assert.deepEqual(options.body.attrs, entry.attrs);
+    assert.equal("styleAttrs" in options.body, false, "styleAttrs is mirrored at the route layer; CLI body carries attrs only");
+    assert.equal("renderAttrs" in options.body, false, "renderAttrs is mirrored at the route layer; CLI body carries attrs only");
+    assert.equal("dry_run" in options.body, false);
+});
+test("applySpacingPreset threads dry_run into the body when requested", async () => {
+    const client = mockClient({ capabilities: { [STORAGE_CAPABILITY]: true } });
+    const entry = emitSpacingGroupPreset({
+        name: "Sec",
+        module: "divi/section",
+        padding: { top: "40px" },
+    }, registry);
+    await applySpacingPreset(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

@@ -25,6 +25,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";
+import { type SpacingEmitterInput } from "./spacing-emitter.js";
 export declare const EXIT: {
     readonly OK: 0;
     readonly INVALID_INPUT: 1;
@@ -56,6 +57,8 @@ export declare function buildButtonInput(parsed: ParsedArgs): ButtonEmitterInput
 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;
+/** Map parsed `spacing` options into the spacing emitter input shape. */
+export declare function buildSpacingInput(parsed: ParsedArgs): SpacingEmitterInput;
 /**
  * Run the CLI. Returns the structured exit code (does NOT call
  * `process.exit` — the thin bin wrapper does). `io` is injectable so