@ptengine/inline-editor 0.1.5 → 0.1.7

package/dist/kernel/changelist/useChangeList.js

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { applyChange, revertChange } from '../canvasCommands.js';
 import { overrideOutcome } from './overrides.js';
 import { backgroundImageValue, buildInsertImageHtml, randomPtElementId } from '../../dialogs/imageEdit.js';
@@ -16,6 +16,16 @@ function withResolvedStyleMode(change, applied) {
 }
 export function useChangeList(sessionId, options = {}) {
     const [list, setList] = useState([]);
+    const past = useRef([]);
+    const future = useRef([]);
+    const [, refreshHistory] = useState(0);
+    const resetHistory = useCallback(() => {
+        past.current = [];
+        future.current = [];
+        refreshHistory(n => n + 1);
+    }, []);
+    useEffect(resetHistory, [sessionId, resetHistory]);
+    const mutationQueue = useRef(Promise.resolve());
     const [lastError, setLastError] = useState(null);
     const listRef = useRef([]);
     listRef.current = list;
@@ -50,7 +60,9 @@ export function useChangeList(sessionId, options = {}) {
         const stored = withResolvedStyleMode(change, applied);
         const ancestorsByChange = new Map(prev.map(r => [r.change, r.ancestors]));
         const insertedByChange = new Map(prev.map(r => [r.change, r.insertedSelectors]));
-        const insertedNow = applied.insertedSelectors?.length ? applied.insertedSelectors : undefined;
+        const insertedNow = applied.insertedSelectors?.length
+            ? applied.insertedSelectors
+            : undefined;
         const nextRecords = nextChanges.map(c => {
             const inserted = c === change ? insertedNow : insertedByChange.get(c);
             return {
@@ -99,15 +111,71 @@ export function useChangeList(sessionId, options = {}) {
         reportRestored(records);
         return { applied: records.length - failed.length, failed };
     }, [sessionId, reportRestored]);
-    const guard = useCallback(async (run) => {
+    const guard = useCallback((run, record = true) => {
+        const next = mutationQueue.current.then(async () => {
+            const before = listRef.current;
+            try {
+                const result = await run();
+                if (record && before !== listRef.current) {
+                    past.current.push({ before, after: listRef.current });
+                    future.current = [];
+                    refreshHistory(n => n + 1);
+                }
+                setLastError(null);
+                return result;
+            }
+            catch (e) {
+                setLastError(String(e?.message ?? e));
+                throw e;
+            }
+        });
+        mutationQueue.current = next.catch(() => { });
+        return next;
+    }, []);
+    const restoreSnapshot = useCallback(async (snapshot) => {
+        if (!sessionId)
+            throw new Error('no canvas session');
+        const current = listRef.current;
+        for (const record of [...current].reverse()) {
+            await revertChange(sessionId, record.changeId).catch(() => { });
+        }
+        reportRemoved(current);
+        listRef.current = [];
+        setList([]);
+        for (const record of snapshot) {
+            const applied = await applyChange(sessionId, record.changeId, record.change);
+            const restored = {
+                ...record,
+                change: withResolvedStyleMode(record.change, applied),
+                ...(applied?.insertedSelectors?.length
+                    ? { insertedSelectors: applied.insertedSelectors }
+                    : {})
+            };
+            listRef.current = [...listRef.current, restored];
+            setList(listRef.current);
+            reportRestored([restored]);
+        }
+    }, [sessionId, reportRemoved, reportRestored]);
+    const travelHistory = useCallback((direction) => guard(async () => {
+        const source = direction === 'undo' ? past.current : future.current;
+        const target = direction === 'undo' ? future.current : past.current;
+        const entry = source.at(-1);
+        if (!entry)
+            return;
+        const current = listRef.current;
         try {
-            return await run();
+            await restoreSnapshot(direction === 'undo' ? entry.before : entry.after);
         }
-        catch (e) {
-            setLastError(String(e?.message ?? e));
-            throw e;
+        catch (error) {
+            await restoreSnapshot(current);
+            throw error;
         }
-    }, []);
+        source.pop();
+        target.push(entry);
+        refreshHistory(n => n + 1);
+    }, false), [guard, restoreSnapshot]);
+    const undo = useCallback(() => travelHistory('undo'), [travelHistory]);
+    const redo = useCallback(() => travelHistory('redo'), [travelHistory]);
     const addStyle = useCallback((input) => guard(() => push(buildStyleChange(input), input.ancestors)), [guard, push]);
     const addContent = useCallback((input) => guard(() => push(buildContentChange(input), input.ancestors)), [guard, push]);
     const addAttribute = useCallback((input) => guard(() => push(buildAttributeChange(input), input.ancestors)), [guard, push]);
@@ -158,14 +226,16 @@ export function useChangeList(sessionId, options = {}) {
                     idMap.set(old, nextRecords[i].changeId);
             }
         }
+        resetHistory();
         return { previous, outcome, idMap };
-    }, [hydrate, revertAll, sessionId]);
+    }, [hydrate, revertAll, sessionId, resetHistory]);
     const peekList = useCallback(() => listRef.current, []);
     const clear = useCallback(() => {
+        resetHistory();
         listRef.current = [];
         setList([]);
         setLastError(null);
-    }, []);
+    }, [resetHistory]);
     return {
         list,
         changes: list.map(r => r.change),
@@ -179,7 +249,12 @@ export function useChangeList(sessionId, options = {}) {
         clear,
         hydrate,
         replaceAll,
+        whenIdle: () => mutationQueue.current,
         peekList,
+        canUndo: past.current.length > 0,
+        canRedo: future.current.length > 0,
+        undo,
+        redo,
         lastError
     };
 }

package/dist/kernel/selection/SelectionOverlay.js

@@ -9,7 +9,7 @@ function rectStyle(rect) {
         width: `${rect.width}px`,
         height: `${rect.height}px`,
         boxSizing: 'border-box',
-        zIndex: 2147483000
+        zIndex: 900
     };
 }
 export function SelectionOverlay({ geometry, context, selectedLabel }) {

package/dist/kernel/selection/SelectionToolbar.js

@@ -2,7 +2,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useLayoutEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Camera, ClipboardPaste, Code, Copy, ImageIcon, MousePointerClick, Move, Paintbrush, Pencil, Plus, Settings2, Sparkles, Trash2, Video } from 'lucide-react';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@ptengine/design-components';
+import { Button, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@ptengine/design-components';
 import { SELECTION_CLASS } from '../../canvas-ui/index.js';
 import { visibleButtons } from './toolbarButtons.js';
 const TOOLBAR_HEIGHT = 34;
@@ -23,7 +23,7 @@ const TOOLBAR_ICONS = {
     delete: Trash2,
     sparkles: Sparkles
 };
-const ICON_SIZE = 15;
+const ICON_SIZE = 16;
 const ICON_STROKE_WIDTH = 1.75;
 const TOOLTIP_DELAY = 200;
 export function computeToolbarPosition(rect, area, width) {
@@ -51,6 +51,7 @@ export function computeToolbarPosition(rect, area, width) {
 export function SelectionToolbar({ host = {}, selectedRect, area, capabilities, isScrolling, onAction, width = 240 }) {
     const { t } = useTranslation();
     const barRef = useRef(null);
+    const [focusIndex, setFocusIndex] = useState(0);
     const [measuredWidth, setMeasuredWidth] = useState(null);
     useLayoutEffect(() => {
         const measured = barRef.current?.offsetWidth ?? 0;
@@ -63,20 +64,37 @@ export function SelectionToolbar({ host = {}, selectedRect, area, capabilities,
     if (buttons.length === 0)
         return null;
     const { left, top } = computeToolbarPosition(selectedRect, area, measuredWidth ?? width);
-    return (_jsx("div", { ref: barRef, "data-testid": "canvas-selection-toolbar", className: SELECTION_CLASS.toolbar, style: {
+    return (_jsx("div", { ref: barRef, role: "toolbar", "aria-label": t('inlineCanvas.toolbar.label', '元素操作'), onKeyDown: e => {
+            const items = Array.from(barRef.current?.querySelectorAll('button:not(:disabled)') ??
+                []);
+            const current = items.indexOf(document.activeElement);
+            let next = current;
+            if (e.key === 'ArrowRight')
+                next = (current + 1) % items.length;
+            else if (e.key === 'ArrowLeft')
+                next = (current - 1 + items.length) % items.length;
+            else if (e.key === 'Home')
+                next = 0;
+            else if (e.key === 'End')
+                next = items.length - 1;
+            else
+                return;
+            e.preventDefault();
+            setFocusIndex(next);
+            items[next]?.focus();
+        }, "data-testid": "canvas-selection-toolbar", className: SELECTION_CLASS.toolbar, style: {
             position: 'fixed',
             left: `${left}px`,
             top: `${top}px`,
             transform: 'none',
-            zIndex: 2147483001
-        }, children: _jsx(TooltipProvider, { delayDuration: TOOLTIP_DELAY, children: buttons.map(button => {
+            zIndex: 901
+        }, children: _jsx(TooltipProvider, { delayDuration: TOOLTIP_DELAY, children: buttons.map((button, index) => {
                 const label = t(button.labelKey);
                 const Icon = TOOLBAR_ICONS[button.icon];
                 const isAi = button.id === 'ask-ai';
-                const className = `${SELECTION_CLASS.tool}${button.id === 'delete' ? ` ${SELECTION_CLASS.toolDanger}` : ''}${isAi ? ` ${SELECTION_CLASS.toolAi}` : ''}`;
                 if (isAi) {
-                    return (_jsxs("button", { type: "button", "data-testid": `canvas-toolbar-${button.id}`, className: className, onClick: () => onAction(button.id), children: ["\u2726 ", label] }, button.id));
+                    return (_jsxs(Button, { type: "button", "data-testid": `canvas-toolbar-${button.id}`, size: isAi ? 'sm' : 'icon-sm', variant: button.id === 'delete' ? 'destructive' : 'ghost', tabIndex: index === Math.min(focusIndex, buttons.length - 1) ? 0 : -1, onClick: () => onAction(button.id), children: ["\u2726 ", label] }, button.id));
                 }
-                return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx("button", { type: "button", "data-testid": `canvas-toolbar-${button.id}`, "aria-label": label, className: className, onClick: () => onAction(button.id), children: _jsx(Icon, { size: ICON_SIZE, strokeWidth: ICON_STROKE_WIDTH, "aria-hidden": true }) }) }), _jsx(TooltipContent, { className: "z-[2147483003]", children: label })] }, button.id));
+                return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsx(Button, { type: "button", "data-testid": `canvas-toolbar-${button.id}`, "aria-label": label, size: isAi ? 'sm' : 'icon-sm', variant: button.id === 'delete' ? 'destructive' : 'ghost', tabIndex: index === Math.min(focusIndex, buttons.length - 1) ? 0 : -1, onClick: () => onAction(button.id), children: _jsx(Icon, { size: ICON_SIZE, strokeWidth: ICON_STROKE_WIDTH, "aria-hidden": true }) }) }), _jsx(TooltipContent, { children: label })] }, button.id));
             }) }) }));
 }

package/dist/kernel/selection/buildRootShelf.d.ts

@@ -7,7 +7,25 @@
  *
  * 这里改成按**几何**挑区块：新 agent 的树带 `rect`（文档坐标）/ `hidden` / `heading`
  * （`getDomTree` 的 `includeRect` / `visibleOnly`），于是能先找出「够高、够宽」的可见区块，
- * 每块给 1 行容器 + 最多几行可改点，header/nav/footer 各封顶，隐藏节点一律不给。
+ * 每块给 1 行容器 + 几行可改点，header/nav/footer 各封顶，隐藏节点一律不给。
+ *
+ * **哪一层算「一个区块」**（2026-10-21 重写）：`after` X 落在 X 的父级里，按父级怎么排孩子
+ * 摆放。「X 下面插入」要落在 X 正下方，X 的父级就得是**上下堆叠区块**的那一层 —— 所以块根 =
+ * 「只装着这一个区块的最外层容器」：
+ *   · 父级横排（轮播的每一张、并列的列）里的大项不单独成块，连同子树归外层；
+ *   · 装着 ≥2 个候选区块 = 外壳，拆开；只装着 1 个 = 它自己就是这一块（外层赢，小圆点、
+ *     进度条这些附属部件都在最外层里），但占页高 ≥60% 的单链节点是整页的框，让给内层；
+ *   · 宿主给了页面模型（`blocks`）时，成员归属校正拆合，并在块根行写 `blockId`。
+ *
+ * **矮区块**（2026-10-21）：几何门槛（高 ≥120）挡掉了真正的矮区块 —— vivaia 手机首页的新闻区只有 86px，
+ * 父级是外壳，它既不是块根也不在块根里，只能等回填，100 行用完时它的标题还没轮到，「把新闻区标题改成…」
+ * 两次被拒、0 处落地。门槛本身不降（降了，section 里的标题条也成候选，section 被拆成外壳）。补两条：
+ *   · 页面模型的成员容器只要够宽就是候选，不看高度（热图说它是一块，它就是一块）；
+ *   · 块根的父级就是区块上下叠放的那一层：那里不够高、但够宽、有内容、不在 header/nav/footer 里的孩子，
+ *     也算一块（没有页面模型时的兜底）。
+ * 旧规则「内层有 heading 就赢」不可用：kit 的 `heading` 是**子树里**第一个标题（没有就取第一段
+ * 文字），section / 轮播轨道 / 每张幻灯片拿到的是同一句，规则又偏向内层 —— 真机 vivaia 首页的
+ * 首屏只剩三张幻灯片，模型照「首屏下面」插进了轮播（2026-10-20）。
  *
  * **兼容**：树上一个 `rect` 都没有 = 老 agent，整个函数退化成老算法，逐项一致。
  *
@@ -15,11 +33,47 @@
  * 里的项。MOVE 闸靠这张表判 target 是不是被移元素的祖先，两边一旦漂移就是「同一个
  * selector 有时能移有时不能，且不报错」（见 buildDescendantShelf 头部说明）。
  */
-import type { DomTreeNode } from '@ptengine/inline-core/protocol';
+import type { DomTreeNode, GetDomTreeParams } from '@ptengine/inline-core/protocol';
 import { type AiDescendant } from './elementAiContext.js';
+/**
+ * 整页货架取树的口径（`getDomTree`，以 body 为根）。编辑器的整页货架与分析路径的成员上提（`resolveBlocks`）
+ * 用**同一份**：块根判据吃的是几何与排法，两边取的树不一样，认出来的块根就可能不一样。
+ *
+ * 树要**深、宽、带几何**：真实站点的内容区块常在 `body > #root > .page > main > div > div > section`
+ * 第 6-7 层，`maxDepth: 4` 根本到不了；`visibleOnly` 把抽屉 / 隐藏菜单整棵剔掉（它们此前把货架吃光），
+ * `includeRect` 给块根判据按高度 / 宽度挑区块用。`maxNodes` 是总量安全阀（1500 个节点的 JSON 仍在一次
+ * sendMessage 的舒适范围内）。老 agent 不认识这几个字段会静默忽略 —— 树上就没有 `rect`，退回老算法。
+ */
+export declare const ROOT_SHELF_TREE_PARAMS: Readonly<Omit<GetDomTreeParams, 'command' | 'sessionId'>>;
+/**
+ * 页面模型的一个区块（热图区块配置解析出来的），只要 id 与成员容器的 selector。
+ * 与宿主的 `PageModelBlock` / `InlinePageBlock` 结构兼容，宿主原样传进来即可。
+ */
+export interface ShelfBlockHint {
+    id: string;
+    members: ReadonlyArray<{
+        selector: string;
+    }>;
+}
+/**
+ * 页面模型的成员 → 它所在的块根：整页货架上写着这个区块 `blockId` 的那一行（同一份判定）。
+ * 返回 区块 id → 成员 selector → 块根节点（输入树上的那个节点）。
+ *
+ * 分析路径（`resolveBlocks` → `<page-block>` → 方案锚点 → 首版 `anchors:`）此前用热图成员原样：真机
+ * vivaia 首页 B1 的成员是轮播第 1 张，方案锚点照抄它，首版 after 它就把「首屏下方」的新模块插进了轮播 ——
+ * 而编辑器货架上 `[B1]` 已经在整个首屏 section 上（2026-10-21）。两条路认块必须是同一个结果。
+ *
+ * 只提到「是成员自己或成员祖先、且只装着这一个区块」的块根。提不了的不进表，调用方保持原成员：
+ * 成员不在树上（截断 / 另一端版式）、所在容器还装着别的区块（两张幻灯片各是一块）、老 agent 没有几何。
+ */
+export declare function liftToBlockRoots(root: DomTreeNode, opts: {
+    viewportWidth?: number;
+    blocks: ReadonlyArray<ShelfBlockHint>;
+}): Map<string, Map<string, DomTreeNode>>;
 export declare function buildRootShelf(root: DomTreeNode, opts: {
     limit: number;
     viewportWidth?: number;
+    blocks?: ReadonlyArray<ShelfBlockHint>;
 }): {
     shelf: AiDescendant[];
     ancestorsOf: Map<string, string[]>;

package/dist/kernel/selection/buildRootShelf.js

@@ -1,16 +1,27 @@
 import { buildDescendantShelfWithPaths } from './buildDescendantShelf.js';
 import { AI_DESCENDANT_TEXT_CHARS } from './elementAiContext.js';
-import { rowPositions } from './rowLayout.js';
+import { SHELF_LAYOUT_FIELDS, laysOutInRow, rowPositions } from './rowLayout.js';
+export const ROOT_SHELF_TREE_PARAMS = {
+    rootSelector: 'body',
+    maxDepth: 16,
+    maxChildren: 40,
+    maxNodes: 1500,
+    visibleOnly: true,
+    includeRect: true,
+    fields: [...SHELF_LAYOUT_FIELDS]
+};
 const LANDMARK_MIN_HEIGHT = 120;
 const LANDMARK_MIN_WIDTH_RATIO = 0.5;
 const DEFAULT_VIEWPORT_WIDTH = 375;
 const LEAVES_PER_LANDMARK = 6;
+const PAGE_SCALE_RATIO = 0.6;
+const SAME_TOP_PX = 2;
 const CHROME_ROWS_CAP = 5;
-const PREFERRED_LANDMARK_TAGS = new Set(['main', 'section', 'article']);
 const CHROME_TAGS = new Set(['header', 'nav', 'footer']);
 const TEXT_LEAF_TAGS = new Set(['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'button', 'span']);
-export function buildRootShelf(root, opts) {
-    const { limit } = opts;
+const isTextLeaf = (n) => n.tag === 'img' || (TEXT_LEAF_TAGS.has(n.tag) && n.textSummary.trim().length > 0);
+const hasContent = (n) => isTextLeaf(n) || !!n.image || n.textSummary.trim().length > 0 || n.children.some(c => !c.hidden && hasContent(c));
+function analyzeBlockRoots(root, opts) {
     const viewportWidth = typeof opts.viewportWidth === 'number' && opts.viewportWidth > 0
         ? opts.viewportWidth
         : DEFAULT_VIEWPORT_WIDTH;
@@ -19,7 +30,7 @@ export function buildRootShelf(root, opts) {
     const entryOf = new Map();
     let sawRect = root.rect !== undefined;
     const isLandmarkNode = (n) => n.rect !== undefined && n.rect.height >= LANDMARK_MIN_HEIGHT && n.rect.width >= minWidth;
-    const visit = (n, ancestors, chromeKey, nearestLandmark) => {
+    const visit = (n, parent, ancestors, chromeKey) => {
         for (const child of n.children) {
             if (child.hidden)
                 continue;
@@ -28,53 +39,186 @@ export function buildRootShelf(root, opts) {
             const ownChrome = CHROME_TAGS.has(child.tag) ? child.selector : chromeKey;
             const entry = {
                 node: child,
+                parent,
                 ancestors,
                 order: entries.length,
                 chromeKey: ownChrome,
-                nearestLandmark,
-                isLandmark: isLandmarkNode(child)
+                landmark: isLandmarkNode(child),
+                demoted: false
             };
             entries.push(entry);
             entryOf.set(child, entry);
-            visit(child, [child.selector, ...ancestors], ownChrome, entry.isLandmark ? entry : nearestLandmark);
+            visit(child, entry, [child.selector, ...ancestors], ownChrome);
         }
     };
-    visit(root, [root.selector], null, null);
+    visit(root, null, [root.selector], null);
     if (!sawRect)
-        return buildDescendantShelfWithPaths(root, limit);
-    const beaten = new Set();
-    const absorbed = new Set();
-    for (const e of entries) {
-        if (!e.isLandmark || !e.nearestLandmark)
-            continue;
-        const outer = e.nearestLandmark;
-        const wins = !!e.node.heading ||
-            (PREFERRED_LANDMARK_TAGS.has(e.node.tag) && !PREFERRED_LANDMARK_TAGS.has(outer.node.tag));
-        if (wins)
-            beaten.add(outer);
+        return null;
+    const pageHeight = entries.reduce((h, e) => (e.node.rect ? Math.max(h, e.node.rect.top + e.node.rect.height) : h), root.rect?.height ?? 0);
+    const isPageScale = (n) => n.rect !== undefined && pageHeight > 0 && n.rect.height >= PAGE_SCALE_RATIO * pageHeight;
+    const isLandmarkRow = (parent) => {
+        const items = parent.children.filter(c => !c.hidden && isLandmarkNode(c));
+        if (items.length < 2 || items.some(isPageScale))
+            return false;
+        if (laysOutInRow(parent))
+            return true;
+        const top0 = items[0].rect.top;
+        return items.every(c => Math.abs(c.rect.top - top0) <= SAME_TOP_PX);
+    };
+    const rowParents = new Map();
+    const inLandmarkRow = (parent) => {
+        let v = rowParents.get(parent);
+        if (v === undefined)
+            rowParents.set(parent, (v = isLandmarkRow(parent)));
+        return v;
+    };
+    for (const e of entries)
+        e.demoted = (e.parent?.demoted ?? false) || inLandmarkRow(e.parent?.node ?? root);
+    if (entries.some(e => e.landmark) && !entries.some(e => e.landmark && !e.demoted)) {
+        for (const e of entries)
+            e.demoted = false;
+    }
+    const entryBySelector = new Map();
+    for (const e of entries)
+        if (!entryBySelector.has(e.node.selector))
+            entryBySelector.set(e.node.selector, e);
+    const memberBoxes = new Set();
+    for (const b of opts.blocks ?? []) {
+        for (const member of b.members) {
+            const e = entryBySelector.get(member.selector);
+            const r = e?.node.rect;
+            if (e && r && r.height > 0 && r.width >= minWidth)
+                memberBoxes.add(e);
+        }
+    }
+    const isCandidate = (e) => (e.landmark || memberBoxes.has(e)) && !e.demoted;
+    const claimed = new Map();
+    const blocksIn = new Map();
+    const memberEntries = new Set();
+    const addTo = (m, e, id) => {
+        let set = m.get(e);
+        if (!set)
+            m.set(e, (set = new Set()));
+        set.add(id);
+    };
+    for (const b of opts.blocks ?? []) {
+        for (const member of b.members) {
+            const own = entryBySelector.get(member.selector);
+            if (!own)
+                continue;
+            memberEntries.add(own);
+            for (let a = own; a; a = a.parent)
+                addTo(blocksIn, a, b.id);
+            let e = own;
+            while (e && !isCandidate(e))
+                e = e.parent;
+            if (e)
+                addTo(claimed, e, b.id);
+        }
+    }
+    const modelBlockCount = (e) => blocksIn.get(e)?.size ?? 0;
+    const isAtomic = (e) => claimed.get(e)?.size === 1 && modelBlockCount(e) === 1;
+    const nearestCandidateAncestor = (e) => {
+        for (let a = e.parent; a; a = a.parent)
+            if (isCandidate(a))
+                return a;
+        return null;
+    };
+    const kids = new Map();
+    const tops = [];
+    const candidates = entries.filter(isCandidate);
+    for (const e of candidates) {
+        const p = nearestCandidateAncestor(e);
+        if (p) {
+            const list = kids.get(p) ?? [];
+            list.push(e);
+            kids.set(p, list);
+        }
+        else
+            tops.push(e);
+    }
+    const isUnit = new Map();
+    for (const e of [...candidates].reverse()) {
+        const ks = kids.get(e) ?? [];
+        let unit;
+        if (isAtomic(e) && (memberEntries.has(e) || ks.length < 2))
+            unit = true;
+        else if (modelBlockCount(e) >= 2)
+            unit = ks.length === 0;
+        else if (ks.length === 0)
+            unit = true;
+        else if (ks.length >= 2)
+            unit = false;
         else
-            absorbed.add(e);
+            unit = (isUnit.get(ks[0]) ?? false) && !isPageScale(e.node);
+        isUnit.set(e, unit);
     }
-    const surviving = new Set();
-    for (const e of entries) {
-        if (!e.isLandmark || beaten.has(e))
+    const blockRoots = [];
+    const takeRoots = (list) => {
+        for (const e of list) {
+            if (isUnit.get(e))
+                blockRoots.push(e);
+            else
+                takeRoots(kids.get(e) ?? []);
+        }
+    };
+    takeRoots(tops);
+    const rootSet = new Set(blockRoots);
+    const holdsRoot = new Set();
+    for (const r of blockRoots)
+        for (let a = r.parent; a; a = a.parent)
+            holdsRoot.add(a);
+    const layers = new Set(blockRoots.map(r => r.parent?.node ?? root));
+    for (const layer of layers) {
+        if (laysOutInRow(layer))
             continue;
-        if (absorbed.has(e)) {
-            let a = e.nearestLandmark;
-            let hasSurvivingAncestor = false;
-            while (a) {
-                if (surviving.has(a)) {
-                    hasSurvivingAncestor = true;
-                    break;
+        for (const child of layer.children) {
+            const e = entryOf.get(child);
+            if (!e || rootSet.has(e) || holdsRoot.has(e) || e.landmark || e.demoted || e.chromeKey !== null)
+                continue;
+            const r = child.rect;
+            if (r && r.height > 0 && r.width >= minWidth && hasContent(child))
+                blockRoots.push(e);
+        }
+    }
+    blockRoots.sort((a, b) => a.order - b.order);
+    const blockIdOf = (e) => {
+        const ids = blocksIn.get(e);
+        return ids && ids.size === 1 ? [...ids][0] : undefined;
+    };
+    return { entryOf, entryBySelector, blockRoots, blockIdOf };
+}
+export function liftToBlockRoots(root, opts) {
+    const out = new Map();
+    const analysis = analyzeBlockRoots(root, opts);
+    if (!analysis)
+        return out;
+    const rootSet = new Set(analysis.blockRoots);
+    for (const b of opts.blocks) {
+        for (const member of b.members) {
+            for (let e = analysis.entryBySelector.get(member.selector) ?? null; e; e = e.parent) {
+                if (!rootSet.has(e))
+                    continue;
+                if (analysis.blockIdOf(e) === b.id) {
+                    let byMember = out.get(b.id);
+                    if (!byMember)
+                        out.set(b.id, (byMember = new Map()));
+                    byMember.set(member.selector, e.node);
                 }
-                a = a.nearestLandmark;
+                break;
             }
-            if (hasSurvivingAncestor)
-                continue;
         }
-        surviving.add(e);
     }
-    const landmarks = [...surviving].sort((a, b) => {
+    return out;
+}
+export function buildRootShelf(root, opts) {
+    const { limit } = opts;
+    const analysis = analyzeBlockRoots(root, opts);
+    if (!analysis)
+        return buildDescendantShelfWithPaths(root, limit);
+    const { entryOf, blockRoots, blockIdOf } = analysis;
+    const rootSet = new Set(blockRoots);
+    const landmarks = [...blockRoots].sort((a, b) => {
         const dt = a.node.rect.top - b.node.rect.top;
         return dt !== 0 ? dt : a.order - b.order;
     });
@@ -83,7 +227,7 @@ export function buildRootShelf(root, opts) {
     const ancestorsOf = new Map();
     const emittedSelectors = new Set();
     const chromeRows = new Map();
-    const emit = (e) => {
+    const emit = (e, blockId) => {
         if (shelf.length >= limit)
             return false;
         if (emittedSelectors.has(e.node.selector))
@@ -107,6 +251,8 @@ export function buildRootShelf(root, opts) {
         const inRow = inRowOf.get(n.selector);
         if (inRow)
             row.inRow = inRow;
+        if (blockId)
+            row.blockId = blockId;
         shelf.push(row);
         ancestorsOf.set(n.selector, e.ancestors);
         emittedSelectors.add(n.selector);
@@ -114,22 +260,24 @@ export function buildRootShelf(root, opts) {
             chromeRows.set(e.chromeKey, (chromeRows.get(e.chromeKey) ?? 0) + 1);
         return true;
     };
-    const isTextLeaf = (n) => n.tag === 'img' || (TEXT_LEAF_TAGS.has(n.tag) && n.textSummary.trim().length > 0);
+    const leavesPerBlock = landmarks.length
+        ? Math.min(LEAVES_PER_LANDMARK, Math.max(1, Math.floor((limit - landmarks.length) / landmarks.length)))
+        : LEAVES_PER_LANDMARK;
     for (const lm of landmarks) {
         if (shelf.length >= limit)
             break;
-        emit(lm);
+        emit(lm, blockIdOf(lm));
         let taken = 0;
         const collect = (n) => {
             for (const child of n.children) {
-                if (taken >= LEAVES_PER_LANDMARK || shelf.length >= limit)
+                if (taken >= leavesPerBlock || shelf.length >= limit)
                     return;
                 if (child.hidden)
                     continue;
                 const ce = entryOf.get(child);
                 if (!ce)
                     continue;
-                if (surviving.has(ce) && ce !== lm)
+                if (rootSet.has(ce) && ce !== lm)
                     continue;
                 if (isTextLeaf(child) && emit(ce))
                     taken += 1;

package/dist/kernel/selection/elementAiContext.d.ts

@@ -77,11 +77,19 @@ export interface AiDescendant {
      */
     inRow?: RowPosition;
     /**
-     * 区块身份（宿主按页面模型的 member 容器打的，如 `B2 首屏 h:740`），写成行尾的 `[…]`。
+     * 区块身份（宿主打的，如 `B2 首屏 h:740`），写成行尾的 `[…]`。
      * 没选中元素时「首屏下面」要有确定的锚：同一 `top`、同一段文字的包装行常有十几个，没有它
-     * 「最外层容器」会被选成整页包装层（真机 2026-10-16）。只有恰好是区块容器的那一行才有。
+     * 「最外层容器」会被选成整页包装层（真机 2026-10-16）。宿主按 `blockId`（新内核）打；
+     * 没有 `blockId` 的老内核货架，退回「selector 与页面模型 member 逐字相等」。
      */
     block?: string;
+    /**
+     * 页面模型区块 id（内核打的）：这一行是**只装着这一个区块的最外层容器**（块根），由
+     * `buildRootShelf` 的 `blocks` 认领得出 —— 热图成员是轮播第 1 张时，id 落在整个首屏 section
+     * 上，而不是那一张上（真机 2026-10-20）。宿主据此格式化成 `block`。没传 `blocks`、或这一行
+     * 不是某个区块的块根时没有这个键。
+     */
+    blockId?: string;
 }
 /**
  * 区块级货架取树的口径（`<page-block>`、方案锚点子树、选中元素货架三处共用）。
@@ -292,7 +300,7 @@ export declare const AI_DESCENDANT_LIMIT = 30;
  * 60 → 100：货架改成「区块优先」（`buildRootShelf`）之后，每个区块是 1 行容器 + 最多 6 行
  * 可改点，一个 10 个区块的落地页就是 70 行；60 会把最后几个区块整段切掉，AI 又回到
  * 「找不到要改的那一块」。100 = 约 13 个区块，长落地页也够；header/nav/footer 各封 5 行，
- * 不会被它们吃掉。
+ * 不会被它们吃掉。区块再多时 `buildRootShelf` 按块数压低每块的叶子数，块根行一个不落。
  *
  * 也不能顺手把 `AI_DESCENDANT_LIMIT` 一起调大：那份是**每轮对话**的固定开销，
  * 整页这份一次会话只算一次。