diff --git a/mcp-server/README.md b/mcp-server/README.md
index 2fa4f5c..30d131a 100644
--- a/mcp-server/README.md
+++ b/mcp-server/README.md
@@ -138,3 +138,39 @@ npm start
 # With a pre-loaded flow file
 npm start -- --file path/to/flow.drawd
 ```
+
+### Validation
+
+#### `validate_html`
+
+Validate HTML/CSS against Satori rendering constraints **without rasterizing**. Returns a structured list of warnings in milliseconds — use before `create_screen` / `update_screen_image` to catch layout bugs before the slow render step.
+
+**Input:**
+
+| Parameter | Type   | Required | Description                                    |
+|-----------|--------|----------|------------------------------------------------|
+| `html`    | string | yes      | The HTML string to validate against Satori constraints |
+
+**Output:**
+
+```json
+{
+  "warnings": [
+    { "path": "div[0] > span[0]", "rule": "text-needs-nowrap", "message": "Text leaf missing white-space: nowrap" },
+    { "path": "div[0]", "rule": "multi-child-needs-flex", "message": "3 children but no display: flex" }
+  ]
+}
+```
+
+Empty `warnings: []` means the HTML passes all checks.
+
+**Rules checked:**
+
+| Rule ID                    | Description                                         |
+|----------------------------|-----------------------------------------------------|
+| `unsupported-position`     | `position: absolute` and `position: fixed` are not supported |
+| `no-style-block`           | `<style>` blocks are not supported; use inline styles |
+| `multi-child-needs-flex`   | Elements with 2+ children must have `display: flex` |
+| `no-br-tag`                | `<br/>` is not supported; use margin/padding        |
+| `text-needs-nowrap`        | Text leaves need `white-space: nowrap` to prevent unexpected wrapping |
+| `unsupported-css-property` | CSS property is outside Satori's supported allowlist |
diff --git a/mcp-server/src/server.js b/mcp-server/src/server.js
index d762dac..f3d3849 100644
--- a/mcp-server/src/server.js
+++ b/mcp-server/src/server.js
@@ -15,6 +15,7 @@ import { commentTools, handleCommentTool } from "./tools/comment-tools.js";
 import { generationTools, handleGenerationTool } from "./tools/generation-tools.js";
 import { selectionTools, handleSelectionTool } from "./tools/selection-tools.js";
 import { assetTools, handleAssetTool } from "./tools/asset-tools.js";
+import { validationTools, handleValidationTool } from "./tools/validation-tools.js";
 import { composeTools, handleComposeTool } from "./tools/compose-tools.js";
 import { layoutTools, handleLayoutTool } from "./tools/layout-tools.js";
 import { designTokenTools, handleDesignTokenTool } from "./tools/design-token-tools.js";
@@ -30,6 +31,7 @@ const COMMENT_TOOL_NAMES = new Set(commentTools.map((t) => t.name));
 const GENERATION_TOOL_NAMES = new Set(generationTools.map((t) => t.name));
 const SELECTION_TOOL_NAMES = new Set(selectionTools.map((t) => t.name));
 const ASSET_TOOL_NAMES = new Set(assetTools.map((t) => t.name));
+const VALIDATION_TOOL_NAMES = new Set(validationTools.map((t) => t.name));
 const COMPOSE_TOOL_NAMES = new Set(composeTools.map((t) => t.name));
 const LAYOUT_TOOL_NAMES = new Set(layoutTools.map((t) => t.name));
 const DESIGN_TOKEN_TOOL_NAMES = new Set(designTokenTools.map((t) => t.name));
@@ -70,6 +72,8 @@ const ALL_TOOLS = [
   ...withFilePath(designTokenTools),
   // Asset tools (icons, stock photos) are stateless — no flow context required.
   ...assetTools,
+  // Validation tools are stateless — no flow context required.
+  ...validationTools,
   // Compose tools return HTML fragments — stateless, no flow context required.
   ...composeTools,
 ];
@@ -120,6 +124,8 @@ export function createServer(state, renderer, bridge) {
         result = handleDesignTokenTool(name, args, state);
       } else if (ASSET_TOOL_NAMES.has(name)) {
         result = await handleAssetTool(name, args, state);
+      } else if (VALIDATION_TOOL_NAMES.has(name)) {
+        result = handleValidationTool(name, args);
       } else if (COMPOSE_TOOL_NAMES.has(name)) {
         result = handleComposeTool(name, args);
       } else if (LAYOUT_TOOL_NAMES.has(name)) {
diff --git a/mcp-server/src/tools/__tests__/validation-tools.test.js b/mcp-server/src/tools/__tests__/validation-tools.test.js
new file mode 100644
index 0000000..d33c1cb
--- /dev/null
+++ b/mcp-server/src/tools/__tests__/validation-tools.test.js
@@ -0,0 +1,274 @@
+// @vitest-environment node
+
+import { describe, it, expect } from "vitest";
+import {
+  validationTools,
+  handleValidationTool,
+  _internal,
+} from "../validation-tools.js";
+
+const { validateHtml, SATORI_ALLOWED_PROPERTIES } = _internal;
+
+describe("validationTools tool definitions", () => {
+  it("declares 1 tool (validate_html)", () => {
+    const names = validationTools.map((t) => t.name);
+    expect(names).toEqual(["validate_html"]);
+  });
+
+  it("tool has description and input schema", () => {
+    const tool = validationTools[0];
+    expect(tool.description.length).toBeGreaterThan(20);
+    expect(tool.inputSchema.type).toBe("object");
+    expect(tool.inputSchema.properties.html).toBeDefined();
+    expect(tool.inputSchema.required).toContain("html");
+  });
+});
+
+describe("handleValidationTool", () => {
+  it("throws on missing html parameter", () => {
+    expect(() => handleValidationTool("validate_html", {})).toThrow(
+      "html parameter is required",
+    );
+  });
+
+  it("throws on unknown tool name", () => {
+    expect(() => handleValidationTool("unknown_tool", { html: "<div/>" })).toThrow(
+      "Unknown validation tool",
+    );
+  });
+
+  it("returns { warnings } structure", () => {
+    const result = handleValidationTool("validate_html", {
+      html: '<div style="display:flex;"><span style="white-space:nowrap;">Hi</span></div>',
+    });
+    expect(result).toHaveProperty("warnings");
+    expect(Array.isArray(result.warnings)).toBe(true);
+  });
+});
+
+describe("rule: unsupported-position", () => {
+  it("flags position: absolute", () => {
+    const warnings = validateHtml(
+      '<div style="position:absolute;top:0;left:0;">content</div>',
+    );
+    const match = warnings.find((w) => w.rule === "unsupported-position");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("absolute");
+  });
+
+  it("flags position: fixed", () => {
+    const warnings = validateHtml(
+      '<div style="position:fixed;bottom:0;">content</div>',
+    );
+    const match = warnings.find((w) => w.rule === "unsupported-position");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("fixed");
+  });
+
+  it("does not flag position: relative", () => {
+    const warnings = validateHtml(
+      '<div style="position:relative;display:flex;"><span style="white-space:nowrap;">Hi</span></div>',
+    );
+    const posWarnings = warnings.filter((w) => w.rule === "unsupported-position");
+    expect(posWarnings).toHaveLength(0);
+  });
+});
+
+describe("rule: no-style-block", () => {
+  it("flags <style> blocks", () => {
+    const warnings = validateHtml(
+      '<style>.foo { color: red; }</style><div style="display:flex;"><span style="white-space:nowrap;">Hi</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "no-style-block");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("<style>");
+    expect(match.path).toBe("(document)");
+  });
+
+  it("does not flag HTML without style blocks", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">Hi</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "no-style-block");
+    expect(match).toBeUndefined();
+  });
+});
+
+describe("rule: multi-child-needs-flex", () => {
+  it("flags parent with multiple children but no display:flex", () => {
+    const warnings = validateHtml(
+      '<div><span style="white-space:nowrap;">A</span><span style="white-space:nowrap;">B</span><span style="white-space:nowrap;">C</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "multi-child-needs-flex");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("3 children");
+  });
+
+  it("passes when parent has display:flex", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">A</span><span style="white-space:nowrap;">B</span></div>',
+    );
+    const flexWarnings = warnings.filter((w) => w.rule === "multi-child-needs-flex");
+    expect(flexWarnings).toHaveLength(0);
+  });
+
+  it("passes when parent has display:none", () => {
+    const warnings = validateHtml(
+      '<div style="display:none;"><span>A</span><span>B</span></div>',
+    );
+    const flexWarnings = warnings.filter((w) => w.rule === "multi-child-needs-flex");
+    expect(flexWarnings).toHaveLength(0);
+  });
+
+  it("does not flag single-child containers", () => {
+    const warnings = validateHtml(
+      '<div><span style="white-space:nowrap;">Only child</span></div>',
+    );
+    const flexWarnings = warnings.filter((w) => w.rule === "multi-child-needs-flex");
+    expect(flexWarnings).toHaveLength(0);
+  });
+});
+
+describe("rule: no-br-tag", () => {
+  it("flags <br/> elements", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">Hello</span><br/><span style="white-space:nowrap;">World</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "no-br-tag");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("<br/>");
+  });
+
+  it("flags <br> (no self-close slash)", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">Hello</span><br><span style="white-space:nowrap;">World</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "no-br-tag");
+    expect(match).toBeDefined();
+  });
+
+  it("does not flag HTML without br tags", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">Hello World</span></div>',
+    );
+    const brWarnings = warnings.filter((w) => w.rule === "no-br-tag");
+    expect(brWarnings).toHaveLength(0);
+  });
+});
+
+describe("rule: text-needs-nowrap", () => {
+  it("flags text-containing element without white-space:nowrap", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span>Hello World</span></div>',
+    );
+    const match = warnings.find((w) => w.rule === "text-needs-nowrap");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("white-space: nowrap");
+  });
+
+  it("passes when white-space:nowrap is set", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:nowrap;">Hello</span></div>',
+    );
+    const nowrapWarnings = warnings.filter((w) => w.rule === "text-needs-nowrap");
+    expect(nowrapWarnings).toHaveLength(0);
+  });
+
+  it("passes when white-space:pre is set", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><span style="white-space:pre;">Hello</span></div>',
+    );
+    const nowrapWarnings = warnings.filter((w) => w.rule === "text-needs-nowrap");
+    expect(nowrapWarnings).toHaveLength(0);
+  });
+
+  it("flags p tags with text", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><p>Some paragraph text</p></div>',
+    );
+    const match = warnings.find((w) => w.rule === "text-needs-nowrap");
+    expect(match).toBeDefined();
+  });
+});
+
+describe("rule: unsupported-css-property", () => {
+  it("flags animation property", () => {
+    const warnings = validateHtml(
+      '<div style="animation:spin 1s linear infinite;display:flex;">content</div>',
+    );
+    const match = warnings.find((w) => w.rule === "unsupported-css-property");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("animation");
+  });
+
+  it("flags transition property", () => {
+    const warnings = validateHtml(
+      '<div style="transition:all 0.3s ease;display:flex;">content</div>',
+    );
+    const match = warnings.find((w) => w.rule === "unsupported-css-property");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("transition");
+  });
+
+  it("flags grid-template-columns", () => {
+    const warnings = validateHtml(
+      '<div style="display:grid;grid-template-columns:1fr 1fr;">content</div>',
+    );
+    const match = warnings.find((w) => w.rule === "unsupported-css-property");
+    expect(match).toBeDefined();
+    expect(match.message).toContain("grid-template-columns");
+  });
+
+  it("does not flag supported properties", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;padding:10px;margin:5px;border-radius:4px;"><span style="white-space:nowrap;color:red;font-size:14px;">Hi</span></div>',
+    );
+    const cssWarnings = warnings.filter((w) => w.rule === "unsupported-css-property");
+    expect(cssWarnings).toHaveLength(0);
+  });
+});
+
+describe("validate_html: clean HTML returns empty warnings", () => {
+  it("fully valid HTML returns no warnings", () => {
+    const html = `
+      <div style="display:flex;flex-direction:column;width:390px;height:844px;">
+        <div style="display:flex;padding:16px;">
+          <span style="white-space:nowrap;font-size:24px;font-weight:bold;">Title</span>
+        </div>
+        <div style="display:flex;flex-direction:column;gap:8px;padding:16px;">
+          <span style="white-space:nowrap;color:#666;">Subtitle</span>
+        </div>
+      </div>
+    `;
+    const result = handleValidationTool("validate_html", { html });
+    expect(result.warnings).toHaveLength(0);
+  });
+});
+
+describe("validate_html: path generation", () => {
+  it("generates meaningful element paths", () => {
+    const warnings = validateHtml(
+      '<div style="display:flex;"><div style="display:flex;"><span>text</span></div></div>',
+    );
+    const match = warnings.find((w) => w.rule === "text-needs-nowrap");
+    expect(match).toBeDefined();
+    expect(match.path).toContain("div[0]");
+    expect(match.path).toContain("span[0]");
+  });
+});
+
+describe("CSS allowlist completeness", () => {
+  it("contains core layout properties", () => {
+    const core = ["display", "width", "height", "margin", "padding", "flex"];
+    for (const p of core) {
+      expect(SATORI_ALLOWED_PROPERTIES.has(p)).toBe(true);
+    }
+  });
+
+  it("does not contain animation/transition/grid", () => {
+    const disallowed = ["animation", "transition", "grid-template-columns", "grid-area"];
+    for (const p of disallowed) {
+      expect(SATORI_ALLOWED_PROPERTIES.has(p)).toBe(false);
+    }
+  });
+});
diff --git a/mcp-server/src/tools/validation-tools.js b/mcp-server/src/tools/validation-tools.js
new file mode 100644
index 0000000..477a0f6
--- /dev/null
+++ b/mcp-server/src/tools/validation-tools.js
@@ -0,0 +1,315 @@
+/**
+ * Validation tools — dry-run Satori constraint checking for the Drawd MCP.
+ *
+ * One tool:
+ *   - validate_html   Parse HTML/CSS and return Satori rule violations without rendering.
+ */
+
+// ── Satori CSS property allowlist ────────────────────────────────────────────
+// Derived from Satori's supported CSS properties documentation.
+const SATORI_ALLOWED_PROPERTIES = new Set([
+  // Layout
+  "display", "position", "top", "right", "bottom", "left",
+  "width", "height", "min-width", "min-height", "max-width", "max-height",
+  "margin", "margin-top", "margin-right", "margin-bottom", "margin-left",
+  "padding", "padding-top", "padding-right", "padding-bottom", "padding-left",
+  "overflow", "overflow-x", "overflow-y",
+
+  // Flexbox
+  "flex", "flex-direction", "flex-wrap", "flex-flow",
+  "flex-grow", "flex-shrink", "flex-basis",
+  "justify-content", "align-items", "align-self", "align-content",
+  "gap", "row-gap", "column-gap",
+  "order",
+
+  // Typography
+  "font-family", "font-size", "font-weight", "font-style",
+  "text-align", "text-transform", "text-decoration", "text-overflow",
+  "text-shadow", "line-height", "letter-spacing", "word-spacing",
+  "white-space", "word-break", "word-wrap", "overflow-wrap",
+  "tab-size",
+
+  // Visual
+  "color", "background", "background-color", "background-image",
+  "background-size", "background-position", "background-repeat",
+  "background-clip",
+  "border", "border-top", "border-right", "border-bottom", "border-left",
+  "border-width", "border-top-width", "border-right-width",
+  "border-bottom-width", "border-left-width",
+  "border-style", "border-top-style", "border-right-style",
+  "border-bottom-style", "border-left-style",
+  "border-color", "border-top-color", "border-right-color",
+  "border-bottom-color", "border-left-color",
+  "border-radius", "border-top-left-radius", "border-top-right-radius",
+  "border-bottom-left-radius", "border-bottom-right-radius",
+  "box-shadow", "opacity",
+  "outline", "outline-color", "outline-style", "outline-width",
+  "box-sizing",
+
+  // Transform
+  "transform", "transform-origin",
+
+  // Misc
+  "object-fit", "object-position",
+  "filter",
+  "mask-image",
+  "clip-path",
+]);
+
+// ── HTML parser (minimal, tag-aware) ─────────────────────────────────────────
+
+/**
+ * A minimal HTML parser that builds a tree structure sufficient for
+ * Satori constraint validation. Not a full HTML parser — handles the
+ * subset of HTML that agents produce for screen rendering.
+ */
+function parseHtmlToTree(html) {
+  const nodes = [];
+  const stack = [];
+  // Track index among siblings for path generation
+  const childCounters = [{}]; // counters per level
+
+  const TAG_RE = /<\/?([a-zA-Z][a-zA-Z0-9]*)\b([^>]*?)(\/?)\s*>/g;
+  let match;
+
+  while ((match = TAG_RE.exec(html)) !== null) {
+    const [fullMatch, tagName, attrs, selfClose] = match;
+    const isClose = fullMatch.startsWith("</");
+    const tag = tagName.toLowerCase();
+
+    if (isClose) {
+      stack.pop();
+      childCounters.pop();
+    } else {
+      const node = {
+        tag,
+        attrs: parseAttrs(attrs),
+        children: [],
+        textContent: "",
+        selfClosing: selfClose === "/" || isSelfClosingTag(tag),
+      };
+
+      // Extract style
+      node.style = parseInlineStyle(node.attrs.style || "");
+
+      // Get text content between this tag and the next tag
+      const afterTag = match.index + fullMatch.length;
+      const nextTagIdx = html.indexOf("<", afterTag);
+      if (nextTagIdx > afterTag) {
+        node.textContent = html.slice(afterTag, nextTagIdx).trim();
+      }
+
+      // Assign to parent or root
+      if (stack.length > 0) {
+        const parent = stack[stack.length - 1];
+        parent.children.push(node);
+      } else {
+        nodes.push(node);
+      }
+
+      // Push onto stack if not self-closing
+      if (!node.selfClosing) {
+        stack.push(node);
+        childCounters.push({});
+      }
+    }
+  }
+
+  return nodes;
+}
+
+function isSelfClosingTag(tag) {
+  return [
+    "img", "br", "hr", "input", "meta", "link", "area",
+    "base", "col", "embed", "source", "track", "wbr",
+  ].includes(tag);
+}
+
+function parseAttrs(attrString) {
+  const attrs = {};
+  const ATTR_RE = /([a-zA-Z_:][a-zA-Z0-9_.:-]*)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+  let m;
+  while ((m = ATTR_RE.exec(attrString)) !== null) {
+    attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+  }
+  return attrs;
+}
+
+function parseInlineStyle(styleStr) {
+  const style = {};
+  if (!styleStr) return style;
+  const declarations = styleStr.split(";");
+  for (const decl of declarations) {
+    const colonIdx = decl.indexOf(":");
+    if (colonIdx === -1) continue;
+    const prop = decl.slice(0, colonIdx).trim().toLowerCase();
+    const value = decl.slice(colonIdx + 1).trim();
+    if (prop) style[prop] = value;
+  }
+  return style;
+}
+
+// ── Validation rules ─────────────────────────────────────────────────────────
+
+/**
+ * Walk the tree and collect warnings.
+ */
+function validateTree(nodes) {
+  const warnings = [];
+
+  function walk(node, pathParts) {
+    const path = pathParts.join(" > ");
+
+    // Rule: unsupported-position
+    if (node.style.position === "absolute" || node.style.position === "fixed") {
+      warnings.push({
+        path,
+        rule: "unsupported-position",
+        message: `position: ${node.style.position} is not supported`,
+      });
+    }
+
+    // Rule: no-br-tag
+    if (node.tag === "br") {
+      warnings.push({
+        path,
+        rule: "no-br-tag",
+        message: "<br/> is not supported in Satori; use margin/padding for spacing",
+      });
+    }
+
+    // Rule: multi-child-needs-flex
+    if (node.children.length > 1) {
+      const display = node.style.display;
+      if (!display || (display !== "flex" && display !== "none" && display !== "contents")) {
+        warnings.push({
+          path,
+          rule: "multi-child-needs-flex",
+          message: `${node.children.length} children but no display: flex`,
+        });
+      }
+    }
+
+    // Rule: text-needs-nowrap
+    // If the node has direct text content and no white-space: nowrap
+    if (node.textContent && isTextContainer(node)) {
+      const ws = node.style["white-space"];
+      if (!ws || (ws !== "nowrap" && ws !== "pre")) {
+        warnings.push({
+          path,
+          rule: "text-needs-nowrap",
+          message: "Text leaf missing white-space: nowrap",
+        });
+      }
+    }
+
+    // Rule: unsupported-css-property
+    for (const prop of Object.keys(node.style)) {
+      if (!SATORI_ALLOWED_PROPERTIES.has(prop)) {
+        warnings.push({
+          path,
+          rule: "unsupported-css-property",
+          message: `CSS property "${prop}" is not supported by Satori`,
+        });
+      }
+    }
+
+    // Recurse into children
+    const tagCounts = {};
+    for (const child of node.children) {
+      const count = tagCounts[child.tag] || 0;
+      tagCounts[child.tag] = count + 1;
+      const childPath = `${child.tag}[${count}]`;
+      walk(child, [...pathParts, childPath]);
+    }
+  }
+
+  // Walk root nodes
+  const tagCounts = {};
+  for (const node of nodes) {
+    const count = tagCounts[node.tag] || 0;
+    tagCounts[node.tag] = count + 1;
+    walk(node, [`${node.tag}[${count}]`]);
+  }
+
+  return warnings;
+}
+
+function isTextContainer(node) {
+  // A node is a text container if it has text content and is an inline
+  // or block element that contains text (span, p, h1-h6, a, label, etc.)
+  const textTags = [
+    "span", "p", "a", "label", "h1", "h2", "h3", "h4", "h5", "h6",
+    "strong", "em", "b", "i", "u", "small", "mark", "sub", "sup",
+    "div", "li", "td", "th", "dt", "dd", "figcaption", "button",
+  ];
+  return textTags.includes(node.tag);
+}
+
+/**
+ * Top-level validation: checks for <style> blocks and then validates the tree.
+ */
+function validateHtml(html) {
+  const warnings = [];
+
+  // Rule: no-style-block
+  const styleBlockRe = /<style\b[^>]*>[\s\S]*?<\/style>/gi;
+  let styleMatch;
+  while ((styleMatch = styleBlockRe.exec(html)) !== null) {
+    warnings.push({
+      path: "(document)",
+      rule: "no-style-block",
+      message: "<style> blocks are not supported; use inline styles only",
+    });
+  }
+
+  // Parse and validate the tree
+  const tree = parseHtmlToTree(html);
+  const treeWarnings = validateTree(tree);
+  warnings.push(...treeWarnings);
+
+  return warnings;
+}
+
+// ── Tool definition ──────────────────────────────────────────────────────────
+
+export const validationTools = [
+  {
+    name: "validate_html",
+    description:
+      "Validate HTML/CSS against Satori rendering constraints WITHOUT rasterizing. " +
+      "Returns a structured list of warnings (unsupported CSS, missing flex, position issues, etc.). " +
+      "Use this before create_screen/update_screen_image to catch layout bugs in milliseconds " +
+      "instead of waiting for a full render. Empty warnings[] means HTML passes validation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        html: {
+          type: "string",
+          description: "The HTML string to validate against Satori constraints.",
+        },
+      },
+      required: ["html"],
+    },
+  },
+];
+
+export function handleValidationTool(name, args) {
+  if (name === "validate_html") {
+    const { html } = args;
+    if (!html || typeof html !== "string") {
+      throw new Error("html parameter is required and must be a string");
+    }
+    const warnings = validateHtml(html);
+    return { warnings };
+  }
+  throw new Error(`Unknown validation tool: ${name}`);
+}
+
+// Export internals for testing
+export const _internal = {
+  parseHtmlToTree,
+  validateTree,
+  validateHtml,
+  SATORI_ALLOWED_PROPERTIES,
+};