@ptengine/inline-editor 0.1.4 → 0.1.6

package/dist/kernel/selection/buildRootShelf.js

@@ -1,16 +1,25 @@
 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;
+function analyzeBlockRoots(root, opts) {
     const viewportWidth = typeof opts.viewportWidth === 'number' && opts.viewportWidth > 0
         ? opts.viewportWidth
         : DEFAULT_VIEWPORT_WIDTH;
@@ -19,7 +28,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 +37,154 @@ 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 isCandidate = (e) => e.landmark && !e.demoted;
+    const entryBySelector = new Map();
+    for (const e of entries)
+        if (!entryBySelector.has(e.node.selector))
+            entryBySelector.set(e.node.selector, e);
+    const claimed = new Map();
+    const blocksIn = new Map();
+    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) {
+            let e = entryBySelector.get(member.selector) ?? null;
+            while (e && !isCandidate(e))
+                e = e.parent;
+            if (!e)
+                continue;
+            addTo(claimed, e, b.id);
+            for (let a = e; a; a = a.parent)
+                addTo(blocksIn, a, 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
-            absorbed.add(e);
+            tops.push(e);
     }
-    const surviving = new Set();
-    for (const e of entries) {
-        if (!e.isLandmark || beaten.has(e))
-            continue;
-        if (absorbed.has(e)) {
-            let a = e.nearestLandmark;
-            let hasSurvivingAncestor = false;
-            while (a) {
-                if (surviving.has(a)) {
-                    hasSurvivingAncestor = true;
-                    break;
+    const isUnit = new Map();
+    for (const e of [...candidates].reverse()) {
+        const ks = kids.get(e) ?? [];
+        let unit;
+        if (isAtomic(e))
+            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
+            unit = (isUnit.get(ks[0]) ?? false) && !isPageScale(e.node);
+        isUnit.set(e, unit);
+    }
+    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 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 +193,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 +217,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);
@@ -115,21 +227,24 @@ export function buildRootShelf(root, opts) {
         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` 一起调大：那份是**每轮对话**的固定开销，
  * 整页这份一次会话只算一次。

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

@@ -35,6 +35,15 @@ export interface InlinePlanAnchor {
     op?: string;
     mode?: string;
     placement?: string;
+    /**
+     * 只给 MOVE_ELEMENT：移到哪（`mode` 相对它：before / after / top / bottom）。移动的落点是**一对**
+     * （移谁 + 移到哪），只存 selector 的话首版只知道要挪、不知道挪到哪（2026-10-21 trace 973f6deb：
+     * 「新闻区挪到畅销榜后面」）。编辑器打开时与锚点一样在活页面上重新解析，命中的目标并进货架 ——
+     * 整页模式下 MOVE 的 target 只认货架行（`pageMoveTargetProblem`）。
+     */
+    targetSelector?: string;
+    /** 目标那一行的标题 / 首句 —— `targetSelector` 失效时按它找回来（与 `label` 同一套规则）。 */
+    targetLabel?: string;
     /**
      * 该区块（B{n}）在活页面上的 member 容器 selector，外层优先。**只在内存里**（宿主从页面模型
      * 补进来），不落库、不与 backend 同形。
@@ -55,6 +64,14 @@ export interface ResolvedAnchor extends InlinePlanAnchor {
     resolved: boolean;
     /** 哪条路成功的。`label` = 原 selector 已失效（客户改版），值得让 agent 知道。 */
     via?: 'selector' | 'label';
+    /**
+     * MOVE 目标（`targetSelector`）的解析结果；锚点没有目标、或锚点自己没解析到时不写。
+     * `true` = 目标在活页面上唯一命中、且已作为一行并进货架与祖先表（agent 抄它就过得了 MOVE 的 target 闸）。
+     */
+    targetResolved?: boolean;
+    targetVia?: 'selector' | 'label';
+    /** 目标在活页面上的 selector。`targetVia: 'label'` 时与存下来的 `targetSelector` 不同 —— 宿主打印这一个。 */
+    resolvedTargetSelector?: string;
 }
 export interface AnchorShelfResult {
     /** 锚点容器行在前、其子树行在后，按锚点顺序。 */

package/dist/kernel/selection/resolveAnchors.js

@@ -64,6 +64,17 @@ export function withImageRows(shelf, anchorRowCount, images) {
 function normalizeLabel(s) {
     return s.replace(/\s+/g, ' ').trim().toLowerCase();
 }
+function indexNodes(root) {
+    const map = new Map();
+    const walk = (n) => {
+        if (!map.has(n.selector))
+            map.set(n.selector, n);
+        for (const child of n.children)
+            walk(child);
+    };
+    walk(root);
+    return map;
+}
 function indexAncestors(root) {
     const map = new Map();
     const walk = (n, ancestors) => {
@@ -117,6 +128,7 @@ export async function resolveInlinePlanAnchors(input) {
     const outcomes = [];
     const seen = new Set();
     const rootAncestors = indexAncestors(rootTree);
+    const rootNodes = indexNodes(rootTree);
     const rootInRow = rowPositions(rootTree);
     const push = (row, chain) => {
         if (seen.has(row.selector))
@@ -125,6 +137,37 @@ export async function resolveInlinePlanAnchors(input) {
         shelf.push(row);
         ancestorsOf.set(row.selector, chain);
     };
+    const resolveTarget = async (selector, label) => {
+        let found = null;
+        let targetVia;
+        try {
+            const probe = await resolveSelector(selector);
+            if (probe.matched && probe.matchCount === 1) {
+                found = selector;
+                targetVia = 'selector';
+            }
+        }
+        catch {
+        }
+        if (!found && label) {
+            const byLabel = findUniqueByLabel(rootTree, label);
+            if (byLabel) {
+                found = byLabel.selector;
+                targetVia = 'label';
+            }
+        }
+        if (!found)
+            return { targetResolved: false };
+        if (!seen.has(found)) {
+            const node = rootNodes.get(found);
+            if (!node)
+                return { targetResolved: false };
+            const inRow = rootInRow.get(found);
+            const row = rowOf(node);
+            push(inRow ? { ...row, inRow } : row, rootAncestors.get(found) ?? []);
+        }
+        return { targetResolved: true, targetVia, resolvedTargetSelector: found };
+    };
     for (const anchor of anchors) {
         let resolvedSelector = null;
         let via;
@@ -148,7 +191,8 @@ export async function resolveInlinePlanAnchors(input) {
             outcomes.push({ ...anchor, resolved: false });
             continue;
         }
-        outcomes.push({ ...anchor, resolved: true, via });
+        const outcome = { ...anchor, resolved: true, via };
+        outcomes.push(outcome);
         const ownAncestors = rootAncestors.get(resolvedSelector) ?? [];
         const ownInRow = rootInRow.get(resolvedSelector);
         const withOwnInRow = (row) => ownInRow ? { ...row, inRow: ownInRow } : row;
@@ -160,17 +204,21 @@ export async function resolveInlinePlanAnchors(input) {
         }
         if (!subtree) {
             push(withOwnInRow({ selector: resolvedSelector, tag: '', text: '', hasChildren: true }), ownAncestors);
-            continue;
         }
-        const anchorSelector = subtree.selector || resolvedSelector;
-        push(withOwnInRow(rowOf(subtree)), ownAncestors);
-        const { shelf: rows, ancestorsOf: within } = buildDescendantShelfWithPaths(subtree, limitPerAnchor);
-        for (const row of rows) {
-            const chainWithin = within.get(row.selector) ?? [];
-            const chain = chainWithin.includes(anchorSelector)
-                ? [...chainWithin, ...ownAncestors]
-                : [...chainWithin, anchorSelector, ...ownAncestors];
-            push({ ...row, depth: (row.depth ?? 0) + 1 }, chain);
+        else {
+            const anchorSelector = subtree.selector || resolvedSelector;
+            push(withOwnInRow(rowOf(subtree)), ownAncestors);
+            const { shelf: rows, ancestorsOf: within } = buildDescendantShelfWithPaths(subtree, limitPerAnchor);
+            for (const row of rows) {
+                const chainWithin = within.get(row.selector) ?? [];
+                const chain = chainWithin.includes(anchorSelector)
+                    ? [...chainWithin, ...ownAncestors]
+                    : [...chainWithin, anchorSelector, ...ownAncestors];
+                push({ ...row, depth: (row.depth ?? 0) + 1 }, chain);
+            }
+        }
+        if (anchor.targetSelector) {
+            Object.assign(outcome, await resolveTarget(anchor.targetSelector, anchor.targetLabel));
         }
     }
     return { shelf, ancestorsOf, anchors: outcomes };