webcake-landing-mcp 1.0.60 → 1.0.61

package/dist/changelog.json

@@ -1,4 +1,11 @@
 [
+  {
+    "v": "1.0.61",
+    "d": "11/06/2026",
+    "type": "Added",
+    "en": "ingest_html and ingest_url now return a size_hint field ({ height, basis, css? }) on every AST section, providing the desktop section height in px…",
+    "vi": "ingest_html và ingest_url nay trả về trường size_hint ({ height, basis, css? }) trên mỗi section trong AST, cung cấp chiều cao desktop của section…"
+  },
   {
     "v": "1.0.60",
     "d": "11/06/2026",
@@ -33,12 +40,5 @@
     "type": "Added",
     "en": "The expand pipeline now automatically derives styles.background from specials.src for every image-block node; the live published renderer reads only…",
     "vi": "Pipeline expand nay tự động tính styles.background từ specials.src cho mọi node image-block; renderer trên trang published chỉ đọc…"
-  },
-  {
-    "v": "1.0.55",
-    "d": "10/06/2026",
-    "type": "Fixed",
-    "en": "The install command now correctly locates claude_desktop_config.json on Windows when Claude Desktop was installed from the Microsoft Store: the…",
-    "vi": "Lệnh install nay xác định đúng đường dẫn claude_desktop_config.json trên Windows khi Claude Desktop được cài từ Microsoft Store: bản Store bị…"
   }
 ]

package/dist/domains/landing/guide.js

@@ -154,5 +154,6 @@ EDITING an existing page
 
 REFERENCE INPUT (HTML page to clone or adapt)
 - ingest_html(html, detail:'full') / ingest_url(url, detail:'full') returns a richer AST for clone-quality rebuilds: CSS custom-property palette (design tokens by name), background_images from stylesheets (hero/CTA bg images invisible to a plain img scan), per-section blocks (repeating card/tile/step structures with title/body/image/cta), li lists, gradients, and images as { src, alt } objects. Use detail:'compact' (default) for a quick layout-only reference.
-- Map AST section roles to Webcake elements: hero → section (background image/overlay) + text-block H1 + text-block subheading + button; features → group per card (icon rectangle + text-block title + text-block body); stats bar → group with text-block per stat; pricing → group with text-block list + button; footer → section (dark bg) + text-block + links. When the ingested page contains a composite widget (phone/device mockup, chat thread, mini dashboard, browser frame) → rebuild it as ONE html-box (clone its HTML with all styles inlined), NOT as element soup.
+- SECTION HEIGHTS: every AST section carries size_hint = { height, basis, css? } — the section's desktop height on the 960px canvas (basis:'css' = an explicit height/min-height found in the source, css holds the raw value e.g. "100vh"; basis:'estimate' = content-volume math). Set each rebuilt section's desktop height FROM its size_hint (±15% to fit your actual element placement) instead of the 800px default, so the page's vertical rhythm tracks the source: a 72px header stays a slim bar, a 1200px pricing band stays tall. Mobile is NOT hinted — redo the height per the mobile text math (stacked content is taller).
+- Map AST section roles to Webcake elements: hero → section (background image/overlay) + text-block H1 + text-block subheading + button; features → group per card (icon rectangle + text-block title + text-block body); stats bar → group with text-block per stat; pricing → group with text-block list + button; footer → section (dark bg) + text-block + links. When the ingested page contains a composite widget (phone/device mockup, chat thread, mini dashboard, browser frame) → rebuild it as ONE html-box, NOT as element soup. The full AST hands you the SOURCE for this: section.widgets = [{ hint, html, css? }] — the widget's cleaned outerHTML plus the stylesheet rules that style it. Build the html-box FROM that html verbatim: inline each css rule into the matching elements' style="" attributes (an html-box has no <style> scope), wrap in a root div with width:100%;height:100%;box-sizing:border-box;overflow:hidden, and size the html-box to the widget's box — do NOT re-imagine the widget's markup from the summary fields.
 - Reference images are the user's assets — for BOTH intents (adapt AND clone), re-host every real image URL found in the AST (images, background_images, og_image) via upload_images and reuse it in the matching slot; never hotlink and never replace it with a search_images stock photo. intent='adapt' rewrites TEXT for the user's brand, not the imagery; search_images only fills slots that have no source image.`;

package/dist/persistence/html-ingest.js

@@ -165,7 +165,16 @@ export function parseHtml(html, detail = "compact") {
         };
     }
     const sectionEls = findSections(body);
-    const sections = sectionEls.map((el) => classifySection(el, detail));
+    const sections = sectionEls.map((el) => {
+        const sec = classifySection(el, detail);
+        sec.size_hint = computeSizeHint(el, sec, styleBlocks);
+        if (detail === "full") {
+            const widgets = detectWidgets(el, styleBlocks);
+            if (widgets.length)
+                sec.widgets = widgets;
+        }
+        return sec;
+    });
     // Brand hints from inline styles (both modes).
     const styleAttrs = [];
     body.querySelectorAll("[style]").forEach((el) => {
@@ -204,25 +213,33 @@ export function parseHtml(html, detail = "compact") {
         ...base,
         gradients: gradients.length ? gradients : undefined,
     };
-    // Size-cap: drop blocks[].body first, then truncate lists.
-    const serialized = JSON.stringify(result);
-    if (serialized.length > FULL_SIZE_CAP) {
-        // Strip block bodies.
+    // Size-cap shedding order: blocks[].body → widgets[].css → lists → widgets
+    // (widget html goes last — it's the clone-fidelity payload of full mode).
+    if (JSON.stringify(result).length > FULL_SIZE_CAP) {
         for (const sec of result.sections) {
-            if (sec.blocks) {
+            if (sec.blocks)
                 for (const blk of sec.blocks)
                     delete blk.body;
+        }
+        if (JSON.stringify(result).length > FULL_SIZE_CAP) {
+            for (const sec of result.sections) {
+                if (sec.widgets)
+                    for (const w of sec.widgets)
+                        delete w.css;
             }
         }
-        const s2 = JSON.stringify(result);
-        if (s2.length > FULL_SIZE_CAP) {
-            // Truncate lists.
+        if (JSON.stringify(result).length > FULL_SIZE_CAP) {
             for (const sec of result.sections) {
                 if (sec.lists && sec.lists.length > 5)
                     sec.lists = sec.lists.slice(0, 5);
             }
             result.truncated = true;
         }
+        if (JSON.stringify(result).length > FULL_SIZE_CAP) {
+            for (const sec of result.sections)
+                delete sec.widgets;
+            result.truncated = true;
+        }
     }
     return result;
 }
@@ -616,6 +633,202 @@ function pickLists(el, _blocks) {
         .filter((t) => t.length > 3 && t.length < 200)
         .slice(0, 15);
 }
+// ─── size hint (desktop section height) ──────────────────────────────────────
+const SIZE_DECL_RE = /(?:^|[;{\s])(min-height|height)\s*:\s*([\d.]+)(px|vh|rem|em)\b/gi;
+const VH_PX = 8; // 1vh ≈ 8px (~800px viewport), so a 100vh hero lands near the editor's 800px default band
+function clamp(v, lo, hi) {
+    return Math.min(hi, Math.max(lo, v));
+}
+/** lines ≈ ceil(chars × fontSize × glyphFactor / width) — same model as the generation guide's text math. */
+function textLines(chars, fontSize, width, factor = 0.55) {
+    if (chars <= 0)
+        return 0;
+    return Math.max(1, Math.ceil((chars * fontSize * factor) / width));
+}
+/** Parse height/min-height declarations out of a CSS declaration string. */
+function sizeDecls(decl) {
+    const out = [];
+    SIZE_DECL_RE.lastIndex = 0;
+    let m;
+    while ((m = SIZE_DECL_RE.exec(decl)) !== null) {
+        const kind = m[1].toLowerCase();
+        const v = parseFloat(m[2]);
+        const unit = m[3].toLowerCase();
+        const px = unit === "px" ? v : unit === "vh" ? v * VH_PX : v * 16; // rem/em ≈ 16px
+        if (px >= 40 && px <= 2400)
+            out.push({ kind, px: Math.round(px), raw: `${m[2]}${unit}` });
+    }
+    return out;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Explicit height/min-height for a section element: its inline style, plus any
+ * stylesheet rule whose selector mentions the element's #id or one of its
+ * classes (whole-token match — `.hero` doesn't match `.hero-card`). Regex-level
+ * on purpose; full selector matching needs a renderer.
+ */
+function cssSizeDecls(el, styleBlocks) {
+    const out = [];
+    const inline = el.getAttribute("style");
+    if (inline)
+        out.push(...sizeDecls(inline));
+    const id = el.getAttribute("id");
+    const classes = (el.getAttribute("class") ?? "").trim().split(/\s+/).filter(Boolean).slice(0, 4);
+    const tokens = [...(id ? ["#" + id] : []), ...classes.map((c) => "." + c)];
+    if (tokens.length) {
+        const matchers = tokens.map((t) => new RegExp(escapeRe(t) + "(?![\\w-])"));
+        const ruleRe = /([^{}]+)\{([^{}]*)\}/g;
+        for (const css of styleBlocks) {
+            ruleRe.lastIndex = 0;
+            let m;
+            while ((m = ruleRe.exec(css)) !== null) {
+                if (matchers.some((re) => re.test(m[1])))
+                    out.push(...sizeDecls(m[2]));
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Content-volume estimate of the section's desktop height (960px canvas,
+ * ~800px content column) so the rebuilt band is proportional to the source
+ * instead of a flat 800px default.
+ */
+function estimateSectionHeight(el, sec) {
+    const role = sec.role;
+    if (role === "header")
+        return 72;
+    if (role === "footer") {
+        const linkRows = Math.ceil((sec.links?.length ?? 0) / 4);
+        return clamp(120 + linkRows * 32 + (sec.paragraphs?.length ?? 0) * 24, 140, 480);
+    }
+    let h = 140; // band padding (top + bottom)
+    if (sec.heading) {
+        const fs = role === "hero" ? 48 : 36;
+        h += textLines(sec.heading.length, fs, 800, 0.6) * Math.round(fs * 1.2) + 20;
+    }
+    if (sec.subheading)
+        h += textLines(sec.subheading.length, 18, 640) * 27 + 16;
+    for (const p of sec.paragraphs ?? [])
+        h += textLines(p.length, 16, 640) * 24 + 12;
+    if (sec.ctas?.length)
+        h += 76;
+    if (sec.form_fields?.length)
+        h += sec.form_fields.length * 64 + 24;
+    // Card/tile rows: full mode carries blocks; compact recounts from the DOM.
+    let cards = sec.blocks?.length ?? 0;
+    if (!cards && (role === "features" || role === "pricing" || role === "testimonials")) {
+        cards = Math.min(countFeatureBlocks(el), 12);
+    }
+    if (cards)
+        h += Math.ceil(cards / 3) * (role === "pricing" ? 420 : 260) + 24;
+    else if (sec.lists?.length)
+        h += sec.lists.length * 30;
+    const imgCount = sec.images?.length ?? 0;
+    if (role === "gallery")
+        h += Math.ceil(imgCount / 3) * 260;
+    else if (role === "hero")
+        h = Math.max(h, imgCount ? 560 : 480);
+    else if (imgCount)
+        h += 320; // a content image alongside/below the text
+    return clamp(Math.round(h / 10) * 10, 160, 1600);
+}
+function computeSizeHint(el, sec, styleBlocks) {
+    const estimate = estimateSectionHeight(el, sec);
+    const decls = cssSizeDecls(el, styleBlocks);
+    const fixed = decls.filter((d) => d.kind === "height").sort((a, b) => b.px - a.px)[0];
+    // An explicit height pins the band; min-height grows with content, so take the larger.
+    if (fixed)
+        return { height: fixed.px, basis: "css", css: fixed.raw };
+    const min = decls.filter((d) => d.kind === "min-height").sort((a, b) => b.px - a.px)[0];
+    if (min)
+        return { height: Math.max(min.px, estimate), basis: "css", css: min.raw };
+    return { height: estimate, basis: "estimate" };
+}
+// ─── full-mode: composite-widget extraction (html-box source) ────────────────
+// Class/id keywords that mark a composite visual the guide rebuilds as ONE
+// html-box. Conservative on purpose — generic words (card, window, slider)
+// over-match ordinary content.
+const WIDGET_HINT_RE = /\b(mockup|phone|device|browser|terminal|console|dashboard|chat|inbox|player)\b/i;
+const WIDGET_HTML_CAP = 8000;
+const WIDGET_CSS_CAP = 4000;
+const MAX_WIDGETS_PER_SECTION = 2;
+/** outerHTML cleaned for html-box reuse: scripts/styles stripped, whitespace collapsed. */
+function cleanWidgetHtml(el) {
+    // Re-parse a copy so removals don't mutate the tree other pickers read.
+    const frag = parse(el.toString(), { lowerCaseTagName: true });
+    frag.querySelectorAll("script, style, noscript").forEach((n) => n.remove());
+    return frag
+        .toString()
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/>\s+</g, "><")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+}
+/** Stylesheet rules whose selector mentions a class/id used inside the widget HTML. */
+function widgetCss(html, styleBlocks) {
+    const tokens = new Set();
+    for (const m of html.matchAll(/class="([^"]+)"/g)) {
+        for (const c of m[1].trim().split(/\s+/))
+            if (c)
+                tokens.add("." + c);
+    }
+    for (const m of html.matchAll(/id="([^"]+)"/g)) {
+        if (m[1].trim())
+            tokens.add("#" + m[1].trim());
+    }
+    if (!tokens.size)
+        return undefined;
+    const matchers = [...tokens].map((t) => new RegExp(escapeRe(t) + "(?![\\w-])"));
+    const parts = [];
+    let total = 0;
+    const ruleRe = /([^{}]+)\{([^{}]*)\}/g;
+    for (const css of styleBlocks) {
+        ruleRe.lastIndex = 0;
+        let m;
+        while ((m = ruleRe.exec(css)) !== null) {
+            const sel = m[1].trim();
+            if (!matchers.some((re) => re.test(sel)))
+                continue;
+            const rule = `${sel.replace(/\s+/g, " ")}{${m[2].trim().replace(/\s+/g, " ")}}`;
+            if (total + rule.length > WIDGET_CSS_CAP)
+                return parts.join("");
+            parts.push(rule);
+            total += rule.length;
+        }
+    }
+    return parts.length ? parts.join("") : undefined;
+}
+/**
+ * Find composite-widget candidates inside a section: OUTERMOST descendants
+ * whose class/id matches WIDGET_HINT_RE and that have real internal structure
+ * (≥3 descendant elements). Emits the cleaned HTML + matching CSS so the
+ * model's html-box reproduces the source instead of approximating it.
+ */
+function detectWidgets(el, styleBlocks) {
+    const out = [];
+    const walk = (node) => {
+        for (const k of elementChildren(node)) {
+            if (out.length >= MAX_WIDGETS_PER_SECTION)
+                return;
+            const idCls = (k.getAttribute("id") ?? "") + " " + (k.getAttribute("class") ?? "");
+            const m = idCls.match(WIDGET_HINT_RE);
+            if (m && k.querySelectorAll("*").length >= 3) {
+                const html = cleanWidgetHtml(k);
+                if (html && html.length <= WIDGET_HTML_CAP) {
+                    const css = widgetCss(html, styleBlocks);
+                    out.push(css ? { hint: m[1].toLowerCase(), html, css } : { hint: m[1].toLowerCase(), html });
+                    continue; // outermost only — don't descend into an emitted widget
+                }
+            }
+            walk(k);
+        }
+    };
+    walk(el);
+    return out;
+}
 // ─── color / font helpers ────────────────────────────────────────────────────
 function elText(el) {
     const t = el?.text?.trim();

package/dist/smoke.js

@@ -236,6 +236,28 @@ check("ingest: hero image captured", (hero?.images?.length ?? 0) > 0, hero?.imag
 const form = ast.sections.find((s) => s.role === "form");
 check("ingest: form fields captured", (form?.form_fields?.length ?? 0) >= 2, form?.form_fields);
 check("ingest: form submit CTA captured", !!form?.ctas?.[0]?.text?.includes("Place"), form?.ctas);
+console.log("== ingest: size_hint (desktop section heights) ==");
+check("ingest: every section has a size_hint", ast.sections.every((s) => (s.size_hint?.height ?? 0) > 0), ast.sections.map((s) => s.size_hint));
+const headerHint = ast.sections.find((s) => s.role === "header")?.size_hint;
+check("ingest: header size_hint is a slim bar", !!headerHint && headerHint.height <= 120, headerHint);
+const heroHint = ast.sections.find((s) => s.role === "hero")?.size_hint;
+check("ingest: hero size_hint is a tall band", !!heroHint && heroHint.height >= 400, heroHint);
+const footerHint = ast.sections.find((s) => s.role === "footer")?.size_hint;
+check("ingest: footer size_hint shorter than hero", !!footerHint && !!heroHint && footerHint.height < heroHint.height, { footerHint, heroHint });
+const cssHintHtml = `<!DOCTYPE html><html><head><style>
+  .hero { min-height: 100vh; }
+  #promo { height: 560px; }
+</style></head><body>
+  <section class="hero"><h1>Big hero</h1><p>Tagline goes here for the hero band.</p><button>Go</button></section>
+  <section id="promo"><h2>Promo</h2><p>Limited time offer on all plans this week.</p><button>Claim</button></section>
+  <section style="min-height: 75vh"><h2>Inline</h2><p>Inline-styled band with its own height.</p></section>
+</body></html>`;
+const cssAst = parseHtml(cssHintHtml);
+const cssHints = cssAst.sections.map((s) => s.size_hint);
+check("ingest: 100vh class rule → css basis ~800px", cssHints[0]?.basis === "css" && cssHints[0]?.height === 800 && cssHints[0]?.css === "100vh", cssHints[0]);
+check("ingest: explicit px height by #id → css basis exact", cssHints[1]?.basis === "css" && cssHints[1]?.height === 560, cssHints[1]);
+check("ingest: inline min-height vh → css basis", cssHints[2]?.basis === "css" && cssHints[2]?.height === 600, cssHints[2]);
+check("ingest: .hero rule does not leak into #promo", cssHints[1]?.css !== "100vh", cssHints[1]);
 console.log("== ingest: tolerates empty/CSR-shell HTML ==");
 const empty = parseHtml("");
 check("ingest: empty input → warning", (empty.warnings?.length ?? 0) > 0, empty.warnings);
@@ -296,6 +318,27 @@ check("ingest: compact has no blocks", compactAst.sections.every((s) => s.blocks
 check("ingest: compact has no gradients", compactAst.gradients === undefined, compactAst.gradients);
 check("ingest: compact images are plain strings", compactAst.sections.every((s) => !s.images || s.images.every((i) => typeof i === "string")), compactAst.sections.map((s) => s.images));
 check("ingest: default (no detail arg) is compact-compatible", parseHtml(sampleHtml).sections.every((s) => s.blocks === undefined));
+console.log("== ingest: full mode — composite widget extraction (html-box source) ==");
+const widgetHtml = `<!DOCTYPE html><html><head><style>
+  .phone-mockup { width: 320px; border-radius: 24px; background: #111; }
+  .chat-bubble { padding: 8px 12px; border-radius: 12px; background: #f1f1f1; }
+  .chat-bubble.right { background: #0A7C6E; color: #fff; }
+</style></head><body>
+  <section><h1>Talk to us</h1><p>Our assistant answers around the clock for you.</p><button>Start chat</button>
+    <div class="phone-mockup"><div class="screen"><div class="chat-bubble left">Xin chào!</div><div class="chat-bubble right">Chào bạn</div><div class="chat-input">Type a message…</div></div><script>track()</script></div>
+  </section>
+  <section><h2>About</h2><p>Plain prose section with no composite widget at all.</p></section>
+</body></html>`;
+const widgetAst = parseHtml(widgetHtml, "full");
+const wSec = widgetAst.sections[0];
+check("widgets: detected on the mockup section", (wSec?.widgets?.length ?? 0) === 1, wSec?.widgets?.map((w) => w.hint));
+const w0 = wSec?.widgets?.[0];
+check("widgets: hint from class keyword", w0?.hint === "phone" || w0?.hint === "mockup", w0?.hint);
+check("widgets: html keeps inner structure", !!w0?.html.includes("chat-bubble"), w0?.html);
+check("widgets: scripts stripped from html", !(w0?.html ?? "").includes("<script"), w0?.html);
+check("widgets: matching css rules attached", !!w0?.css?.includes(".phone-mockup") && !!w0?.css?.includes(".chat-bubble"), w0?.css);
+check("widgets: none on plain sections", widgetAst.sections[1]?.widgets === undefined, widgetAst.sections[1]);
+check("widgets: compact mode emits none", parseHtml(widgetHtml, "compact").sections.every((s) => s.widgets === undefined));
 console.log("== ingest: nested-grid block detection (depth > 1) ==");
 // section > .grid-wrapper > .card  — blocks must be found even though cards are not direct children
 const nestedGridHtml = `<!DOCTYPE html><html lang="en"><head><title>T</title></head><body>

package/dist/tools/ingest.js

@@ -24,9 +24,9 @@ import { parseHtml, fetchHtml } from "../persistence/html-ingest.js";
 const detailParam = z
     .enum(["compact", "full"])
     .optional()
-    .describe("Level of detail in the returned AST. 'compact' (default) — backward-compatible ~2-5 KB shape with top colors/fonts from inline styles. 'full' — richer AST: CSS custom-property palette (design tokens by name), background_images from stylesheets, gradients, per-section blocks (repeating card/tile/step structures with title/body/image/cta), li lists, extended paragraphs, and images as { src, alt } objects. Use 'full' for clone-faithful rebuilds. Image URLs found in the result (images, background_images, og_image) are the user's assets: re-host them via upload_images and reuse them in the generated page for BOTH intents (never hotlink, never replace them with search_images stock photos).");
+    .describe("Level of detail in the returned AST. 'compact' (default) — backward-compatible ~2-5 KB shape with top colors/fonts from inline styles. 'full' — richer AST: CSS custom-property palette (design tokens by name), background_images from stylesheets, gradients, per-section blocks (repeating card/tile/step structures with title/body/image/cta), li lists, extended paragraphs, images as { src, alt } objects, and per-section widgets = { hint, html, css? } — the cleaned source HTML + matching CSS of composite visuals (phone/device mockup, chat thread, dashboard, browser frame) to rebuild VERBATIM as ONE html-box (inline the css; don't re-imagine the markup). Use 'full' for clone-faithful rebuilds. Image URLs found in the result (images, background_images, og_image) are the user's assets: re-host them via upload_images and reuse them in the generated page for BOTH intents (never hotlink, never replace them with search_images stock photos).");
 export function registerIngestTools(server) {
-    server.tool("ingest_html", "Parses an HTML string into a reference AST: title, description, og_image, language, and sections classified by role (header, hero, features, about, form, cta, gallery, testimonials, pricing, faq, footer, unknown) with headings, subheadings, paragraphs, images, ctas, links, form fields — plus top colors, fonts, CSS custom-property palette, and background_images pulled from both inline styles and <style> blocks. Returns ~2-5KB (compact) or up to ~25KB (full). Use detail:'full' for clone-faithful rebuilds — it adds per-section blocks (cards/tiles/steps), li lists, gradients, and images as { src, alt } objects. Image URLs in the result (images, background_images, og_image) are the user's assets — re-host them via upload_images and reuse them for BOTH intents; use search_images only for slots with no source image.", {
+    server.tool("ingest_html", "Parses an HTML string into a reference AST: title, description, og_image, language, and sections classified by role (header, hero, features, about, form, cta, gallery, testimonials, pricing, faq, footer, unknown) with headings, subheadings, paragraphs, images, ctas, links, form fields, and a size_hint (desktop section height in px — from the source CSS when explicit, else a content-volume estimate; set the rebuilt section's desktop height from it) — plus top colors, fonts, CSS custom-property palette, and background_images pulled from both inline styles and <style> blocks. Returns ~2-5KB (compact) or up to ~25KB (full). Use detail:'full' for clone-faithful rebuilds — it adds per-section blocks (cards/tiles/steps), li lists, gradients, images as { src, alt } objects, and widgets (the source HTML + CSS of composite mockups, to paste into ONE html-box). Image URLs in the result (images, background_images, og_image) are the user's assets — re-host them via upload_images and reuse them for BOTH intents; use search_images only for slots with no source image.", {
         html: z.string().describe("Raw HTML of a page or a section."),
         intent: z
             .enum(["adapt", "clone"])
@@ -34,7 +34,7 @@ export function registerIngestTools(server) {
             .describe("How the caller intends to use the result. 'adapt' (default) — use as a layout reference and rewrite the TEXT for the user's brand (images from the reference are still re-hosted via upload_images and reused). 'clone' — keep text and images close to the original."),
         detail: detailParam,
     }, { title: "Ingest HTML Reference", readOnlyHint: true, openWorldHint: false }, async ({ html, intent, detail }) => text({ intent: intent ?? "adapt", ...parseHtml(html, detail ?? "compact") }));
-    server.tool("ingest_url", "Fetches a public webpage (GET, 10s timeout, 2MB cap) and parses it into the same reference AST as ingest_html. Returns a warning when the page appears client-rendered (empty <body>) so the caller can fall back to a screenshot — Claude can analyze a screenshot natively without this tool. Does not execute JavaScript; sites built with React/Vue/Next.js may return little content. Use detail:'full' for clone-faithful rebuilds — adds CSS palette, background_images, per-section blocks, lists, and images as { src, alt } objects. Image URLs in the result are the user's assets — re-host them via upload_images and reuse them for BOTH intents; use search_images only for slots with no source image.", {
+    server.tool("ingest_url", "Fetches a public webpage (GET, 10s timeout, 2MB cap) and parses it into the same reference AST as ingest_html (including per-section size_hint desktop heights). Returns a warning when the page appears client-rendered (empty <body>) so the caller can fall back to a screenshot — Claude can analyze a screenshot natively without this tool. Does not execute JavaScript; sites built with React/Vue/Next.js may return little content. Use detail:'full' for clone-faithful rebuilds — adds CSS palette, background_images, per-section blocks, lists, images as { src, alt } objects, and widgets (source HTML + CSS of composite mockups for html-box rebuilds). Image URLs in the result are the user's assets — re-host them via upload_images and reuse them for BOTH intents; use search_images only for slots with no source image.", {
         url: z.string().describe("Public HTTP(S) URL of the page to fetch."),
         intent: z
             .enum(["adapt", "clone"])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webcake-landing-mcp",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "description": "MCP server exposing Webcake landing-page element schemas + AI usage hints, and persisting LLM-generated page sources to a Webcake backend.",
   "mcpName": "io.github.vuluu2k/webcake-landing-mcp",
   "type": "module",