@assistant-ui/react-generative-ui 0.0.23 → 0.1.0

package/src/slack/toSlackBlocks.test.ts

@@ -1,3065 +0,0 @@
-import { decodeBlockAction } from "./decodeBlockAction";
-import { describe, expect, it } from "vitest";
-import {
-  CHILDREN_CAP,
-  MAX_TRAVERSAL_DEPTH,
-  NODE_BUDGET,
-} from "../convert/boundSpec";
-import { toSlackBlocks } from "./toSlackBlocks";
-import {
-  ACTION_ID_CAP,
-  ACTIONS_ELEMENT_CAP,
-  ALERT_TEXT_CAP,
-  BUTTON_VALUE_CAP,
-  CARD_BODY_CAP,
-  CARD_SUBTEXT_CAP,
-  CARD_TITLE_CAP,
-  CAROUSEL_CARD_CAP,
-  CHECKBOX_OPTION_CAP,
-  CONTEXT_ELEMENT_CAP,
-  CONTEXT_TEXT_CAP,
-  DATA_TABLE_CHAR_BUDGET,
-  DATA_TABLE_COLUMN_CAP,
-  DATA_TABLE_ROW_CAP,
-  FACT_FIELD_CAP,
-  FACT_FIELD_TEXT_CAP,
-  HEADER_TEXT_CAP,
-  INPUT_LABEL_CAP,
-  INTERACTIVE_TEXT_CAP,
-  MARKDOWN_TEXT_BUDGET,
-  MESSAGE_BLOCK_CAP,
-  MODAL_BLOCK_CAP,
-  PLACEHOLDER_TEXT_CAP,
-  RADIO_OPTION_CAP,
-  SECTION_TEXT_CAP,
-  SELECT_OPTION_CAP,
-  TABLE_CAPTION,
-} from "./constants";
-import type {
-  SlackActionsBlock,
-  SlackAlertBlock,
-  SlackCardBlock,
-  SlackCarouselBlock,
-  SlackCheckboxesElement,
-  SlackContextBlock,
-  SlackDataTableBlock,
-  SlackInputBlock,
-  SlackRadioButtonsElement,
-  SlackSectionBlock,
-  SlackStaticSelectElement,
-} from "./types";
-
-const hostileSpecies = <T>(
-  source: T[],
-  injected: unknown[],
-  onDispatch: () => void,
-): T[] => {
-  function HostileCtor() {
-    return {
-      map: () => {
-        onDispatch();
-        return injected;
-      },
-      [Symbol.iterator]: function* () {
-        onDispatch();
-        yield* injected;
-      },
-    };
-  }
-  const constructor = { [Symbol.species]: HostileCtor };
-  return new Proxy(source, {
-    get: (target, prop, receiver) =>
-      prop === "constructor"
-        ? constructor
-        : Reflect.get(target, prop, receiver),
-  });
-};
-
-describe("toSlackBlocks", () => {
-  describe("Header", () => {
-    it("renders a header block", () => {
-      const { blocks } = toSlackBlocks({ $type: "Header", text: "Title" });
-      expect(blocks).toEqual([
-        { type: "header", text: { type: "plain_text", text: "Title" } },
-      ]);
-    });
-
-    it(`clamps text to ${HEADER_TEXT_CAP} characters and warns`, () => {
-      const text = "h".repeat(200);
-      const { blocks, warnings } = toSlackBlocks({ $type: "Header", text });
-      expect(blocks).toEqual([
-        {
-          type: "header",
-          text: { type: "plain_text", text: "h".repeat(HEADER_TEXT_CAP) },
-        },
-      ]);
-      expect(warnings).toEqual([
-        {
-          code: "clamped",
-          component: "Header",
-          detail: `text was clamped to ${HEADER_TEXT_CAP} characters.`,
-        },
-      ]);
-    });
-  });
-
-  describe("Text", () => {
-    it("renders a section with mrkdwn text", () => {
-      const { blocks } = toSlackBlocks({ $type: "Text", value: "Hello" });
-      expect(blocks).toEqual([
-        { type: "section", text: { type: "mrkdwn", text: "Hello" } },
-      ]);
-    });
-
-    it(`clamps value to ${SECTION_TEXT_CAP} characters and warns`, () => {
-      const value = "t".repeat(4000);
-      const { blocks, warnings } = toSlackBlocks({ $type: "Text", value });
-      expect((blocks[0] as SlackSectionBlock).text?.text).toHaveLength(
-        SECTION_TEXT_CAP,
-      );
-      expect(warnings).toEqual([
-        {
-          code: "clamped",
-          component: "Text",
-          detail: `value was clamped to ${SECTION_TEXT_CAP} characters.`,
-        },
-      ]);
-    });
-  });
-
-  describe("Caption", () => {
-    it("renders a context block with one mrkdwn element", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Caption",
-        value: "Fine print",
-      });
-      expect(blocks).toEqual([
-        { type: "context", elements: [{ type: "mrkdwn", text: "Fine print" }] },
-      ]);
-    });
-  });
-
-  describe("Badge", () => {
-    it("renders standalone as a context block", () => {
-      const { blocks } = toSlackBlocks({ $type: "Badge", value: "New" });
-      expect(blocks).toEqual([
-        { type: "context", elements: [{ type: "mrkdwn", text: "New" }] },
-      ]);
-    });
-  });
-
-  describe("Fact", () => {
-    it("renders a single fact as one section field", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Fact",
-        label: "Status",
-        value: "Active",
-      });
-      expect(blocks).toEqual([
-        {
-          type: "section",
-          fields: [{ type: "mrkdwn", text: "*Status*\nActive" }],
-        },
-      ]);
-    });
-
-    it("merges consecutive Fact siblings into one section, starting a new section past the field cap", () => {
-      const facts = Array.from({ length: FACT_FIELD_CAP + 2 }, (_, i) => ({
-        $type: "Fact",
-        label: `L${i}`,
-        value: `V${i}`,
-      }));
-      const { blocks, warnings } = toSlackBlocks(facts);
-      expect(blocks).toHaveLength(2);
-      expect((blocks[0] as SlackSectionBlock).fields).toHaveLength(
-        FACT_FIELD_CAP,
-      );
-      expect((blocks[1] as SlackSectionBlock).fields).toHaveLength(2);
-      expect(warnings).toEqual([]);
-    });
-
-    it("appends a directional fact delta to the value text", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Fact",
-        label: "Revenue",
-        value: "$12.4k",
-        delta: "8%",
-        trend: "down",
-      });
-      expect((blocks[0] as SlackSectionBlock).fields?.[0]?.text).toBe(
-        "*Revenue*\n$12.4k (↓ 8%)",
-      );
-    });
-
-    it("breaks Fact merging on a non-Fact sibling", () => {
-      const root = [
-        { $type: "Fact", label: "A", value: "1" },
-        { $type: "Fact", label: "B", value: "2" },
-        { $type: "Text", value: "between" },
-        { $type: "Fact", label: "C", value: "3" },
-      ];
-      const { blocks } = toSlackBlocks(root);
-      expect(blocks).toHaveLength(3);
-      expect((blocks[0] as SlackSectionBlock).fields).toHaveLength(2);
-      expect((blocks[1] as SlackSectionBlock).text).toEqual({
-        type: "mrkdwn",
-        text: "between",
-      });
-      expect((blocks[2] as SlackSectionBlock).fields).toHaveLength(1);
-    });
-
-    it(`clamps a fact field to ${FACT_FIELD_TEXT_CAP} characters and warns`, () => {
-      const value = "v".repeat(FACT_FIELD_TEXT_CAP + 100);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Fact",
-        label: "L",
-        value,
-      });
-      const field = (blocks[0] as SlackSectionBlock).fields?.[0];
-      expect(field?.text).toHaveLength(FACT_FIELD_TEXT_CAP);
-      expect(warnings).toEqual([
-        {
-          code: "clamped",
-          component: "Fact",
-          detail: `field was clamped to ${FACT_FIELD_TEXT_CAP} characters.`,
-        },
-      ]);
-    });
-  });
-
-  describe("Image", () => {
-    it("renders image_url and alt_text, dropping other props silently", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Image",
-        src: "https://x/y.png",
-        alt: "A photo",
-        size: "lg",
-        round: true,
-      });
-      expect(blocks).toEqual([
-        { type: "image", image_url: "https://x/y.png", alt_text: "A photo" },
-      ]);
-      expect(warnings).toEqual([]);
-    });
-  });
-
-  describe("Divider", () => {
-    it("renders a divider block", () => {
-      const { blocks } = toSlackBlocks({ $type: "Divider" });
-      expect(blocks).toEqual([{ type: "divider" }]);
-    });
-  });
-
-  describe("Button", () => {
-    it("maps buttonStyle primary/danger to Slack style, omitting style otherwise", () => {
-      const { blocks: primaryBlocks } = toSlackBlocks({
-        $type: "Button",
-        label: "Go",
-        buttonStyle: "primary",
-        $action: { type: "go" },
-      });
-      expect((primaryBlocks[0] as SlackActionsBlock).elements[0]).toMatchObject(
-        { style: "primary" },
-      );
-
-      const { blocks: dangerBlocks } = toSlackBlocks({
-        $type: "Button",
-        label: "Delete",
-        buttonStyle: "danger",
-        $action: { type: "del" },
-      });
-      expect((dangerBlocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        style: "danger",
-      });
-
-      const { blocks: plainBlocks } = toSlackBlocks({
-        $type: "Button",
-        label: "Neutral",
-        buttonStyle: "secondary",
-        $action: { type: "noop" },
-      });
-      expect(
-        (plainBlocks[0] as SlackActionsBlock).elements[0],
-      ).not.toHaveProperty("style");
-    });
-
-    it('derives action_id from $action.type, falling back to "action", and serializes the remaining payload as value', () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Button",
-        label: "Buy",
-        $action: { type: "buy", sku: "abc" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "button",
-            text: { type: "plain_text", text: "Buy" },
-            action_id: "buy",
-            value: JSON.stringify({ sku: "abc" }),
-          },
-        ],
-      });
-
-      const { blocks: fallbackBlocks } = toSlackBlocks({
-        $type: "Button",
-        label: "Go",
-      });
-      expect(fallbackBlocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "button",
-            text: { type: "plain_text", text: "Go" },
-            action_id: "action",
-          },
-        ],
-      });
-    });
-
-    it(`clamps the label to ${INTERACTIVE_TEXT_CAP} characters and warns`, () => {
-      const label = "x".repeat(100);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Button",
-        label,
-        $action: { type: "go" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        text: { type: "plain_text", text: "x".repeat(INTERACTIVE_TEXT_CAP) },
-      });
-      expect(warnings).toEqual([
-        {
-          code: "clamped",
-          component: "Button",
-          detail: `label was clamped to ${INTERACTIVE_TEXT_CAP} characters.`,
-        },
-      ]);
-    });
-
-    it(`clamps action_id to ${ACTION_ID_CAP} characters and warns`, () => {
-      const longType = "a".repeat(ACTION_ID_CAP + 20);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Button",
-        label: "Go",
-        $action: { type: longType },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        action_id: "a".repeat(ACTION_ID_CAP),
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Button",
-        detail: `action_id was clamped to ${ACTION_ID_CAP} characters.`,
-      });
-    });
-
-    it("preserves field references until state is available to the decoder", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Button",
-        label: "Save",
-        $action: {
-          type: "save",
-          note: { $field: "note" },
-          form: {
-            id: 7,
-            name: { $field: "name", fallback: "Ada" },
-            plan: [{ $field: "plan" }],
-          },
-        },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        action_id: "save",
-        value: JSON.stringify({
-          note: { $field: "note" },
-          form: {
-            id: 7,
-            name: { $field: "name", fallback: "Ada" },
-            plan: [{ $field: "plan" }],
-          },
-        }),
-      });
-      expect(warnings).toEqual([]);
-      expect(
-        decodeBlockAction((blocks[0] as SlackActionsBlock).elements[0]),
-      ).toEqual({ type: "save", form: { id: 7, name: "Ada", plan: [] } });
-    });
-
-    it(`omits value instead of truncating and warns when the serialized action payload exceeds ${BUTTON_VALUE_CAP} characters`, () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Button",
-        label: "Go",
-        $action: { type: "go", blob: "z".repeat(BUTTON_VALUE_CAP) },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "value",
-      );
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Button",
-        detail:
-          "value was dropped because the action payload was too large to round-trip.",
-      });
-    });
-  });
-
-  describe("Select", () => {
-    it("reports options dropped for want of a string label and value", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Select",
-        options: [{ label: "ok", value: "a" }, { label: "bad" }, "nope"],
-      });
-      const select = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackStaticSelectElement;
-      expect(select.options).toHaveLength(1);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Select",
-        detail: "2 options were dropped for want of a string label and value.",
-      });
-    });
-
-    it("converts options and placeholder", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Select",
-        placeholder: "Pick one",
-        options: [
-          { label: "Alpha", value: "a" },
-          { label: "Beta", value: "b" },
-        ],
-        $action: { type: "pick" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "static_select",
-            action_id: "pick",
-            options: [
-              { text: { type: "plain_text", text: "Alpha" }, value: "a" },
-              { text: { type: "plain_text", text: "Beta" }, value: "b" },
-            ],
-            placeholder: { type: "plain_text", text: "Pick one" },
-          },
-        ],
-      });
-    });
-
-    it("sets initial_option from a matching defaultValue", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Select",
-        defaultValue: "b",
-        options: [
-          { label: "Alpha", value: "a" },
-          { label: "Beta", value: "b" },
-        ],
-      });
-      expect(
-        (
-          (blocks[0] as SlackActionsBlock)
-            .elements[0] as SlackStaticSelectElement
-        ).initial_option,
-      ).toEqual({ text: { type: "plain_text", text: "Beta" }, value: "b" });
-    });
-
-    it("sets initial_option from a matching empty defaultValue", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Select",
-        defaultValue: "",
-        options: [{ label: "No preference", value: "" }],
-      });
-      expect(
-        (
-          (blocks[0] as SlackActionsBlock)
-            .elements[0] as SlackStaticSelectElement
-        ).initial_option,
-      ).toEqual({
-        text: { type: "plain_text", text: "No preference" },
-        value: "",
-      });
-    });
-
-    it("omits initial_option when defaultValue has no matching option", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Select",
-        defaultValue: "missing",
-        options: [{ label: "Alpha", value: "a" }],
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "initial_option",
-      );
-    });
-
-    it(`clamps options past ${SELECT_OPTION_CAP} entries and warns`, () => {
-      const options = Array.from({ length: SELECT_OPTION_CAP + 5 }, (_, i) => ({
-        label: `L${i}`,
-        value: `v${i}`,
-      }));
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Select",
-        options,
-        $action: { type: "pick" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackStaticSelectElement;
-      expect(element.options).toHaveLength(SELECT_OPTION_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Select",
-        detail: `options were clamped to ${SELECT_OPTION_CAP} entries.`,
-      });
-    });
-
-    it("does not dispatch a prop array through Symbol.species", () => {
-      let dispatches = 0;
-      const injected = Array.from(
-        { length: SELECT_OPTION_CAP + 1 },
-        (_, i) => ({ label: `injected-${i}`, value: `injected-${i}` }),
-      );
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Select",
-        options: hostileSpecies(
-          [{ label: "kept", value: "kept" }],
-          injected,
-          () => {
-            dispatches += 1;
-          },
-        ),
-        $action: { type: "pick" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackStaticSelectElement;
-      expect(element.options).toEqual([
-        { text: { type: "plain_text", text: "kept" }, value: "kept" },
-      ]);
-      expect(dispatches).toBe(0);
-      expect(warnings).toEqual([]);
-    });
-
-    it(`clamps an option label to ${INTERACTIVE_TEXT_CAP} characters and warns`, () => {
-      const longLabel = "y".repeat(90);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Select",
-        options: [{ label: longLabel, value: "v" }],
-        $action: { type: "pick" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackStaticSelectElement;
-      expect(element.options[0]?.text.text).toBe(
-        "y".repeat(INTERACTIVE_TEXT_CAP),
-      );
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Select",
-        detail: `option label was clamped to ${INTERACTIVE_TEXT_CAP} characters.`,
-      });
-    });
-
-    it(`clamps the placeholder to ${PLACEHOLDER_TEXT_CAP} characters and warns`, () => {
-      const placeholder = "p".repeat(PLACEHOLDER_TEXT_CAP + 20);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Select",
-        placeholder,
-        options: [{ label: "A", value: "a" }],
-        $action: { type: "pick" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackStaticSelectElement;
-      expect(element.placeholder?.text).toHaveLength(PLACEHOLDER_TEXT_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Select",
-        detail: `placeholder was clamped to ${PLACEHOLDER_TEXT_CAP} characters.`,
-      });
-    });
-  });
-
-  describe("Input", () => {
-    it("keeps number text and drops the omitted password's field fallback", () => {
-      const { blocks, warnings } = toSlackBlocks([
-        {
-          $type: "Input",
-          name: "quantity",
-          inputType: "number",
-          defaultValue: "2.5",
-          $action: { type: "edit_quantity" },
-        },
-        {
-          $type: "Input",
-          name: "password",
-          label: "Password",
-          inputType: "password",
-          defaultValue: "secret",
-        },
-        {
-          $type: "Button",
-          label: "Submit",
-          $action: {
-            type: "submit",
-            quantity: { $field: "quantity" },
-            password: { $field: "password", fallback: "secret" },
-          },
-        },
-      ]);
-      expect(blocks[0]).toMatchObject({
-        type: "input",
-        element: { type: "plain_text_input", initial_value: "2.5" },
-      });
-      expect(blocks[1]).toEqual({
-        type: "context",
-        elements: [
-          { type: "mrkdwn", text: "Password input omitted on Slack." },
-        ],
-      });
-      expect(blocks.filter((block) => block.type === "input")).toHaveLength(1);
-      expect(JSON.stringify(blocks)).not.toContain("secret");
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Input",
-        detail: "Password input was replaced by a Slack omission note.",
-      });
-      const button = blocks[2];
-      const numberInput = blocks[0];
-      if (
-        button?.type !== "actions" ||
-        button.elements[0]?.type !== "button" ||
-        numberInput?.type !== "input" ||
-        !numberInput.block_id
-      ) {
-        throw new Error("Expected a named number input and submit button");
-      }
-      expect(
-        decodeBlockAction(button.elements[0], {
-          [numberInput.block_id]: {
-            edit_quantity: { type: "plain_text_input", value: "3.5" },
-          },
-        }),
-      ).toEqual({
-        type: "submit",
-        quantity: "3.5",
-      });
-    });
-
-    it("drops nested password fallbacks from button values", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Col",
-        children: [
-          {
-            $type: "Input",
-            name: "password",
-            inputType: "password",
-          },
-          {
-            $type: "Button",
-            label: "Submit",
-            $action: {
-              type: "submit",
-              fields: [
-                { password: { $field: "password", fallback: "secret" } },
-              ],
-            },
-          },
-        ],
-      });
-      expect(JSON.stringify(blocks)).not.toContain("secret");
-    });
-
-    it("drops a button value that nests a password reference past the traversal limit", () => {
-      let nested: unknown = { $field: "password", fallback: "secret" };
-      for (let depth = 0; depth <= MAX_TRAVERSAL_DEPTH; depth++) {
-        nested = { nested };
-      }
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Col",
-        children: [
-          { $type: "Input", name: "password", inputType: "password" },
-          {
-            $type: "Button",
-            label: "Submit",
-            $action: { type: "submit", nested },
-          },
-        ],
-      });
-      expect(JSON.stringify(blocks)).not.toContain("secret");
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Button",
-        detail:
-          "value was dropped because the action payload could not be serialized.",
-      });
-      const button = blocks[1];
-      if (button?.type !== "actions" || button.elements[0]?.type !== "button") {
-        throw new Error("Expected a submit button");
-      }
-      expect(button.elements[0].value).toBeUndefined();
-    });
-
-    it("carries a named control in its block_id", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Input",
-        name: "email",
-        label: "Email",
-      });
-      expect(blocks[0]).toMatchObject({
-        type: "input",
-        block_id: `aui:0:${JSON.stringify([["action", "email"]])}`,
-      });
-      expect(warnings).toEqual([]);
-    });
-
-    it("warns when a name cannot fit in Slack's block_id limit", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Input",
-        name: "n".repeat(250),
-        label: "Name",
-      });
-      expect(blocks[0]).not.toHaveProperty("block_id");
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Input",
-        detail:
-          "name could not be mapped because its Slack block_id exceeded 255 characters.",
-      });
-    });
-
-    it("wraps a plain_text_input element, passing multiline through", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Input",
-        label: "Notes",
-        placeholder: "Type here",
-        multiline: true,
-        $action: { type: "notes" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "input",
-        label: { type: "plain_text", text: "Notes" },
-        element: {
-          type: "plain_text_input",
-          action_id: "notes",
-          multiline: true,
-          placeholder: { type: "plain_text", text: "Type here" },
-        },
-      });
-    });
-
-    it("omits multiline when not set", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Input",
-        label: "Name",
-        $action: { type: "name" },
-      });
-      expect((blocks[0] as SlackInputBlock).element).not.toHaveProperty(
-        "multiline",
-      );
-    });
-
-    it("omits multiline for a number input", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Input",
-        inputType: "number",
-        multiline: true,
-      });
-      expect((blocks[0] as SlackInputBlock).element).not.toHaveProperty(
-        "multiline",
-      );
-    });
-
-    it("sets initial_value from a non-empty defaultValue", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Input",
-        label: "Notes",
-        defaultValue: "Draft reply",
-      });
-      expect((blocks[0] as SlackInputBlock).element.initial_value).toBe(
-        "Draft reply",
-      );
-    });
-
-    it("omits initial_value when defaultValue is empty", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Input",
-        label: "Notes",
-        defaultValue: "",
-      });
-      expect((blocks[0] as SlackInputBlock).element).not.toHaveProperty(
-        "initial_value",
-      );
-    });
-
-    it(`clamps label to ${INPUT_LABEL_CAP} and placeholder to ${PLACEHOLDER_TEXT_CAP} characters, warning on each`, () => {
-      const label = "l".repeat(INPUT_LABEL_CAP + 10);
-      const placeholder = "p".repeat(PLACEHOLDER_TEXT_CAP + 10);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Input",
-        label,
-        placeholder,
-        $action: { type: "notes" },
-      });
-      const input = blocks[0] as SlackInputBlock;
-      expect(input.label.text).toHaveLength(INPUT_LABEL_CAP);
-      expect(input.element.placeholder?.text).toHaveLength(
-        PLACEHOLDER_TEXT_CAP,
-      );
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Input",
-        detail: `label was clamped to ${INPUT_LABEL_CAP} characters.`,
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Input",
-        detail: `placeholder was clamped to ${PLACEHOLDER_TEXT_CAP} characters.`,
-      });
-    });
-  });
-
-  describe("DatePicker", () => {
-    it("sets initial_date from value", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "DatePicker",
-        value: "2026-07-15",
-        $action: { type: "pick_date" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "datepicker",
-            action_id: "pick_date",
-            initial_date: "2026-07-15",
-          },
-        ],
-      });
-    });
-
-    it("omits initial_date when value is absent", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "DatePicker",
-        $action: { type: "pick_date" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "initial_date",
-      );
-      expect(warnings).toEqual([]);
-    });
-
-    it("drops a value that does not match YYYY-MM-DD and warns", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "DatePicker",
-        value: "07/15/2026",
-        $action: { type: "pick_date" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "initial_date",
-      );
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "DatePicker",
-        detail: "value did not match the YYYY-MM-DD format and was dropped.",
-      });
-    });
-  });
-
-  describe("Slider", () => {
-    it("renders a number input block with its numeric bounds", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Slider",
-        label: "Quantity",
-        min: 1,
-        max: 12,
-        step: 0.5,
-        defaultValue: 3.5,
-        $action: { type: "set_quantity" },
-      });
-
-      expect(blocks).toEqual([
-        {
-          type: "input",
-          label: { type: "plain_text", text: "Quantity" },
-          element: {
-            type: "number_input",
-            action_id: "set_quantity",
-            min_value: 1,
-            max_value: 12,
-            initial_value: 3.5,
-            is_decimal_allowed: true,
-          },
-        },
-      ]);
-    });
-
-    it.each([
-      ["minimum", { min: 0.5, max: 2, step: 1 }],
-      ["maximum", { min: 0, max: 2.5 }],
-      ["default value", { min: 0, max: 2, step: 1, defaultValue: 0.5 }],
-    ])("allows decimals when the %s is fractional", (_property, values) => {
-      const { blocks } = toSlackBlocks({
-        $type: "Slider",
-        label: "Quantity",
-        ...values,
-      });
-
-      expect(blocks[0]).toMatchObject({
-        element: { type: "number_input", is_decimal_allowed: true },
-      });
-    });
-
-    it("uses the same input block when nested in a Form", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Form",
-        children: { $type: "Slider", label: "Quantity", min: 1, max: 12 },
-      });
-
-      expect(blocks[0]).toMatchObject({
-        type: "input",
-        element: { type: "number_input", min_value: 1, max_value: 12 },
-      });
-    });
-  });
-
-  describe("Checkbox", () => {
-    it("emits a single-option checkboxes element", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Checkbox",
-        label: "Agree",
-        name: "agree",
-        $action: { type: "toggle" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        block_id: `aui:0:${JSON.stringify([["toggle", "agree", "Checkbox"]])}`,
-        elements: [
-          {
-            type: "checkboxes",
-            action_id: "toggle",
-            options: [
-              { text: { type: "plain_text", text: "Agree" }, value: "agree" },
-            ],
-          },
-        ],
-      });
-      const block = blocks[0];
-      if (block?.type !== "actions" || !block.block_id) {
-        throw new Error("Expected a named checkbox block");
-      }
-      const checkbox = block.elements[0];
-      if (checkbox?.type !== "checkboxes") {
-        throw new Error("Expected a checkbox");
-      }
-      for (const [selectedOptions, expected] of [
-        [[], []],
-        [checkbox.options, ["agree"]],
-      ] as const) {
-        expect(
-          decodeBlockAction({
-            type: "checkboxes",
-            block_id: block.block_id,
-            action_id: checkbox.action_id,
-            selected_options: selectedOptions,
-          }),
-        ).toEqual({ type: "toggle", $input: expected });
-      }
-    });
-
-    it("falls back to the label as the option value when name is absent", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Checkbox",
-        label: "Agree",
-        $action: { type: "toggle" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        options: [{ value: "Agree" }],
-      });
-    });
-
-    it("emits initial_options with its single option when defaultChecked is true", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Checkbox",
-        label: "Agree",
-        name: "agree",
-        defaultChecked: true,
-        $action: { type: "toggle" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackCheckboxesElement;
-      expect(element.initial_options).toEqual([
-        { text: { type: "plain_text", text: "Agree" }, value: "agree" },
-      ]);
-    });
-
-    it("omits initial_options when defaultChecked is absent or false", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Checkbox",
-        label: "Agree",
-        $action: { type: "toggle" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "initial_options",
-      );
-    });
-
-    it("maps a switch like a checkbox", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Checkbox",
-        label: "Agree",
-        variant: "switch",
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        type: "checkboxes",
-        options: [{ value: "Agree" }],
-      });
-    });
-  });
-
-  describe("RadioGroup", () => {
-    it("maps option descriptions to Slack option descriptions", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "RadioGroup",
-        options: [
-          {
-            label: "Free",
-            description: "For personal projects",
-            value: "free",
-          },
-        ],
-      });
-
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        options: [
-          {
-            description: { type: "plain_text", text: "For personal projects" },
-          },
-        ],
-      });
-    });
-
-    it("names RadioGroup when the same option loss happens there", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "RadioGroup",
-        options: [{ label: "ok", value: "a" }, { label: "bad" }],
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "RadioGroup",
-        detail: "1 option was dropped for want of a string label and value.",
-      });
-    });
-
-    const options = [
-      { label: "Small", value: "s" },
-      { label: "Large", value: "l" },
-    ];
-
-    it("sets initial_option from a matching value prop", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "RadioGroup",
-        options,
-        value: "l",
-        $action: { type: "size" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        initial_option: { value: "l" },
-      });
-    });
-
-    it("sets initial_option from a matching defaultValue prop", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "RadioGroup",
-        options,
-        defaultValue: "s",
-        $action: { type: "size" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).toMatchObject({
-        initial_option: { value: "s" },
-      });
-    });
-
-    it("omits initial_option when nothing matches", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "RadioGroup",
-        options,
-        $action: { type: "size" },
-      });
-      expect((blocks[0] as SlackActionsBlock).elements[0]).not.toHaveProperty(
-        "initial_option",
-      );
-    });
-
-    it(`clamps options past ${RADIO_OPTION_CAP} entries and warns`, () => {
-      const manyOptions = Array.from(
-        { length: RADIO_OPTION_CAP + 3 },
-        (_, i) => ({ label: `L${i}`, value: `v${i}` }),
-      );
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "RadioGroup",
-        options: manyOptions,
-        $action: { type: "size" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackRadioButtonsElement;
-      expect(element.options).toHaveLength(RADIO_OPTION_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "RadioGroup",
-        detail: `options were clamped to ${RADIO_OPTION_CAP} entries.`,
-      });
-    });
-  });
-
-  describe("CheckboxGroup", () => {
-    const options = [
-      { label: "Small", value: "s" },
-      { label: "Large", value: "l" },
-    ];
-
-    it("emits a multi-option checkboxes element", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "CheckboxGroup",
-        options,
-        $action: { type: "sizes" },
-      });
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "checkboxes",
-            action_id: "sizes",
-            options: [
-              { text: { type: "plain_text", text: "Small" }, value: "s" },
-              { text: { type: "plain_text", text: "Large" }, value: "l" },
-            ],
-          },
-        ],
-      });
-    });
-
-    it("sets initial_options from matching defaultValue entries", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "CheckboxGroup",
-        options,
-        defaultValue: ["l", "missing"],
-        $action: { type: "sizes" },
-      });
-      expect(
-        ((blocks[0] as SlackActionsBlock).elements[0] as SlackCheckboxesElement)
-          .initial_options,
-      ).toEqual([{ text: { type: "plain_text", text: "Large" }, value: "l" }]);
-
-      const { blocks: withoutInitialOptions } = toSlackBlocks({
-        $type: "CheckboxGroup",
-        options,
-        defaultValue: ["missing"],
-        $action: { type: "sizes" },
-      });
-      expect(
-        (withoutInitialOptions[0] as SlackActionsBlock).elements[0],
-      ).not.toHaveProperty("initial_options");
-    });
-
-    it("names CheckboxGroup when malformed options are dropped", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "CheckboxGroup",
-        options: [{ label: "ok", value: "a" }, { label: "bad" }],
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "CheckboxGroup",
-        detail: "1 option was dropped for want of a string label and value.",
-      });
-    });
-
-    it(`clamps options past ${CHECKBOX_OPTION_CAP} entries and warns`, () => {
-      const manyOptions = Array.from(
-        { length: CHECKBOX_OPTION_CAP + 3 },
-        (_, i) => ({ label: `L${i}`, value: `v${i}` }),
-      );
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "CheckboxGroup",
-        options: manyOptions,
-        $action: { type: "sizes" },
-      });
-      const element = (blocks[0] as SlackActionsBlock)
-        .elements[0] as SlackCheckboxesElement;
-      expect(element.options).toHaveLength(CHECKBOX_OPTION_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "CheckboxGroup",
-        detail: `options were clamped to ${CHECKBOX_OPTION_CAP} entries.`,
-      });
-    });
-  });
-
-  describe("interactive grouping", () => {
-    it("groups consecutive interactive siblings into one actions block, split by a non-interactive sibling", () => {
-      const root = [
-        { $type: "Button", label: "A", $action: { type: "a" } },
-        {
-          $type: "Select",
-          options: [{ label: "X", value: "x" }],
-          $action: { type: "b" },
-        },
-        {
-          $type: "CheckboxGroup",
-          options: [{ label: "Y", value: "y" }],
-          $action: { type: "checkbox" },
-        },
-        { $type: "Text", value: "gap" },
-        { $type: "Button", label: "C", $action: { type: "c" } },
-      ];
-      const { blocks } = toSlackBlocks(root);
-      expect(blocks).toHaveLength(3);
-      expect(blocks[0]).toMatchObject({
-        type: "actions",
-        elements: [
-          { type: "button" },
-          { type: "static_select" },
-          { type: "checkboxes" },
-        ],
-      });
-      expect(blocks[1]).toMatchObject({ type: "section" });
-      expect(blocks[2]).toMatchObject({
-        type: "actions",
-        elements: [{ type: "button" }],
-      });
-    });
-
-    it(`splits an actions block past the ${ACTIONS_ELEMENT_CAP}-element cap`, () => {
-      const total = ACTIONS_ELEMENT_CAP + 5;
-      const buttons = Array.from({ length: total }, (_, i) => ({
-        $type: "Button",
-        label: `B${i}`,
-        $action: { type: `b${i}` },
-      }));
-      const { blocks, warnings } = toSlackBlocks(buttons);
-      expect(blocks).toHaveLength(2);
-      expect((blocks[0] as SlackActionsBlock).elements).toHaveLength(
-        ACTIONS_ELEMENT_CAP,
-      );
-      expect((blocks[1] as SlackActionsBlock).elements).toHaveLength(
-        total - ACTIONS_ELEMENT_CAP,
-      );
-      expect(warnings).toEqual([]);
-    });
-  });
-
-  describe("Alert", () => {
-    it("renders the info tone by default", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Alert",
-        title: "Heads up",
-        description: "Something happened.",
-      });
-      expect(blocks).toEqual([
-        {
-          type: "context",
-          elements: [{ type: "mrkdwn", text: "ℹ️ *Heads up*" }],
-        },
-        {
-          type: "section",
-          text: { type: "mrkdwn", text: "Something happened." },
-        },
-      ]);
-      expect(warnings).toEqual([
-        {
-          code: "fallback",
-          component: "Alert",
-          detail: "Alert was rendered with message-surface fallback blocks.",
-        },
-      ]);
-    });
-
-    it("renders the success tone emoji", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Alert",
-        title: "Done",
-        tone: "success",
-      });
-      expect(blocks[0]).toEqual({
-        type: "context",
-        elements: [{ type: "mrkdwn", text: "✅ *Done*" }],
-      });
-    });
-
-    it("renders the warning tone emoji", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Alert",
-        title: "Careful",
-        tone: "warning",
-      });
-      expect(blocks[0]).toEqual({
-        type: "context",
-        elements: [{ type: "mrkdwn", text: "⚠️ *Careful*" }],
-      });
-    });
-
-    it("renders the danger tone emoji", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Alert",
-        title: "Stop",
-        tone: "danger",
-      });
-      expect(blocks[0]).toEqual({
-        type: "context",
-        elements: [{ type: "mrkdwn", text: "🛑 *Stop*" }],
-      });
-    });
-
-    it("renders just the emoji when no title is given", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Alert",
-        description: "No title here.",
-      });
-      expect(blocks[0]).toEqual({
-        type: "context",
-        elements: [{ type: "mrkdwn", text: "ℹ️" }],
-      });
-    });
-
-    it("renders a native alert block on the modal surface, joining title and description", () => {
-      const { blocks, warnings } = toSlackBlocks(
-        {
-          $type: "Alert",
-          title: "Heads up",
-          description: "Something happened.",
-        },
-        { surface: "modal" },
-      );
-      expect(blocks).toEqual([
-        {
-          type: "alert",
-          text: { type: "mrkdwn", text: "Heads up\nSomething happened." },
-          level: "info",
-        },
-      ]);
-      expect(warnings).toEqual([]);
-    });
-
-    it("maps the danger tone to the error level on the modal surface", () => {
-      const { blocks } = toSlackBlocks(
-        { $type: "Alert", title: "Stop", tone: "danger" },
-        { surface: "modal" },
-      );
-      expect(blocks).toEqual([
-        {
-          type: "alert",
-          text: { type: "mrkdwn", text: "Stop" },
-          level: "error",
-        },
-      ]);
-    });
-
-    it("maps the success and warning tones to like-named levels on the modal surface", () => {
-      const { blocks: successBlocks } = toSlackBlocks(
-        { $type: "Alert", title: "Done", tone: "success" },
-        { surface: "modal" },
-      );
-      expect((successBlocks[0] as SlackAlertBlock).level).toBe("success");
-
-      const { blocks: warningBlocks } = toSlackBlocks(
-        { $type: "Alert", title: "Careful", tone: "warning" },
-        { surface: "modal" },
-      );
-      expect((warningBlocks[0] as SlackAlertBlock).level).toBe("warning");
-    });
-
-    it(`clamps modal alert text to ${ALERT_TEXT_CAP} characters and warns`, () => {
-      const description = "d".repeat(ALERT_TEXT_CAP + 50);
-      const { blocks, warnings } = toSlackBlocks(
-        { $type: "Alert", description },
-        { surface: "modal" },
-      );
-      expect((blocks[0] as SlackAlertBlock).text.text).toHaveLength(
-        ALERT_TEXT_CAP,
-      );
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Alert",
-        detail: `text was clamped to ${ALERT_TEXT_CAP} characters.`,
-      });
-    });
-
-    it("keeps the message-surface fallback unchanged when the surface is explicitly set to message", () => {
-      const { blocks, warnings } = toSlackBlocks(
-        {
-          $type: "Alert",
-          title: "Heads up",
-          description: "Something happened.",
-        },
-        { surface: "message" },
-      );
-      expect(blocks).toEqual([
-        {
-          type: "context",
-          elements: [{ type: "mrkdwn", text: "ℹ️ *Heads up*" }],
-        },
-        {
-          type: "section",
-          text: { type: "mrkdwn", text: "Something happened." },
-        },
-      ]);
-      expect(warnings).toEqual([
-        {
-          code: "fallback",
-          component: "Alert",
-          detail: "Alert was rendered with message-surface fallback blocks.",
-        },
-      ]);
-    });
-  });
-
-  describe("Card", () => {
-    it("maps a clean card into a native card block with title, hero image, body, subtext, and actions", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        title: "Order #42",
-        confirm: { label: "Ship", $action: { type: "ship" } },
-        cancel: { label: "Cancel", $action: { type: "cancel" } },
-        children: [
-          { $type: "Image", src: "https://x/y.png", alt: "Package" },
-          { $type: "Text", value: "Shipped" },
-          { $type: "Caption", value: "Updated just now" },
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "card",
-          hero_image: {
-            type: "image",
-            image_url: "https://x/y.png",
-            alt_text: "Package",
-          },
-          title: { type: "mrkdwn", text: "Order #42" },
-          body: { type: "mrkdwn", text: "Shipped" },
-          subtext: { type: "mrkdwn", text: "Updated just now" },
-          actions: [
-            {
-              type: "button",
-              text: { type: "plain_text", text: "Ship" },
-              action_id: "ship",
-              style: "primary",
-            },
-            {
-              type: "button",
-              text: { type: "plain_text", text: "Cancel" },
-              action_id: "cancel",
-            },
-          ],
-        },
-      ]);
-      expect(warnings).toEqual([]);
-    });
-
-    it("maps confirm/cancel to the actions array directly, without a title or body", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Card",
-        confirm: { label: "Yes", $action: { type: "confirm_yes" } },
-        cancel: { label: "No", $action: { type: "confirm_no" } },
-      });
-      expect(blocks).toEqual([
-        {
-          type: "card",
-          actions: [
-            {
-              type: "button",
-              text: { type: "plain_text", text: "Yes" },
-              action_id: "confirm_yes",
-              style: "primary",
-            },
-            {
-              type: "button",
-              text: { type: "plain_text", text: "No" },
-              action_id: "confirm_no",
-            },
-          ],
-        },
-      ]);
-    });
-
-    it("falls back to a header and inline sequence when content does not fit the card shape", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        title: "Order #42",
-        children: [
-          { $type: "Text", value: "Shipped" },
-          { $type: "Fact", label: "Carrier", value: "UPS" },
-        ],
-      });
-      expect(blocks).toEqual([
-        { type: "header", text: { type: "plain_text", text: "Order #42" } },
-        { type: "section", text: { type: "mrkdwn", text: "Shipped" } },
-        {
-          type: "section",
-          fields: [{ type: "mrkdwn", text: "*Carrier*\nUPS" }],
-        },
-      ]);
-      expect(warnings).toEqual([
-        {
-          code: "fallback",
-          component: "Card",
-          detail:
-            "A card with content beyond hero_image, body, subtext, and actions was rendered inline.",
-        },
-      ]);
-    });
-
-    it("falls back when a second Image cannot fit the single hero_image slot", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        title: "Gallery",
-        children: [
-          { $type: "Image", src: "https://x/1.png", alt: "One" },
-          { $type: "Image", src: "https://x/2.png", alt: "Two" },
-        ],
-      });
-      expect(blocks[0]).toMatchObject({ type: "header" });
-      expect(warnings).toContainEqual({
-        code: "fallback",
-        component: "Card",
-        detail:
-          "A card with content beyond hero_image, body, subtext, and actions was rendered inline.",
-      });
-    });
-
-    it("falls back inline when the converted card content overflows the surface block budget", () => {
-      const headers = Array.from({ length: MESSAGE_BLOCK_CAP + 1 }, (_, i) => ({
-        $type: "Header",
-        text: `H${i}`,
-      }));
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        title: "Big",
-        children: headers,
-      });
-      expect(blocks[0]).toEqual({
-        type: "header",
-        text: { type: "plain_text", text: "Big" },
-      });
-      expect(blocks).toHaveLength(MESSAGE_BLOCK_CAP);
-      expect(blocks[blocks.length - 1]).toMatchObject({ type: "context" });
-      expect(warnings).toContainEqual({
-        code: "fallback",
-        component: "Card",
-        detail:
-          "A card with content beyond hero_image, body, subtext, and actions was rendered inline.",
-      });
-      expect(
-        warnings.some((w) => w.code === "clamped" && w.component === "Root"),
-      ).toBe(true);
-    });
-
-    it(`clamps the title to ${CARD_TITLE_CAP} characters and warns`, () => {
-      const title = "c".repeat(200);
-      const { blocks, warnings } = toSlackBlocks({ $type: "Card", title });
-      expect(blocks).toEqual([
-        {
-          type: "card",
-          title: { type: "mrkdwn", text: "c".repeat(CARD_TITLE_CAP) },
-        },
-      ]);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Card",
-        detail: `title was clamped to ${CARD_TITLE_CAP} characters.`,
-      });
-    });
-
-    it(`clamps body to ${CARD_BODY_CAP} characters and warns`, () => {
-      const value = "b".repeat(CARD_BODY_CAP + 50);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        children: [{ $type: "Text", value }],
-      });
-      const card = blocks[0] as SlackCardBlock;
-      expect(card.body?.text).toHaveLength(CARD_BODY_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Card",
-        detail: `body was clamped to ${CARD_BODY_CAP} characters.`,
-      });
-    });
-
-    it(`clamps subtext to ${CARD_SUBTEXT_CAP} characters and warns`, () => {
-      const value = "s".repeat(CARD_SUBTEXT_CAP + 50);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Card",
-        title: "Order",
-        children: [{ $type: "Caption", value }],
-      });
-      const card = blocks[0] as SlackCardBlock;
-      expect(card.subtext?.text).toHaveLength(CARD_SUBTEXT_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Card",
-        detail: `subtext was clamped to ${CARD_SUBTEXT_CAP} characters.`,
-      });
-    });
-
-    it("drops a card with none of hero_image, title, body, or actions instead of emitting an invalid block", () => {
-      const { blocks, warnings } = toSlackBlocks({ $type: "Card" });
-      expect(blocks).toEqual([]);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Card",
-        detail:
-          "A card with none of hero_image, title, body, or actions was dropped.",
-      });
-    });
-  });
-
-  describe("Carousel", () => {
-    it("converts clean Card children into carousel elements", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "One",
-            children: [{ $type: "Text", value: "First" }],
-          },
-          {
-            $type: "Card",
-            title: "Two",
-            children: [{ $type: "Text", value: "Second" }],
-          },
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "carousel",
-          elements: [
-            {
-              type: "card",
-              title: { type: "mrkdwn", text: "One" },
-              body: { type: "mrkdwn", text: "First" },
-            },
-            {
-              type: "card",
-              title: { type: "mrkdwn", text: "Two" },
-              body: { type: "mrkdwn", text: "Second" },
-            },
-          ],
-        },
-      ]);
-      expect(warnings).toEqual([]);
-    });
-
-    it(`clamps to ${CAROUSEL_CARD_CAP} elements and warns`, () => {
-      const cards = Array.from({ length: CAROUSEL_CARD_CAP + 1 }, (_, i) => ({
-        $type: "Card",
-        title: `Card ${i}`,
-      }));
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: cards,
-      });
-      expect((blocks[0] as SlackCarouselBlock).elements).toHaveLength(
-        CAROUSEL_CARD_CAP,
-      );
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Carousel",
-        detail: `cards were clamped to ${CAROUSEL_CARD_CAP} entries.`,
-      });
-    });
-
-    it("drops non-card children with a warning, keeping valid cards", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          { $type: "Card", title: "Kept" },
-          { $type: "Text", value: "not a card" },
-        ],
-      });
-      expect((blocks[0] as SlackCarouselBlock).elements).toEqual([
-        { type: "card", title: { type: "mrkdwn", text: "Kept" } },
-      ]);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Carousel",
-        detail: "1 non-card child was dropped.",
-      });
-    });
-
-    it("degrades a child card that cannot map cleanly instead of falling back to a block sequence", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Order #1",
-            children: [
-              { $type: "Text", value: "Shipped" },
-              { $type: "Fact", label: "Carrier", value: "UPS" },
-            ],
-          },
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "carousel",
-          elements: [
-            {
-              type: "card",
-              title: { type: "mrkdwn", text: "Order #1" },
-              body: { type: "mrkdwn", text: "Shipped\nUPS\nCarrier" },
-            },
-          ],
-        },
-      ]);
-      expect(warnings).toContainEqual({
-        code: "fallback",
-        component: "Card",
-        detail: "A card inside a carousel was reshaped to title and body.",
-      });
-      expect(warnings.some((warning) => warning.code === "dropped")).toBe(
-        false,
-      );
-    });
-
-    it("does not report a Caption as lost, since its text reaches the body", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Plan",
-            children: [
-              { $type: "Text", value: "body" },
-              { $type: "Caption", value: "fine print" },
-              { $type: "Divider" },
-            ],
-          },
-        ],
-      });
-      const card = (blocks[0] as SlackCarouselBlock).elements[0];
-      expect(card?.body).toEqual({ type: "mrkdwn", text: "body\nfine print" });
-      expect(warnings.some((warning) => warning.code === "dropped")).toBe(
-        false,
-      );
-    });
-
-    it("reports the images and controls a reshaped card really loses", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Plan",
-            confirm: { label: "Buy", $action: { type: "buy" } },
-            children: [
-              { $type: "Image", src: "hero.png", alt: "hero" },
-              { $type: "Text", value: "body" },
-              { $type: "Caption", value: "fine print" },
-              { $type: "Divider" },
-            ],
-          },
-        ],
-      });
-      const card = (blocks[0] as SlackCarouselBlock).elements[0];
-      expect(card?.hero_image).toBeUndefined();
-      expect(card?.actions).toBeUndefined();
-      expect(card?.body).toEqual({ type: "mrkdwn", text: "body\nfine print" });
-      expect(warnings).toContainEqual({
-        code: "fallback",
-        component: "Card",
-        detail: "A card inside a carousel was reshaped to title and body.",
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Card",
-        detail: "A reshaped carousel card's images and controls were dropped.",
-      });
-    });
-
-    it.each([
-      ["tables", { $type: "Table", columns: [{ label: "A" }], rows: [["1"]] }],
-      ["charts", { $type: "Chart", series: [] }],
-      [
-        "images",
-        { $type: "ListViewItem", children: [{ $type: "Image", src: "x.png" }] },
-      ],
-      [
-        "controls",
-        {
-          $type: "ListViewItem",
-          children: [{ $type: "Button", label: "Go", $action: { type: "go" } }],
-        },
-      ],
-      ["controls", { $type: "Select", options: [{ label: "A", value: "a" }] }],
-      ["controls", { $type: "Input", name: "email", label: "Email" }],
-      [
-        "controls",
-        { $type: "Form", children: [{ $type: "Text", value: "inner" }] },
-      ],
-      [
-        "controls",
-        {
-          $type: "Card",
-          title: "nested",
-          confirm: { label: "Buy", $action: { type: "buy" } },
-        },
-      ],
-    ])(
-      "reports %s that a reshape cannot carry, however deep",
-      (kind, child) => {
-        const { warnings } = toSlackBlocks({
-          $type: "Carousel",
-          children: [
-            {
-              $type: "Card",
-              title: "Plan",
-              children: [
-                { $type: "Text", value: "b" },
-                child,
-                { $type: "Divider" },
-              ],
-            },
-          ],
-        });
-        expect(warnings).toContainEqual({
-          code: "dropped",
-          component: "Card",
-          detail: `A reshaped carousel card's ${kind} were dropped.`,
-        });
-      },
-    );
-
-    it("scans below a child whose text the reshape consumes", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Plan",
-            children: [
-              {
-                $type: "Text",
-                value: "body",
-                children: [{ $type: "Image", src: "x.png" }],
-              },
-              { $type: "Divider" },
-            ],
-          },
-        ],
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Card",
-        detail: "A reshaped carousel card's images were dropped.",
-      });
-    });
-
-    it("does not report a ListViewItem whose action renders no accessory", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Plan",
-            children: [
-              { $type: "Text", value: "body" },
-              { $type: "ListViewItem", title: "row", $action: "open" },
-              { $type: "Divider" },
-            ],
-          },
-        ],
-      });
-      expect(warnings.some((warning) => warning.code === "dropped")).toBe(
-        false,
-      );
-    });
-
-    it("does not report an action on a node that renders no control", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "Plan",
-            children: [
-              {
-                $type: "Box",
-                $action: { type: "open" },
-                children: [{ $type: "Text", value: "body" }],
-              },
-              { $type: "Divider" },
-            ],
-          },
-        ],
-      });
-      expect(warnings.some((warning) => warning.code === "dropped")).toBe(
-        false,
-      );
-    });
-
-    it("clamps a reshaped card's title and body instead of slicing them silently", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            title: "t".repeat(CARD_TITLE_CAP + 10),
-            children: [
-              { $type: "Text", value: "b".repeat(CARD_BODY_CAP + 10) },
-              { $type: "Fact", label: "L", value: "V" },
-            ],
-          },
-        ],
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Card",
-        detail: `title was clamped to ${CARD_TITLE_CAP} characters.`,
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Card",
-        detail: `body was clamped to ${CARD_BODY_CAP} characters.`,
-      });
-    });
-
-    it("uses the first text chunk as the title when a degraded card has no title of its own", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Carousel",
-        children: [
-          {
-            $type: "Card",
-            children: [
-              { $type: "Fact", label: "Carrier", value: "UPS" },
-              { $type: "Fact", label: "Status", value: "Delivered" },
-            ],
-          },
-        ],
-      });
-      const carousel = blocks[0] as SlackCarouselBlock;
-      expect(carousel.elements[0]).toEqual({
-        type: "card",
-        title: { type: "mrkdwn", text: "UPS" },
-        body: { type: "mrkdwn", text: "Carrier\nDelivered\nStatus" },
-      });
-    });
-
-    it("is dropped when it has no renderable cards", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [{ $type: "Text", value: "not a card" }],
-      });
-      expect(blocks).toEqual([]);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Carousel",
-        detail: "A carousel without renderable cards was dropped.",
-      });
-    });
-
-    it("drops a child card that degrades to empty, which then trips the zero-renderable-cards carousel drop", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Carousel",
-        children: [{ $type: "Card", children: [{ $type: "Divider" }] }],
-      });
-      expect(blocks).toEqual([]);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Card",
-        detail:
-          "A card with none of hero_image, title, body, or actions was dropped.",
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Carousel",
-        detail: "A carousel without renderable cards was dropped.",
-      });
-    });
-  });
-
-  describe("Col and Box", () => {
-    it("flatten children in order", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Col",
-        children: [
-          { $type: "Header", text: "Hi" },
-          { $type: "Text", value: "There" },
-        ],
-      });
-      expect(blocks).toEqual([
-        { type: "header", text: { type: "plain_text", text: "Hi" } },
-        { type: "section", text: { type: "mrkdwn", text: "There" } },
-      ]);
-    });
-
-    it("Box flattens the same way", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Box",
-        children: { $type: "Divider" },
-      });
-      expect(blocks).toEqual([{ type: "divider" }]);
-    });
-  });
-
-  describe("Row", () => {
-    it("flattens children in order when they are not all Badge/Caption", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Row",
-        children: [
-          { $type: "Header", text: "Hi" },
-          { $type: "Text", value: "There" },
-        ],
-      });
-      expect(blocks).toEqual([
-        { type: "header", text: { type: "plain_text", text: "Hi" } },
-        { type: "section", text: { type: "mrkdwn", text: "There" } },
-      ]);
-    });
-
-    it("merges an all-Badge/Caption row into one context block", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Row",
-        children: [
-          { $type: "Badge", value: "New" },
-          { $type: "Caption", value: "since today" },
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "context",
-          elements: [
-            { type: "mrkdwn", text: "New" },
-            { type: "mrkdwn", text: "since today" },
-          ],
-        },
-      ]);
-    });
-
-    it("does not merge into context when a non-Badge/Caption child is present", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Row",
-        children: [{ $type: "Badge", value: "New" }, "plain text"],
-      });
-      expect(blocks).toEqual([
-        { type: "context", elements: [{ type: "mrkdwn", text: "New" }] },
-        { type: "section", text: { type: "mrkdwn", text: "plain text" } },
-      ]);
-    });
-
-    it(`clamps a Badge/Caption row to ${CONTEXT_ELEMENT_CAP} elements and warns`, () => {
-      const badges = Array.from(
-        { length: CONTEXT_ELEMENT_CAP + 2 },
-        (_, i) => ({ $type: "Badge", value: `B${i}` }),
-      );
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Row",
-        children: badges,
-      });
-      expect((blocks[0] as SlackContextBlock).elements).toHaveLength(
-        CONTEXT_ELEMENT_CAP,
-      );
-      expect(warnings).toEqual([
-        {
-          code: "clamped",
-          component: "Row",
-          detail: `context elements were clamped to ${CONTEXT_ELEMENT_CAP} entries.`,
-        },
-      ]);
-    });
-  });
-
-  describe("context text cap", () => {
-    it(`clamps Caption, standalone Badge, and Row-merged badge/caption text to ${CONTEXT_TEXT_CAP} characters, warning on each`, () => {
-      const long = "c".repeat(CONTEXT_TEXT_CAP + 50);
-
-      const caption = toSlackBlocks({ $type: "Caption", value: long });
-      expect(
-        (caption.blocks[0] as SlackContextBlock).elements[0]?.text,
-      ).toHaveLength(CONTEXT_TEXT_CAP);
-      expect(caption.warnings).toContainEqual({
-        code: "clamped",
-        component: "Caption",
-        detail: `value was clamped to ${CONTEXT_TEXT_CAP} characters.`,
-      });
-
-      const badge = toSlackBlocks({ $type: "Badge", value: long });
-      expect(
-        (badge.blocks[0] as SlackContextBlock).elements[0]?.text,
-      ).toHaveLength(CONTEXT_TEXT_CAP);
-      expect(badge.warnings).toContainEqual({
-        code: "clamped",
-        component: "Badge",
-        detail: `value was clamped to ${CONTEXT_TEXT_CAP} characters.`,
-      });
-
-      const row = toSlackBlocks({
-        $type: "Row",
-        children: [
-          { $type: "Badge", value: long },
-          { $type: "Caption", value: "short" },
-        ],
-      });
-      expect(
-        (row.blocks[0] as SlackContextBlock).elements[0]?.text,
-      ).toHaveLength(CONTEXT_TEXT_CAP);
-      expect(row.warnings).toContainEqual({
-        code: "clamped",
-        component: "Badge",
-        detail: `value was clamped to ${CONTEXT_TEXT_CAP} characters.`,
-      });
-    });
-  });
-
-  describe("Spacer and Icon", () => {
-    it("are dropped silently", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Col",
-        children: [
-          { $type: "Spacer" },
-          { $type: "Icon", name: "star" },
-          { $type: "Text", value: "kept" },
-        ],
-      });
-      expect(blocks).toEqual([
-        { type: "section", text: { type: "mrkdwn", text: "kept" } },
-      ]);
-      expect(warnings).toEqual([]);
-    });
-  });
-
-  describe("Table", () => {
-    it.each([["A"], [{}], [{ label: 42 }]])(
-      "keeps an unlabeled column's position in the header and reports it: %j",
-      (column) => {
-        const { blocks, warnings } = toSlackBlocks({
-          $type: "Table",
-          columns: [column, { label: "B" }],
-          rows: [["1", "2"]],
-        });
-        const table = blocks[0] as SlackDataTableBlock;
-        expect(table.rows[0]).toEqual([
-          { type: "raw_text", text: "" },
-          { type: "raw_text", text: "B" },
-        ]);
-        expect(warnings).toContainEqual({
-          code: "dropped",
-          component: "Table",
-          detail: "1 column header was left blank for want of a string label.",
-        });
-      },
-    );
-
-    it("converts columns and rows into a header-first rows array with typed cells", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "Name" }, { label: "Age" }],
-        rows: [
-          ["Ada", 36],
-          ["Bob", 24],
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "data_table",
-          caption: TABLE_CAPTION,
-          rows: [
-            [
-              { type: "raw_text", text: "Name" },
-              { type: "raw_text", text: "Age" },
-            ],
-            [
-              { type: "raw_text", text: "Ada" },
-              { type: "raw_number", text: "36" },
-            ],
-            [
-              { type: "raw_text", text: "Bob" },
-              { type: "raw_number", text: "24" },
-            ],
-          ],
-        },
-      ]);
-    });
-
-    it("formats table cells from their columns", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        columns: [
-          { label: "Number", format: { kind: "number", decimals: 1 } },
-          {
-            label: "Revenue",
-            format: { kind: "currency", currency: "USD", decimals: 2 },
-          },
-          { label: "Share", format: { kind: "percent", decimals: 0 } },
-          { label: "Date", format: { kind: "date" } },
-        ],
-        rows: [[1234.5, 12.4, 0.08, "2024-01-02"]],
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows[1]?.map((cell) => cell.text)).toEqual([
-        "1,234.5",
-        "$12.40",
-        "8%",
-        "Jan 2, 2024",
-      ]);
-    });
-
-    it("requires a caption on every emitted table", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "Name" }],
-        rows: [["Ada"]],
-      });
-      expect((blocks[0] as SlackDataTableBlock).caption).toBe(TABLE_CAPTION);
-    });
-
-    it(`clamps data rows to ${DATA_TABLE_ROW_CAP} (plus the header row) and columns to ${DATA_TABLE_COLUMN_CAP}, warning on each`, () => {
-      const columnCount = DATA_TABLE_COLUMN_CAP + 3;
-      const columns = Array.from({ length: columnCount }, () => ({
-        label: "C",
-      }));
-      const rows = Array.from({ length: DATA_TABLE_ROW_CAP + 5 }, () =>
-        Array.from({ length: columnCount }, () => "x"),
-      );
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Table",
-        columns,
-        rows,
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows).toHaveLength(DATA_TABLE_ROW_CAP + 1);
-      expect(table.rows[0]).toHaveLength(DATA_TABLE_COLUMN_CAP);
-      expect(table.rows[1]).toHaveLength(DATA_TABLE_COLUMN_CAP);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Table",
-        detail: `columns were clamped to ${DATA_TABLE_COLUMN_CAP} entries.`,
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Table",
-        detail: `rows were clamped to ${DATA_TABLE_ROW_CAP} entries.`,
-      });
-      expect(warnings.some((w) => w.detail.includes("table budget"))).toBe(
-        false,
-      );
-    });
-
-    it("does not dispatch columns, rows, or row arrays through Symbol.species", () => {
-      const dispatches = { columns: 0, rows: 0, row: 0 };
-      const row = hostileSpecies(
-        ["kept"],
-        ["injected", "also-injected"],
-        () => {
-          dispatches.row += 1;
-        },
-      );
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        columns: hostileSpecies(
-          [{ label: "Kept" }],
-          [{ label: "Injected" }, { label: "Also injected" }],
-          () => {
-            dispatches.columns += 1;
-          },
-        ),
-        rows: hostileSpecies([row], [row, row], () => {
-          dispatches.rows += 1;
-        }),
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows).toHaveLength(2);
-      expect(table.rows[0]).toEqual([{ type: "raw_text", text: "Kept" }]);
-      expect(table.rows[1]).toEqual([{ type: "raw_text", text: "kept" }]);
-      expect(dispatches).toEqual({ columns: 0, rows: 0, row: 0 });
-    });
-
-    it(`clamps rows to fit the ${DATA_TABLE_CHAR_BUDGET}-character table budget, always keeping the header row`, () => {
-      const bigCell = "z".repeat(Math.ceil(DATA_TABLE_CHAR_BUDGET / 5));
-      const rows = Array.from({ length: 6 }, (_, r) => [`row${r}`, bigCell]);
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "Id" }, { label: "Blob" }],
-        rows,
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows.length).toBeLessThan(rows.length + 1);
-      expect(table.rows[0]).toEqual([
-        { type: "raw_text", text: "Id" },
-        { type: "raw_text", text: "Blob" },
-      ]);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Table",
-        detail: `rows were clamped to fit the ${DATA_TABLE_CHAR_BUDGET}-character table budget.`,
-      });
-    });
-
-    it("shares the character budget across multiple data-table blocks in one payload", () => {
-      const secondValue = "second";
-      const filler = "f".repeat(DATA_TABLE_CHAR_BUDGET - secondValue.length);
-      const { blocks, warnings } = toSlackBlocks([
-        { $type: "Table", columns: [{ label: "A" }], rows: [[filler]] },
-        { $type: "Table", columns: [{ label: "B" }], rows: [[secondValue]] },
-      ]);
-      const first = blocks[0] as SlackDataTableBlock;
-      const second = blocks[1] as SlackDataTableBlock;
-      expect(first.rows).toEqual([
-        [{ type: "raw_text", text: "A" }],
-        [{ type: "raw_text", text: filler }],
-      ]);
-      expect(second.rows).toEqual([[{ type: "raw_text", text: "B" }]]);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Table",
-        detail: `rows were clamped to fit the ${DATA_TABLE_CHAR_BUDGET}-character table budget.`,
-      });
-    });
-
-    it("synthesizes an empty-cell header row matching the data width when rows are given without columns", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        rows: [
-          ["Ada", 36],
-          ["Bob", 24],
-        ],
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows[0]).toEqual([
-        { type: "raw_text", text: "" },
-        { type: "raw_text", text: "" },
-      ]);
-      expect(table.rows).toEqual([
-        table.rows[0],
-        [
-          { type: "raw_text", text: "Ada" },
-          { type: "raw_number", text: "36" },
-        ],
-        [
-          { type: "raw_text", text: "Bob" },
-          { type: "raw_number", text: "24" },
-        ],
-      ]);
-    });
-
-    it(`counts the header row's own cell text toward the ${DATA_TABLE_CHAR_BUDGET}-character budget`, () => {
-      const bigHeader = "H".repeat(DATA_TABLE_CHAR_BUDGET - 1);
-      const rows = Array.from({ length: 50 }, () => ["y"]);
-      const { blocks } = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: bigHeader }],
-        rows,
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows).toHaveLength(2);
-    });
-
-    it("emits Slack's documented ceiling of 200 data rows unclamped", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "n" }],
-        rows: Array.from({ length: 200 }, (_, r) => [String(r)]),
-      });
-      const table = blocks[0] as SlackDataTableBlock;
-      expect(table.rows).toHaveLength(201);
-      expect(warnings).toEqual([]);
-    });
-
-    it("emits Slack's documented ceiling of 20,000 characters and clamps at 20,001", () => {
-      const atBudget = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "h" }],
-        rows: [["c".repeat(19999)]],
-      });
-      expect((atBudget.blocks[0] as SlackDataTableBlock).rows).toHaveLength(2);
-      expect(atBudget.warnings).toEqual([]);
-
-      const overBudget = toSlackBlocks({
-        $type: "Table",
-        columns: [{ label: "h" }],
-        rows: [["c".repeat(20000)]],
-      });
-      expect((overBudget.blocks[0] as SlackDataTableBlock).rows).toHaveLength(
-        1,
-      );
-      expect(overBudget.warnings).toContainEqual({
-        code: "clamped",
-        component: "Table",
-        detail: "rows were clamped to fit the 20000-character table budget.",
-      });
-    });
-  });
-
-  describe("Markdown", () => {
-    it("converts to a markdown block", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Markdown",
-        value: "# Title",
-      });
-      expect(blocks).toEqual([{ type: "markdown", text: "# Title" }]);
-      expect(warnings).toEqual([]);
-    });
-
-    it(`falls back to a section once the cumulative ${MARKDOWN_TEXT_BUDGET}-character budget is exceeded`, () => {
-      const first = "a".repeat(MARKDOWN_TEXT_BUDGET - 1000);
-      const second = "b".repeat(2000);
-      const third = "c".repeat(10);
-      const { blocks, warnings } = toSlackBlocks([
-        { $type: "Markdown", value: first },
-        { $type: "Markdown", value: second },
-        { $type: "Markdown", value: third },
-      ]);
-      expect(blocks[0]).toEqual({ type: "markdown", text: first });
-      expect(blocks[1]).toEqual({
-        type: "section",
-        text: { type: "mrkdwn", text: second },
-      });
-      expect(blocks[2]).toEqual({
-        type: "section",
-        text: { type: "mrkdwn", text: third },
-      });
-      expect(warnings.filter((w) => w.component === "Markdown")).toHaveLength(
-        2,
-      );
-      expect(warnings).toContainEqual({
-        code: "fallback",
-        component: "Markdown",
-        detail: `The ${MARKDOWN_TEXT_BUDGET}-character markdown budget was exceeded.`,
-      });
-    });
-  });
-
-  describe("Chart", () => {
-    it("is dropped and replaced by an omission note", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Chart",
-        variant: "bar",
-        data: [{ value: 1 }],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "context",
-          elements: [{ type: "mrkdwn", text: "Chart omitted on Slack." }],
-        },
-      ]);
-      expect(warnings).toEqual([
-        {
-          code: "dropped",
-          component: "Chart",
-          detail: "Chart was replaced by a Slack omission note.",
-        },
-      ]);
-    });
-  });
-
-  describe("ListView and ListViewItem", () => {
-    it("forwards a discarded child's own dropped warning and counts it", () => {
-      const { warnings } = toSlackBlocks({
-        $type: "ListView",
-        children: [
-          { $type: "Mystery" },
-          { $type: "ListViewItem", children: { $type: "Text", value: "row" } },
-        ],
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "Mystery",
-        detail: "Unknown component type was dropped.",
-      });
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "ListView",
-        detail: "1 non-item child was dropped.",
-      });
-    });
-
-    it("does not let a discarded child spend the markdown budget", () => {
-      const { blocks, warnings } = toSlackBlocks([
-        {
-          $type: "ListView",
-          children: [
-            { $type: "Markdown", value: "x".repeat(MARKDOWN_TEXT_BUDGET) },
-            {
-              $type: "ListViewItem",
-              children: { $type: "Text", value: "row" },
-            },
-          ],
-        },
-        { $type: "Markdown", value: "**real**" },
-      ]);
-      expect(blocks[blocks.length - 1]).toEqual({
-        type: "markdown",
-        text: "**real**",
-      });
-      expect(warnings.some((warning) => warning.component === "Markdown")).toBe(
-        false,
-      );
-    });
-
-    it("reports a non-item child it filters out", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "ListView",
-        children: [
-          { $type: "Text", value: "stray" },
-          { $type: "ListViewItem", children: { $type: "Text", value: "Kept" } },
-        ],
-      });
-      expect(blocks).toHaveLength(1);
-      expect(warnings).toContainEqual({
-        code: "dropped",
-        component: "ListView",
-        detail: "1 non-item child was dropped.",
-      });
-    });
-
-    it("renders each item as a section, separated by dividers", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "ListView",
-        children: [
-          {
-            $type: "ListViewItem",
-            children: { $type: "Text", value: "Row 1" },
-          },
-          {
-            $type: "ListViewItem",
-            children: { $type: "Text", value: "Row 2" },
-          },
-        ],
-      });
-      expect(blocks).toEqual([
-        { type: "section", text: { type: "mrkdwn", text: "Row 1" } },
-        { type: "divider" },
-        { type: "section", text: { type: "mrkdwn", text: "Row 2" } },
-      ]);
-    });
-
-    it("turns an item's $action into a button accessory", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "ListView",
-        children: [
-          {
-            $type: "ListViewItem",
-            $action: { type: "open_row" },
-            children: { $type: "Text", value: "Clickable" },
-          },
-        ],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "section",
-          text: { type: "mrkdwn", text: "Clickable" },
-          accessory: {
-            type: "button",
-            text: { type: "plain_text", text: "Open" },
-            action_id: "open_row",
-          },
-        },
-      ]);
-    });
-  });
-
-  describe("Form", () => {
-    it("converts children normally and appends a submit actions block", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Form",
-        $action: { type: "submit_signup" },
-        children: [{ $type: "Input", label: "Name", name: "name" }],
-      });
-      expect(blocks).toEqual([
-        {
-          type: "input",
-          block_id: `aui:0:${JSON.stringify([["action", "name"]])}`,
-          label: { type: "plain_text", text: "Name" },
-          element: { type: "plain_text_input", action_id: "action" },
-        },
-        {
-          type: "actions",
-          elements: [
-            {
-              type: "button",
-              text: { type: "plain_text", text: "Submit" },
-              action_id: "submit_signup",
-              style: "primary",
-            },
-          ],
-        },
-      ]);
-    });
-
-    it("maps named controls per element when they share an actions block", () => {
-      const { blocks, warnings } = toSlackBlocks([
-        {
-          $type: "Select",
-          name: "plan",
-          options: [{ label: "Pro", value: "pro" }],
-          $action: { type: "choose_plan" },
-        },
-        {
-          $type: "CheckboxGroup",
-          name: "tags",
-          options: [{ label: "News", value: "news" }],
-          $action: { type: "choose_tags" },
-        },
-        {
-          $type: "Button",
-          label: "Save",
-          $action: {
-            type: "save",
-            plan: { $field: "plan" },
-            tags: { $field: "tags" },
-          },
-        },
-      ]);
-      expect(blocks[0]).toMatchObject({
-        type: "actions",
-        block_id: `aui:0:${JSON.stringify([
-          ["choose_plan", "plan"],
-          ["choose_tags", "tags"],
-        ])}`,
-      });
-      expect(warnings).toEqual([]);
-      const block = blocks[0];
-      if (block?.type !== "actions" || !block.block_id) {
-        throw new Error("Expected a named actions block");
-      }
-      const button = block.elements.find(
-        (element) => element.type === "button",
-      );
-      if (!button) throw new Error("Expected a button");
-      for (const [selectedOptions, tags] of [
-        [[], []],
-        [[{ value: "news" }], ["news"]],
-      ] as const) {
-        expect(
-          decodeBlockAction({
-            type: "checkboxes",
-            block_id: block.block_id,
-            action_id: "choose_tags",
-            selected_options: selectedOptions,
-          }),
-        ).toEqual({ type: "choose_tags", $input: tags });
-        expect(
-          decodeBlockAction(button, {
-            [block.block_id]: {
-              choose_tags: {
-                type: "checkboxes",
-                selected_options: selectedOptions,
-              },
-            },
-          }),
-        ).toEqual({ type: "save", tags });
-      }
-    });
-
-    it("starts a new actions block when repeated action ids need distinct field mappings", () => {
-      const { blocks } = toSlackBlocks([
-        {
-          $type: "Select",
-          name: "first",
-          options: [{ label: "One", value: "one" }],
-          $action: { type: "choose" },
-        },
-        {
-          $type: "Select",
-          name: "second",
-          options: [{ label: "Two", value: "two" }],
-          $action: { type: "choose" },
-        },
-      ]);
-      expect(blocks).toHaveLength(2);
-      expect(blocks[0]).toMatchObject({
-        type: "actions",
-        block_id: `aui:0:${JSON.stringify([["choose", "first"]])}`,
-      });
-      expect(blocks[1]).toMatchObject({
-        type: "actions",
-        block_id: `aui:1:${JSON.stringify([["choose", "second"]])}`,
-      });
-    });
-
-    it("keeps unnamed controls with repeated action ids in their existing block", () => {
-      const { blocks } = toSlackBlocks([
-        {
-          $type: "Button",
-          label: "First",
-          $action: { type: "choose" },
-        },
-        {
-          $type: "Button",
-          label: "Second",
-          $action: { type: "choose" },
-        },
-      ]);
-      expect(blocks).toHaveLength(1);
-      expect(blocks[0]).not.toHaveProperty("block_id");
-      expect((blocks[0] as SlackActionsBlock).elements).toHaveLength(2);
-    });
-
-    it("splits grouped fields when their mapping would exceed Slack's block_id limit", () => {
-      const { blocks, warnings } = toSlackBlocks([
-        {
-          $type: "Select",
-          name: "a".repeat(120),
-          options: [{ label: "A", value: "a" }],
-          $action: { type: "choose_a" },
-        },
-        {
-          $type: "Select",
-          name: "b".repeat(120),
-          options: [{ label: "B", value: "b" }],
-          $action: { type: "choose_b" },
-        },
-      ]);
-      expect(blocks).toHaveLength(2);
-      expect(blocks[0]).toHaveProperty("block_id");
-      expect(blocks[1]).toHaveProperty("block_id");
-      expect(warnings).toEqual([]);
-    });
-  });
-
-  describe("Root", () => {
-    it("converts a root array of mixed components sequentially", () => {
-      const { blocks } = toSlackBlocks([
-        { $type: "Header", text: "Title" },
-        { $type: "Divider" },
-        { $type: "Text", value: "Body" },
-      ]);
-      expect(blocks).toEqual([
-        { type: "header", text: { type: "plain_text", text: "Title" } },
-        { type: "divider" },
-        { type: "section", text: { type: "mrkdwn", text: "Body" } },
-      ]);
-    });
-
-    it("clamps to the surface cap and appends an omission note", () => {
-      const count = MESSAGE_BLOCK_CAP + 5;
-      const nodes = Array.from({ length: count }, (_, i) => ({
-        $type: "Header",
-        text: `H${i}`,
-      }));
-      const { blocks, warnings } = toSlackBlocks(nodes);
-      expect(blocks).toHaveLength(MESSAGE_BLOCK_CAP);
-      const omitted = count - (MESSAGE_BLOCK_CAP - 1);
-      expect(blocks[blocks.length - 1]).toEqual({
-        type: "context",
-        elements: [{ type: "mrkdwn", text: `${omitted} blocks were omitted.` }],
-      });
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Root",
-        detail: `${omitted} blocks were omitted.`,
-      });
-    });
-
-    it("uses a 100-block cap for the modal surface", () => {
-      const count = MODAL_BLOCK_CAP + 3;
-      const nodes = Array.from({ length: count }, (_, i) => ({
-        $type: "Header",
-        text: `H${i}`,
-      }));
-      const { blocks } = toSlackBlocks(nodes, { surface: "modal" });
-      expect(blocks).toHaveLength(MODAL_BLOCK_CAP);
-    });
-
-    it("does not clamp when under budget", () => {
-      const { blocks, warnings } = toSlackBlocks([
-        { $type: "Header", text: "One" },
-      ]);
-      expect(blocks).toHaveLength(1);
-      expect(warnings).toEqual([]);
-    });
-  });
-
-  describe("bare children", () => {
-    it("strings and numbers inside a flattened container become section mrkdwn blocks", () => {
-      const { blocks } = toSlackBlocks({
-        $type: "Col",
-        children: ["hello", 42],
-      });
-      expect(blocks).toEqual([
-        { type: "section", text: { type: "mrkdwn", text: "hello" } },
-        { type: "section", text: { type: "mrkdwn", text: "42" } },
-      ]);
-    });
-  });
-
-  describe("unknown component types", () => {
-    it("are skipped with a dropped warning", () => {
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "TotallyMadeUp",
-        foo: "bar",
-      });
-      expect(blocks).toEqual([]);
-      expect(warnings).toEqual([
-        {
-          code: "dropped",
-          component: "TotallyMadeUp",
-          detail: "Unknown component type was dropped.",
-        },
-      ]);
-    });
-  });
-
-  describe("depth bound", () => {
-    it("does not throw on 65 levels of nesting", () => {
-      let node: unknown = { $type: "Text", value: "deep" };
-      for (let i = 0; i < 65; i++) {
-        node = { $type: "Col", children: node };
-      }
-      expect(() => toSlackBlocks(node)).not.toThrow();
-      const { blocks } = toSlackBlocks(node);
-      expect(Array.isArray(blocks)).toBe(true);
-    });
-  });
-
-  describe("never throws", () => {
-    it("returns a well-formed result instead of throwing for degenerate input", () => {
-      const degenerateInputs: unknown[] = [
-        null,
-        undefined,
-        42,
-        "just text",
-        true,
-        false,
-        [],
-        {},
-        () => {},
-        Symbol("x"),
-      ];
-      for (const input of degenerateInputs) {
-        const result = toSlackBlocks(input);
-        expect(Array.isArray(result.blocks)).toBe(true);
-        expect(Array.isArray(result.warnings)).toBe(true);
-      }
-    });
-
-    it("bounds a hostile root-level Proxy array with a fabricated length instead of hanging", () => {
-      const hostileRoot = new Proxy([], {
-        get(target, prop) {
-          if (prop === "length") return 2 ** 31;
-          if (typeof prop === "string" && /^\d+$/.test(prop)) {
-            return { $type: "Text", value: "x" };
-          }
-          return Reflect.get(target, prop);
-        },
-        has(target, prop) {
-          if (prop === "length") return true;
-          if (typeof prop === "string" && /^\d+$/.test(prop)) return true;
-          return Reflect.has(target, prop);
-        },
-      });
-      const { blocks, warnings } = toSlackBlocks(hostileRoot);
-      expect(Array.isArray(blocks)).toBe(true);
-      expect(warnings).toContainEqual(
-        expect.objectContaining({ code: "clamped", component: "Root" }),
-      );
-    });
-
-    it("omits the button value instead of throwing when the action payload is circular", () => {
-      const circular: Record<string, unknown> = { type: "loop" };
-      circular["self"] = circular;
-      expect(() =>
-        toSlackBlocks({ $type: "Button", label: "Go", $action: circular }),
-      ).not.toThrow();
-      const { blocks, warnings } = toSlackBlocks({
-        $type: "Button",
-        label: "Go",
-        $action: circular,
-      });
-      expect(warnings).toEqual([
-        {
-          code: "dropped",
-          component: "Button",
-          detail:
-            "value was dropped because the action payload could not be serialized.",
-        },
-      ]);
-      expect(blocks[0]).toEqual({
-        type: "actions",
-        elements: [
-          {
-            type: "button",
-            text: { type: "plain_text", text: "Go" },
-            action_id: "loop",
-          },
-        ],
-      });
-    });
-  });
-
-  describe("node budget and cycle guard", () => {
-    it("bounds a self-referential children array instead of looping forever", () => {
-      const arr: unknown[] = [];
-      const el = { $type: "Card", children: arr };
-      arr.push(el);
-      const { warnings } = toSlackBlocks(el);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Root",
-        detail: "a self-referencing node was dropped.",
-      });
-    });
-
-    it("bounds a shared-reference fan-out across nested levels with a budget warning instead of doing exponential work", () => {
-      let shared: unknown = { $type: "Text", value: "leaf" };
-      for (let level = 0; level < 3; level++) {
-        shared = {
-          $type: "Card",
-          children: Array.from({ length: 200 }, () => shared),
-        };
-      }
-      const { warnings } = toSlackBlocks(shared);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Root",
-        detail: `the tree was truncated after ${NODE_BUDGET} nodes.`,
-      });
-    });
-
-    it("clamps a benign tree past the node budget with exactly one budget warning", () => {
-      const rows = Array.from({ length: 60 }, (_, r) => ({
-        $type: "Col",
-        children: Array.from({ length: 100 }, (_, c) => ({
-          $type: "Caption",
-          value: `r${r}c${c}`,
-        })),
-      }));
-      const { blocks, warnings } = toSlackBlocks(rows);
-      expect(blocks.length).toBeLessThan(6000);
-      const budgetWarnings = warnings.filter(
-        (warning) =>
-          warning.code === "clamped" &&
-          warning.component === "Root" &&
-          warning.detail ===
-            `the tree was truncated after ${NODE_BUDGET} nodes.`,
-      );
-      expect(budgetWarnings).toHaveLength(1);
-    });
-
-    it("clamps a shared-reference array past the children cap without treating the reuse as a cycle", () => {
-      const card = { $type: "Card", title: "shared" };
-      let node: unknown = Array.from({ length: 201 }, () => card);
-      for (let level = 0; level < 3; level++) {
-        node = { $type: "Col", children: node };
-      }
-      const { warnings } = toSlackBlocks(node);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Root",
-        detail: `children were clamped to ${CHILDREN_CAP} entries.`,
-      });
-      expect(
-        warnings.some((warning) => warning.detail.includes("self-referencing")),
-      ).toBe(false);
-    });
-
-    it("converts a 70-level-deep chain successfully and reports the depth detail", () => {
-      let node: unknown = { $type: "Caption", value: "x" };
-      for (let i = 0; i < 70; i++) {
-        node = { $type: "Card", children: [node] };
-      }
-      expect(() => toSlackBlocks(node)).not.toThrow();
-      const { warnings } = toSlackBlocks(node);
-      expect(warnings).toContainEqual({
-        code: "clamped",
-        component: "Root",
-        detail: "nodes deeper than 32 levels were dropped.",
-      });
-    });
-
-    it("reports the depth detail at the level it actually starts dropping", () => {
-      const chain = (levels: number) => {
-        let node: unknown = { $type: "Caption", value: "x" };
-        for (let i = 0; i < levels; i++) {
-          node = { $type: "Card", children: [node] };
-        }
-        return node;
-      };
-      const dropped = (node: unknown) =>
-        toSlackBlocks(node).warnings.some((warning) =>
-          warning.detail.includes("deeper than"),
-        );
-      expect(dropped(chain(32))).toBe(false);
-      expect(dropped(chain(33))).toBe(true);
-      expect(dropped([chain(31)])).toBe(false);
-      expect(dropped([chain(32)])).toBe(true);
-    });
-  });
-});
-
-describe("toSlackBlocks data_table integrity", () => {
-  it("preserves cell positions when a value is unsupported", () => {
-    const { blocks } = toSlackBlocks({
-      $type: "Table",
-      columns: [{ label: "A" }, { label: "B" }],
-      rows: [[{ nested: true }, "kept"]],
-    });
-    const table = blocks[0];
-    if (table?.type !== "data_table") {
-      throw new Error("Expected a data table block.");
-    }
-    expect(table.rows[1]).toEqual([
-      { type: "raw_text", text: "" },
-      { type: "raw_text", text: "kept" },
-    ]);
-  });
-
-  it("pads ragged rows to a uniform width", () => {
-    const { blocks } = toSlackBlocks({
-      $type: "Table",
-      columns: [{ label: "A" }, { label: "B" }, { label: "C" }],
-      rows: [["x"], ["x", "y", "z"]],
-    });
-    const table = blocks[0];
-    if (table?.type !== "data_table") {
-      throw new Error("Expected a data table block.");
-    }
-    expect(new Set(table.rows.map((row) => row.length))).toEqual(new Set([3]));
-  });
-
-  it("drops a table whose header row alone exceeds the character budget", () => {
-    const { blocks, warnings } = toSlackBlocks({
-      $type: "Table",
-      columns: [{ label: "h".repeat(DATA_TABLE_CHAR_BUDGET + 1) }],
-      rows: [["x"]],
-    });
-    expect(blocks).toEqual([]);
-    expect(
-      warnings.some(
-        (warning) =>
-          warning.component === "Table" && warning.code === "dropped",
-      ),
-    ).toBe(true);
-  });
-});
-
-it("resolves a Slider field reference from numeric Slack state", () => {
-  const { blocks } = toSlackBlocks([
-    {
-      $type: "Slider",
-      name: "count",
-      label: "Count",
-      min: 0,
-      max: 10,
-      $action: { type: "change_count" },
-    },
-    {
-      $type: "Button",
-      label: "Submit",
-      $action: { type: "submit", count: { $field: "count" } },
-    },
-  ]);
-  const slider = blocks.find((block) => block.type === "input");
-  const actions = blocks.find((block) => block.type === "actions");
-  if (
-    !slider ||
-    slider.type !== "input" ||
-    !slider.block_id ||
-    !actions ||
-    actions.type !== "actions"
-  )
-    throw new Error("Expected slider and action blocks");
-  const button = actions.elements[0];
-  if (!button || button.type !== "button")
-    throw new Error("Expected submit button");
-  expect(
-    decodeBlockAction(button, {
-      [slider.block_id]: {
-        change_count: { type: "number_input", value: "3" },
-      },
-    }),
-  ).toEqual({ type: "submit", count: 3 });
-});