sbuilder-mcp 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.1] - 2026-09-09
+
+### Added
+- sb_review now reports `hover_dead` for a node whose element keeps its hover state in a legacy home its own renderer reads instead of the universal `states.hover` slot — a `button`, for instance — naming the sb_set call that moves the values where they will actually paint.
+- npm run codegen now refuses to run against a web_builder checkout with uncommitted changes in the directories it reads (schema/src, editor/src, server/render, server/docs), naming the dirty files instead of silently baking a concurrent session's half-finished work into the committed catalog; `--dirty` overrides it for generating against your own in-progress change.
+
+### Fixed
+- The generated element catalog is regenerated from a committed ref, removing a `cart-count` element and its satellite owner that had leaked in from another session's uncommitted platform change; the catalog is back to 108 elements.
+
+## [0.11.0] - 2026-09-09
+
+### Added
+- sb_set's `state:"hover"` now routes each write to the home its element's own renderer actually reads, since the platform's universal hover compiler deliberately stands aside for twelve element types that declare their own Hover variant; a `button` write now lands in `config.stateHover` (flat, base-only) instead of the unread `states.hover` slot, and the response reports where it went so a caller reading the node back is not surprised.
+- sb_set refuses a `state:"parentHover"` write on a node with no box to key off — a satellite, a direct child of the page root, or an orphan — naming the reason instead of storing a rule the platform would never match.
+- sb_set refuses `config.revealOnHover` on a node with no such box for the same reason, since the platform emits neither half of the reveal without one and the element would simply stay visible.
+- sb_set now translates `hidden: true` under a hover state into `display: none`, and refuses any other config key or a `false` value, matching the same contract already enforced for the `stuck` state.
+- sb_set warns when a write targets `product-image-list`'s hover state: its meta promises `states.hover`, but measured on 2026-09-09 nothing in the platform compiles it yet, so the override is stored where it belongs and will start painting once the platform closes the gap.
+
 ## [0.10.0] - 2026-09-09
 
 ### Added

package/CHANGELOG.vi.md

@@ -6,6 +6,24 @@ Mọi thay đổi đáng chú ý của dự án được ghi lại trong file n
 Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 và dự án tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.1] - 2026-09-09
+
+### Added
+- sb_review giờ báo cáo `hover_dead` cho một node mà element của nó lưu hover state ở nơi cũ mà chính renderer của nó đọc, thay vì slot `states.hover` phổ quát — ví dụ như `button` — và nêu rõ lệnh sb_set để chuyển giá trị tới đúng nơi sẽ thực sự hiển thị.
+- npm run codegen giờ từ chối chạy trên một checkout web_builder có thay đổi chưa commit trong các thư mục mà nó đọc (schema/src, editor/src, server/render, server/docs), nêu tên các file bẩn thay vì âm thầm đưa công việc dở dang của một phiên làm việc đồng thời vào catalog đã commit; `--dirty` cho phép ghi đè khi bạn tự tạo ra thay đổi đang dở dang đó.
+
+### Fixed
+- Catalog element được sinh lại từ một ref đã commit, loại bỏ một element `cart-count` và chủ sở hữu satellite của nó vốn đã lọt vào từ thay đổi nền tảng chưa commit của một phiên làm việc khác; catalog trở lại 108 element.
+
+## [0.11.0] - 2026-09-09
+
+### Added
+- `state:"hover"` của sb_set giờ định tuyến mỗi lần ghi tới đúng nơi mà renderer của element đó thực sự đọc, vì bộ biên dịch hover phổ quát của nền tảng chủ động đứng ngoài đối với mười hai loại element tự khai báo biến thể Hover riêng; một lần ghi trên `button` giờ vào `config.stateHover` (dạng phẳng, chỉ ở base) thay vì slot `states.hover` không ai đọc, và kết quả trả về cho biết giá trị đã đi vào đâu để người gọi đọc lại node không bị bất ngờ.
+- sb_set từ chối ghi `state:"parentHover"` trên một node không có "hộp" nào để dựa vào — một satellite, một con trực tiếp của root trang, hoặc một node mồ côi — nêu rõ lý do thay vì lưu một rule mà nền tảng sẽ không bao giờ khớp.
+- sb_set từ chối `config.revealOnHover` trên một node không có hộp như vậy vì cùng lý do, vì nền tảng sẽ không phát ra cả hai nửa của hiệu ứng reveal nếu thiếu nó, khiến phần tử đơn giản là luôn hiển thị.
+- sb_set giờ dịch `hidden: true` dưới một hover state thành `display: none`, và từ chối mọi config key khác hoặc giá trị `false`, khớp với đúng quy tắc đã áp dụng cho trạng thái `stuck`.
+- sb_set cảnh báo khi một lần ghi nhắm vào hover state của `product-image-list`: meta của nó hứa hẹn `states.hover`, nhưng đo được vào ngày 2026-09-09 thì chưa có gì trong nền tảng biên dịch nó cả, nên override vẫn được lưu đúng chỗ meta quy định và sẽ bắt đầu hiển thị khi nền tảng khắc phục xong khoảng trống này.
+
 ## [0.10.0] - 2026-09-09
 
 ### Added

package/dist/catalog/elements.generated.js

@@ -33564,6 +33564,11 @@ export const TRAIT_WRITES = {
                 "target": "config",
                 "writeKey": "hidden",
                 "type": "boolean"
+            },
+            {
+                "target": "config",
+                "writeKey": "revealOnHover",
+                "type": "boolean"
             }
         ]
     },
@@ -34600,3 +34605,41 @@ export const ELEMENT_SEEDS = {
 export const FIRST_CHILD_ONLY = [
     "list-dataset"
 ];
+export const HOVER_HOMES = {
+    "button": {
+        "home": "legacy"
+    },
+    "filter-checkbox": {
+        "home": "state"
+    },
+    "filter-color": {
+        "home": "state"
+    },
+    "filter-radio": {
+        "home": "state"
+    },
+    "filter-tag": {
+        "home": "state"
+    },
+    "tab-item": {
+        "home": "state"
+    },
+    "accordion-item": {
+        "home": "state"
+    },
+    "menu-item": {
+        "home": "state"
+    },
+    "product-image-list": {
+        "home": "state"
+    },
+    "quantity-button": {
+        "home": "state"
+    },
+    "product-variant-option": {
+        "home": "state"
+    },
+    "text-dataset": {
+        "home": "state"
+    }
+};

package/dist/domains/site/builder.js

@@ -3,6 +3,7 @@ import { ELEMENTS, ELEMENT_SEEDS, SATELLITE_RULES } from '../../catalog/elements
 import { bindingsForConfig, createNode, mintSatellites } from './node.js';
 import { refuseSecondTemplate } from './traps.js';
 import { STUCK_STATE, refuseStuckAfter, refuseStuckConfig, requireStuckHost, stickySeeds, } from './sticky.js';
+import { HOVER_STATE, PARENT_HOVER_STATE, hoverHome, legacyHoverPath, refuseHoverConfig, refuseReveal, requireHoverHost, } from './hover.js';
 import { genId } from './ids.js';
 /** Append sentinel: splice clamps a too-large index, and `isSyncablePatch`
  *  deliberately allows one — an append is a legitimate thing to describe. */
@@ -186,8 +187,12 @@ export function setKeys(doc, id, keys, opts) {
     // different ways without a word — see sticky.ts. Checked here rather than in
     // the state branch because it is written on the node that PINS, at base or at
     // a breakpoint, never inside a stuck slot.
-    if (namespace === 'config')
+    if (namespace === 'config') {
         refuseStuckAfter(doc.doc, id, keys);
+        // The reveal is a BASE-level config key with a host precondition, so it is
+        // checked here rather than in the state branch — it is not a state at all.
+        refuseReveal(doc.doc, id, keys);
+    }
     // The paths `keys` and `unset` share. Computed once so a removal can never
     // land somewhere a write would not have.
     const slot = () => {
@@ -242,6 +247,32 @@ export function setKeys(doc, id, keys, opts) {
             if (namespace === 'config')
                 refuseStuckConfig(keys);
         }
+        // THE PARENT-HOVER STATE has a host precondition of its own, and a different
+        // one: not "something pins above me" but "I am a real child of a real box".
+        if (opts.state === PARENT_HOVER_STATE && Object.keys(keys).length) {
+            requireHoverHost(doc.doc, id);
+        }
+        if ((opts.state === HOVER_STATE || opts.state === PARENT_HOVER_STATE) &&
+            namespace === 'config' &&
+            Object.keys(keys).length) {
+            refuseHoverConfig(keys, opts.state);
+        }
+        // HOVER HAS THREE HOMES and only one of them is `states.hover`. An element
+        // that declares a Hover variant of its own is served by its own renderer
+        // from a flat, base-only `config.stateHover` map, and the universal compiler
+        // stands aside for it — so writing the state slot here would store keys no
+        // compiler reads. Routed rather than refused: the caller asked for a hover
+        // and there is a home that works; `hoverRoutingNote` says where it went.
+        if (opts.state === HOVER_STATE && namespace === 'style' && hoverHome(doc.node(id).data.type) === 'legacy') {
+            return [
+                ...Object.entries(keys).map(([k, v]) => ({
+                    op: 'set',
+                    path: legacyHoverPath(id, k),
+                    value: v,
+                })),
+                ...(opts.unset ?? []).map((k) => ({ op: 'unset', path: legacyHoverPath(id, k) })),
+            ];
+        }
         // Base state and per-breakpoint state are DIFFERENT PLACES in the document,
         // and the old path (`states[state][bp][ns]`) was neither of them: it buried
         // a breakpoint inside the base-state cluster, where nothing reads it.

package/dist/domains/site/findings.js

@@ -60,6 +60,10 @@ export const FIX = {
         '{ "overflowX": "visible", "overflowY": "visible" } — or move the pinned node outside it. ' +
         'Sticky resolves against its nearest SCROLLING ancestor, so a clipping one becomes that ' +
         'ancestor and the node pins inside a box that never scrolls.',
+    hover_dead: 'Rewrite it: sb_set id "<id>", namespace style, state "hover", keys { … } — sb_set now ' +
+        'routes a hover to the home its element declares, and reports where it went. The values ' +
+        'currently in states.hover are read by nobody; remove them with the same call\'s `unset` ' +
+        'once the working copy is in place.',
     stuck_no_host: 'Pin something: sb_set id "<id>" (or the section it lives in), namespace style, keys ' +
         '{ "position": "sticky" } — sb_set seeds the offset and the layer order with it. Until ' +
         'then the platform compiles no rule for this state at all, so the override is stored, ' +

package/dist/domains/site/hover.js

@@ -0,0 +1,194 @@
+import { HOVER_HOMES } from '../../catalog/elements.generated.js';
+/**
+ * HOVER, AND THE FACT THAT IT HAS THREE HOMES.
+ *
+ * The platform grew a UNIVERSAL hover state in September 2026
+ * (`schema/src/hoverState.ts`, Go mirror `render/style/hover.go`) alongside the
+ * pinned one, and the obvious reading — "hover is `states.hover` now" — is
+ * wrong for twelve element types, silently.
+ *
+ *   states.hover        →  <scope>:hover{…}            the pointer is on THIS
+ *   states.parentHover  →  <host>:hover <scope>{…}     …on the box around this
+ *
+ * But the universal compiler STANDS ASIDE for every element whose meta declares
+ * a Hover variant of its own (`generated.HoverStateOwners`), because those have
+ * their own storage and their own compiler and a second generic rule would fight
+ * the narrower one. For a BUTTON that storage is `config.stateHover` — a flat,
+ * base-only style map — and the editor routes a hover edit there deliberately:
+ * "a hover edit on a button must go on being the button's :hover rule"
+ * (editor/src/trait/values.ts). Nothing reads `states.hover` on a button.
+ *
+ * MEASURED, on one publish of one page: `state:"hover"` on a product card's
+ * dataset-block emitted `@media (hover:hover){#card:hover{…}}`; the identical
+ * write on the BUTTON inside it emitted nothing at all. Both reported success.
+ * Every hover this server had ever written onto a button was dead.
+ *
+ * So the home is a per-type question, and `HOVER_HOMES` is generated from the
+ * metas plus the Go renderers that actually read the legacy map — never
+ * hand-kept, because the platform is still moving here.
+ */
+/** The node's own pointer state. */
+export const HOVER_STATE = 'hover';
+/** "While the box around me is hovered." Universal on every element. */
+export const PARENT_HOVER_STATE = 'parentHover';
+/** The flat, base-only style map a Hover-variant element's own renderer reads. */
+export const LEGACY_HOVER_KEY = 'stateHover';
+/**
+ * The config key behind "only show while the card is hovered". Base-level,
+ * because a state can only override what the base already paints — and, like
+ * the parent state, it needs a host to hover.
+ */
+export const REVEAL_ON_HOVER = 'revealOnHover';
+/**
+ * Where this element type's `hover` state has to be written.
+ *
+ * 'state' is the default and the majority: the universal compiler serves it.
+ */
+/**
+ * Where this element type's `hover` state has to be written.
+ *
+ * 'state' is the default and the overwhelming majority — `node.states.hover`,
+ * compiled either by the universal state or, for the twelve types that declare a
+ * Hover variant, by the element's own CSS. 'legacy' is the flat, base-only
+ * `config.stateHover` map, which is what the element's meta means when it
+ * declares a Hover variant with no `storage: 'node'`.
+ */
+export function hoverHome(type) {
+    return HOVER_HOMES[type]?.home ?? 'state';
+}
+/**
+ * Element types that PROMISE `states.hover` and whose hover nothing compiles.
+ *
+ * Measured 2026-09-09 by rendering one node per Hover-variant type with a
+ * `states.hover` override and looking for the value in `BundleCSS`: every other
+ * type painted, `product-image-list` did not. Its meta declares
+ * `storage: 'node'`, so the value goes where the meta says — and the universal
+ * compiler stands aside for it, while nothing element-specific picks it up.
+ *
+ * A LIST, not a derivation, because there is nothing in the metas to derive it
+ * from: the fact lives in which Go renderer happens to read the slot. It is
+ * therefore a measurement with a date on it, and the note says so rather than
+ * pretending the platform still behaves this way.
+ */
+const HOVER_UNCOMPILED = new Set(['product-image-list']);
+/**
+ * The box whose `:hover` a parent-hover rule keys off, or null.
+ *
+ * Mirrors `HoverHostOf`: the node's PARENT, and only when the node is a real
+ * child of it. Three cases answer null, and each is a rule that would compile to
+ * nothing:
+ *
+ *   - a SATELLITE, which hangs off `config[key]` rather than `data.nodes` and
+ *     renders no element the selector could name;
+ *   - a node whose parent is ROOT, because the pointer is inside the page
+ *     whenever it is inside the window;
+ *   - an orphan whose parent id points at nothing.
+ */
+export function hoverHostOf(doc, id) {
+    const node = doc.nodes[id];
+    const parentId = node?.data.parent;
+    if (!node || !parentId)
+        return null;
+    const parent = doc.nodes[parentId];
+    if (!parent || !(parent.data.nodes ?? []).includes(id))
+        return null;
+    if (parent.data.type === 'root' || parentId === doc.root_node_id)
+        return null;
+    return parentId;
+}
+/** Is this node a satellite — referenced from its parent's config, not its children? */
+export function isSatelliteNode(doc, id) {
+    const parentId = doc.nodes[id]?.data.parent;
+    if (!parentId)
+        return false;
+    const parent = doc.nodes[parentId];
+    return !!parent && !(parent.data.nodes ?? []).includes(id);
+}
+/**
+ * Refuse a parent-hover override that no selector would ever match, naming which
+ * of the three reasons applies — the caller is one structural fact away from the
+ * design they wanted, and "it does nothing" would not tell them which.
+ */
+export function requireHoverHost(doc, id) {
+    if (hoverHostOf(doc, id))
+        return;
+    if (isSatelliteNode(doc, id)) {
+        throw new Error(`sbuilder: "${PARENT_HOVER_STATE}" needs a box to hover, and ${id} is a SATELLITE — it ` +
+            'hangs off its owner\'s config rather than its children and renders no element of its ' +
+            'own, so there is nothing for the rule to name. Style its own hover instead ' +
+            `(state: "${HOVER_STATE}"), which its owner compiles.`);
+    }
+    const parentId = doc.nodes[id]?.data.parent;
+    if (!parentId) {
+        throw new Error(`sbuilder: ${id} has no parent, so "${PARENT_HOVER_STATE}" has nothing to key off.`);
+    }
+    throw new Error(`sbuilder: "${PARENT_HOVER_STATE}" keys off the node's PARENT, and ${id}'s parent is ROOT — ` +
+        'the pointer is inside the page whenever it is inside the window, so the platform emits ' +
+        'no rule. Put this node inside a real box (a section\'s inner block, a card) and set it ' +
+        `there, or use state: "${HOVER_STATE}" for the node's own pointer state.`);
+}
+/**
+ * The one config key a hover state translates into a declaration, and only
+ * `true` — the same contract `stuckDecls` has, for the same reason: `false`
+ * would need `display: revert`, which rolls past the element's own static CSS to
+ * the UA default.
+ */
+export function refuseHoverConfig(keys, state) {
+    const stray = Object.keys(keys).filter((k) => k !== 'hidden');
+    if (stray.length) {
+        throw new Error(`sbuilder: the "${state}" state translates exactly one config key — "hidden" — into a ` +
+            `declaration (display:none). ${stray.map((k) => `"${k}"`).join(', ')} would be stored ` +
+            'and read by no compiler. Style is what a state paints.');
+    }
+    if ('hidden' in keys && keys.hidden !== true) {
+        throw new Error(`sbuilder: "${state}" config.hidden takes only true. false would have to mean "show it ` +
+            'again while hovered", which needs display:revert — wrong here, because revert rolls ' +
+            "past the element's own static CSS to the UA default. To stop hiding it, remove the " +
+            'override.');
+    }
+}
+/**
+ * Refuse a reveal that compiles to nothing.
+ *
+ * `compileHoverCss` emits the reveal pair only `if (hostScope && …)`, so the
+ * switch on a satellite or a top-level section is stored and the element simply
+ * stays visible — the caller asked for a quick-add button that appears on hover
+ * and got one that is always there, with nothing to say so.
+ */
+export function refuseReveal(doc, id, keys) {
+    if (keys[REVEAL_ON_HOVER] !== true)
+        return;
+    if (hoverHostOf(doc, id))
+        return;
+    throw new Error(`sbuilder: config.${REVEAL_ON_HOVER} hides this until the box AROUND it is hovered, and ` +
+        `${id} has no such box (a satellite, or a direct child of ROOT). The platform emits ` +
+        'neither half of the reveal, so the element would simply stay visible. Put it inside a ' +
+        'card or a block and set it there.');
+}
+/**
+ * The note a caller gets when a hover write is routed somewhere other than
+ * `states.hover`, and the warning when nothing will read it either way.
+ *
+ * Said rather than silently done: the routing is right, but a caller who later
+ * reads the node back would otherwise find their keys somewhere they did not put
+ * them.
+ */
+export function hoverRoutingNote(type) {
+    if (HOVER_UNCOMPILED.has(type)) {
+        return (`"${type}" declares a Hover variant, so the platform's universal hover compiler stands ` +
+            'aside for it — and measured on 2026-09-09, no element-specific compiler picks the slot ' +
+            'up either, so this override paints nothing. Written where its meta says it belongs ' +
+            '(states.hover), which is where it will start painting when the platform closes the gap. ' +
+            'Style a wrapper around it if the hover has to be visible now.');
+    }
+    if (hoverHome(type) !== 'legacy')
+        return null;
+    return (`"${type}" stores its hover in config.${LEGACY_HOVER_KEY} — a flat map its own renderer ` +
+        'compiles into the node\'s :hover rule — and the universal hover state stands aside for it, ' +
+        'so states.hover here would be read by nobody. Written to that map instead. It is BASE-ONLY, ' +
+        'so this value applies at every width.');
+}
+/** The path a legacy hover write lands on — flat, base-only, one key per patch. */
+export function legacyHoverPath(id, key) {
+    return ['nodes', id, 'config', LEGACY_HOVER_KEY, key];
+}

package/dist/domains/site/review.js

@@ -1,5 +1,6 @@
 import { childrenOf, childrenWithSatellites, isOverlay, pageChildren, appBlockRoot, SPEC_GLOBAL_REF, SPEC_APP_BLOCK_REF } from '../../core/tree.js';
 import { STUCK_STATE, stickyBlockedBy, stuckHostOf, isPinnedNode } from './sticky.js';
+import { HOVER_STATE, hoverHome } from './hover.js';
 import { ELEMENTS, BINDING_SOURCES, BOUND_SPECIALS, FIRST_CHILD_ONLY, SATELLITE_RULES, ELEMENT_SEEDS } from '../../catalog/elements.generated.js';
 import { fill } from './findings.js';
 /**
@@ -224,6 +225,32 @@ export function reviewDesign(doc) {
             styled.states?.[STUCK_STATE],
             ...Object.values(styled.responsive ?? {}).map((r) => r?.states?.[STUCK_STATE]),
         ];
+        // A HOVER STORED WHERE NOBODY READS IT. The universal hover state is not the
+        // only home: an element whose meta declares a Hover variant keeps it
+        // somewhere its own renderer looks, and for a `button` that is the flat
+        // `config.stateHover` map. Every hover this server wrote onto a button
+        // before it learned that is still sitting in `states.hover`, painting
+        // nothing — on a control that is the single most common thing anyone gives
+        // a hover to.
+        const hoverSlots = [
+            styled.states?.[HOVER_STATE],
+            ...Object.values(styled.responsive ?? {}).map((r) => r?.states?.[HOVER_STATE]),
+        ];
+        const hasHover = hoverSlots.some((slot) => {
+            const h = slot;
+            return !!h && (Object.keys(h.style ?? {}).length > 0 || Object.keys(h.config ?? {}).length > 0);
+        });
+        if (hasHover && hoverHome(type) === 'legacy') {
+            out.push({
+                code: 'hover_dead',
+                nodeId: id,
+                type,
+                problem: `"${type}" keeps its hover in config.stateHover — the flat map its own renderer ` +
+                    'compiles — and the platform\'s universal hover compiler stands aside for it. These ' +
+                    'states.hover values are stored, saved, published and painted by nobody.',
+                fix: fill('hover_dead', { id }),
+            });
+        }
         const hasStuck = stuckSlots.some((slot) => {
             const s = slot;
             return !!s && (Object.keys(s.style ?? {}).length > 0 || Object.keys(s.config ?? {}).length > 0);

package/dist/tools/page.js

@@ -15,6 +15,7 @@ import { globalWarning, restampPatches, RESPONSIVE_NOTICE } from '../domains/sit
 import { catalogMatches, traitsFor } from '../catalog/element-search.js';
 import { applyPatches } from '../core/patch.js';
 import { stickyWarning } from '../domains/site/sticky.js';
+import { HOVER_STATE, hoverRoutingNote } from '../domains/site/hover.js';
 import { siteFor } from './context.js';
 import { projectList, PAGE_FIELDS, TEMPLATE_FIELDS } from './project.js';
 /**
@@ -303,6 +304,18 @@ export function registerPageTools(server, ctx) {
             batch.push({ id, namespace, keys: keys ?? {}, breakpoint: breakpoint, base, state, unset });
         }
         const { patches, touched } = setMany(d, batch);
+        // WHERE A HOVER ACTUALLY WENT. Routing it silently would leave a caller
+        // who reads the node back looking for keys in a slot they never wrote to —
+        // and, for the elements with no compiler on either home, believing they
+        // had styled something.
+        const hoverNotes = {};
+        for (const e of batch) {
+            if (e.state !== HOVER_STATE || e.namespace !== 'style')
+                continue;
+            const note = hoverRoutingNote(d.doc.nodes[e.id]?.data.type ?? '');
+            if (note)
+                hoverNotes[e.id] = note;
+        }
         // THE STICKY WARNING IS COMPUTED AGAINST THE DOCUMENT AS IT WILL BE, so
         // the dry run and the real run say the same thing. A caller who is told
         // only after committing has already shipped a header that does not move.
@@ -333,6 +346,7 @@ export function registerPageTools(server, ctx) {
                 dry_run: true,
                 patches,
                 ...(Object.keys(sw).length ? { warnings: sw } : {}),
+                ...(Object.keys(hoverNotes).length ? { hover: hoverNotes } : {}),
                 ...(note ? { note } : {}),
             });
         }
@@ -346,9 +360,20 @@ export function registerPageTools(server, ctx) {
         }
         if (!edits) {
             const warn = warnings[batch[0].id];
-            return text({ set: touched[0].keys, rev: d.rev, ...(warn ? { warning: warn } : {}) });
+            const hv = hoverNotes[batch[0].id];
+            return text({
+                set: touched[0].keys,
+                rev: d.rev,
+                ...(warn ? { warning: warn } : {}),
+                ...(hv ? { hover: hv } : {}),
+            });
         }
-        return text({ set: touched, rev: d.rev, ...(Object.keys(warnings).length ? { warnings } : {}) });
+        return text({
+            set: touched,
+            rev: d.rev,
+            ...(Object.keys(warnings).length ? { warnings } : {}),
+            ...(Object.keys(hoverNotes).length ? { hover: hoverNotes } : {}),
+        });
     });
     server.registerTool('sb_move', {
         description: 'Move a node to another parent at an index.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sbuilder-mcp",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "MCP server that designs and operates a Store Builder site — pages, data, theme and publish — through the platform's own API and live-edit protocol.",
   "mcpName": "io.github.vuluu2k/sbuilder-mcp",
   "type": "module",