dsh-browser-playwright-codex 0.7.8 → 0.8.1

package/lib/runtime-state.js

@@ -14,6 +14,9 @@ let _enabled = true;
 let _engine = undefined;
 /** User's window-mode choice: true = headless, undefined = follow the config. */
 let _headless = undefined;
+/** 进场特效的开关：true/false = 用户自己选的，undefined = 跟配置的默认值。 */
+let _swarm = undefined;
+let _swarmTuning = undefined;
 /** Config default pushed in by the provider (display only). */
 let _configuredHeadless = undefined;
 /** Default pushed in by the provider that is actually loaded (display only). */
@@ -40,6 +43,31 @@ function load() {
             // Same contract as engine: absent/unknown means "follow the configured
             // default", so files written before this setting existed stay valid.
             _headless = typeof obj.headless === 'boolean' ? obj.headless : undefined;
+            // 同一个约定：没写过或值不认识 = 跟配置默认值，老状态文件照样有效。
+            _swarm = typeof obj.swarm === 'boolean' ? obj.swarm : undefined;
+            const tuning = obj.swarmTuning;
+            if (tuning !== undefined && tuning !== null && typeof tuning === 'object') {
+                // 只收认识的项；缺的项不写，读的时候自然落回配置默认值。
+                const next = {};
+                if (typeof tuning.speed === 'number')
+                    next.speed = tuning.speed;
+                if (typeof tuning.maxMs === 'number')
+                    next.maxMs = tuning.maxMs;
+                if (typeof tuning.oncePerSite === 'boolean')
+                    next.oncePerSite = tuning.oncePerSite;
+                if (typeof tuning.playOnVeiled === 'boolean')
+                    next.playOnVeiled = tuning.playOnVeiled;
+                if (tuning.whileAiWorks === 'auto-close' || tuning.whileAiWorks === 'keep-alive')
+                    next.whileAiWorks = tuning.whileAiWorks;
+                if (tuning.range === 'viewport' || tuning.range === 'page')
+                    next.range = tuning.range;
+                if (typeof tuning.persistPlayed === 'boolean')
+                    next.persistPlayed = tuning.persistPlayed;
+                _swarmTuning = next;
+            }
+            else {
+                _swarmTuning = undefined;
+            }
         }
     }
     catch {
@@ -69,6 +97,10 @@ function persist() {
         const payload = _engine === undefined ? { enabled: _enabled } : { enabled: _enabled, engine: _engine };
         if (_headless !== undefined)
             payload.headless = _headless;
+        if (_swarm !== undefined)
+            payload.swarm = _swarm;
+        if (_swarmTuning !== undefined)
+            payload.swarmTuning = _swarmTuning;
         fs.writeFileSync(tmp, JSON.stringify(payload, null, 2));
         fs.renameSync(tmp, target);
     }
@@ -127,6 +159,74 @@ export function setHeadless(next) {
     persist();
     return true;
 }
+/**
+ * 进场特效的开关：用户自己选过的值，没选过返回 undefined（由配置默认值说话）。
+ */
+export function getSwarm() {
+    load();
+    return _swarm;
+}
+/** 记下用户对进场特效的选择。Returns true when the value changed. */
+export function setSwarm(next) {
+    load();
+    if (typeof next !== 'boolean')
+        return false;
+    if (_swarm === next)
+        return false;
+    _swarm = next;
+    persist();
+    return true;
+}
+/** 用户自己选过吗？（设置卡用来区分「你选的」和「默认的」。） */
+export function isSwarmUserChosen() {
+    load();
+    return _swarm !== undefined;
+}
+/** 播放参数：只含用户改过的项，其余跟配置默认值。 */
+export function getSwarmTuning() {
+    load();
+    return _swarmTuning ?? {};
+}
+/** 改播放参数（只传要改的项）。Returns true when something changed. */
+export function setSwarmTuning(patch) {
+    load();
+    const next = { ...(_swarmTuning ?? {}) };
+    let changed = false;
+    if (typeof patch.speed === 'number' && next.speed !== patch.speed) {
+        next.speed = patch.speed;
+        changed = true;
+    }
+    if (typeof patch.maxMs === 'number' && next.maxMs !== patch.maxMs) {
+        next.maxMs = patch.maxMs;
+        changed = true;
+    }
+    if (typeof patch.oncePerSite === 'boolean' && next.oncePerSite !== patch.oncePerSite) {
+        next.oncePerSite = patch.oncePerSite;
+        changed = true;
+    }
+    if (typeof patch.playOnVeiled === 'boolean' && next.playOnVeiled !== patch.playOnVeiled) {
+        next.playOnVeiled = patch.playOnVeiled;
+        changed = true;
+    }
+    if ((patch.whileAiWorks === 'auto-close' || patch.whileAiWorks === 'keep-alive') &&
+        next.whileAiWorks !== patch.whileAiWorks) {
+        next.whileAiWorks = patch.whileAiWorks;
+        changed = true;
+    }
+    if ((patch.range === 'viewport' || patch.range === 'page') && next.range !== patch.range) {
+        next.range = patch.range;
+        changed = true;
+    }
+    if (typeof patch.persistPlayed === 'boolean' && next.persistPlayed !== patch.persistPlayed) {
+        next.persistPlayed = patch.persistPlayed;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    _swarmTuning = next;
+    persist();
+    return true;
+}
 /** Publish the configured default (launch.headless) for display. */
 export function publishConfiguredHeadless(value) {
     _configuredHeadless = value === true;

package/lib/session.d.ts

@@ -149,6 +149,17 @@ export declare class PlaywrightSession {
     capture(page: Page, opts: {
         interactiveOnly?: boolean;
     } | undefined, afterAction?: boolean): Promise<BrowserSnapshot>;
+    /**
+     * Close one page whose script has stopped answering, so the next acquire starts
+     * on a live tab instead of inheriting it. Bounded and best-effort: main thread
+     * wedged badly enough to stall an evaluate may never answer close either, and
+     * this runs on the error path — it must never turn a timeout into a second hang.
+     *
+     * 代价要说清楚：`runBeforeUnload:false` 意味着**不弹**「确定要离开吗」，所以页面上
+     * 填了一半的表单、没提交的内容直接丢弃；如果那是唯一一个标签，接下来是一张空白页。
+     * 对真卡死的页这笔账划算，但用户必须被告知——所以 capture() 的报错文案里写明这件事。
+     */
+    private discardStuckPage;
     /**
      * Semantic-tree capture via Playwright's official ariaSnapshot(mode:'ai').
      * An unavailable or unreadable aria tree (`missing`) degrades to the legacy

package/lib/session.js

@@ -240,7 +240,12 @@ export class PlaywrightSession {
     }
     /** Element-level stability before a pointer/keyboard action, bounded. Returns true when stable. */
     async waitForElementStable(locator) {
-        const ok = await locator.evaluate(elementStabilityProbe, { frames: 2, timeoutMs: 1500 }).catch(() => false);
+        // locator.evaluate has no timeout of its own either: the probe runs page
+        // script, so a wedged main thread makes it hang before the action it is
+        // supposed to protect. Degrade to "not stable" and let the action's own
+        // Playwright timeout report the real problem (same contract as before, just
+        // no longer unbounded).
+        const ok = await withDeadline(locator.evaluate(elementStabilityProbe, { frames: 2, timeoutMs: 1500 }).catch(() => false), Math.max(3000, this.timeoutMs()), 'waiting for the element to hold still', this.currentSignal, 'resolve-undefined').catch(() => false);
         return ok === true;
     }
     /** Post-action settle: wait out a real navigation, then render-stabilize before snapshotting. */
@@ -327,19 +332,42 @@ export class PlaywrightSession {
             return this.attachDiff(attachNoProgress(this, attachDocResponse(this, page, raw), afterAction));
         };
         try {
-            const snap = await withDeadline(read(), this.timeoutMs(), 'reading the page content', this.currentSignal);
+            const snap = await withDeadline(read(), this.timeoutMs(), 'reading the page content', this.currentSignal, 'reject', 
+            // 报错文案必须说人话、说真话：这一页真的被关掉了，页面里没提交的东西跟着没了。
+            // 关页不弹 beforeunload（弹了可能又卡死），所以用户只有从这条消息里才知道。
+            'That page has been closed; anything typed into it but not submitted is lost, and if it was the last tab the session now starts on a blank page.');
             return snap;
         }
         catch (error) {
             // 超时只能让我们这一侧返回，页面里那个 evaluate 还在跑。作废会话句柄，
-            // 下一次调用会重新拿到干净窗口，而不是继承这个卡住的页面。
+            // 再把那张卡死的页面真正关掉——否则持久化模式下 ensurePage() 会把同一个
+            // 页面交还给下一次调用，所谓「自愈」只是换了个句柄继续超时（issue #5）。
             if (isReadTimeout(error)) {
                 this.closed = true;
                 this.provider.invalidateOwner(this.owner);
+                await this.discardStuckPage(page);
             }
             throw error;
         }
     }
+    /**
+     * Close one page whose script has stopped answering, so the next acquire starts
+     * on a live tab instead of inheriting it. Bounded and best-effort: main thread
+     * wedged badly enough to stall an evaluate may never answer close either, and
+     * this runs on the error path — it must never turn a timeout into a second hang.
+     *
+     * 代价要说清楚：`runBeforeUnload:false` 意味着**不弹**「确定要离开吗」，所以页面上
+     * 填了一半的表单、没提交的内容直接丢弃；如果那是唯一一个标签，接下来是一张空白页。
+     * 对真卡死的页这笔账划算，但用户必须被告知——所以 capture() 的报错文案里写明这件事。
+     */
+    async discardStuckPage(page) {
+        try {
+            await withDeadline(page.close({ runBeforeUnload: false }), 2_000, 'closing the stuck page', undefined, 'resolve-undefined');
+        }
+        catch {
+            /* already gone, or too wedged to close: nothing better we can do */
+        }
+    }
     /**
      * Semantic-tree capture via Playwright's official ariaSnapshot(mode:'ai').
      * An unavailable or unreadable aria tree (`missing`) degrades to the legacy
@@ -556,7 +584,11 @@ export class PlaywrightSession {
                 if (page === undefined)
                     continue;
                 this.guardBlockedDialog(page);
-                out.push({ index, url: page.url(), title: await page.title(), active: index === activeIndex });
+                // page.title() is a page round trip with no timeout: one tab running a
+                // stuck script used to hang the whole tab list, and every tab after it.
+                // An unreadable title degrades to "" — the URL still identifies the tab.
+                const title = await withDeadline(page.title().catch(() => ''), Math.max(2000, Math.min(this.timeoutMs(), 5000)), 'reading the title of tab ' + String(index), this.currentSignal, 'resolve-undefined').catch(() => undefined);
+                out.push({ index, url: page.url(), title: title ?? '', active: index === activeIndex });
             }
             return out;
         });
@@ -600,7 +632,29 @@ export class PlaywrightSession {
         });
     }
     async pageData() {
-        return pageData(this);
+        // page.evaluate again: the extract walker is page script, so a stuck tab used
+        // to hang browser_extract exactly like a snapshot read. Same deadline, and on
+        // timeout the same cleanup — drop the handle and the page so the next call
+        // does not inherit a page that will never answer.
+        try {
+            return await withDeadline(pageData(this), this.timeoutMs(), 'reading the page content', this.currentSignal, 'reject', 'That page has been closed; anything typed into it but not submitted is lost.');
+        }
+        catch (error) {
+            if (isReadTimeout(error)) {
+                this.closed = true;
+                this.provider.invalidateOwner(this.owner);
+                let page;
+                try {
+                    page = this.currentPageSync();
+                }
+                catch {
+                    page = undefined;
+                }
+                if (page !== undefined)
+                    await this.discardStuckPage(page);
+            }
+            throw error;
+        }
     }
     async evaluate(expression, signal) {
         // The switch is enforced HERE, not only in the tool layer: browser_evaluate
@@ -616,14 +670,26 @@ export class PlaywrightSession {
             this.provider.touch(this.owner);
             const page = await this.ensurePage();
             const fn = new Function('return (' + expression + ')');
+            // page.evaluate takes no timeout: an expression with an infinite loop (a
+            // shader compile, a spin on a mutex) never returns and the tool call hangs
+            // forever. Bound it with the same budget the snapshot read uses, and on
+            // timeout drop this handle + the stuck page so the next call starts clean
+            // instead of inheriting a page that will never answer.
+            const once = async () => (await withDeadline(withAbort(page.evaluate(fn), signal), this.timeoutMs(), 'evaluating page JavaScript', undefined, 'reject', 'That page has been closed; anything typed into it but not submitted is lost, and the expression may have left the page unresponsive.'));
             try {
-                return await withAbort(page.evaluate(fn), signal);
+                return await once();
             }
             catch (error) {
+                if (isReadTimeout(error)) {
+                    this.closed = true;
+                    this.provider.invalidateOwner(this.owner);
+                    await this.discardStuckPage(page);
+                    throw error;
+                }
                 if (!isContextDestroyed(error) || signal?.aborted === true)
                     throw error;
                 await this.settleNavigation(page);
-                return withAbort(page.evaluate(fn), signal);
+                return once();
             }
         });
     }
@@ -665,13 +731,16 @@ export class PlaywrightSession {
                 // inside the driver, and the failure gets reported as a protocol error.
                 const session = this.cdpSession;
                 const send = session.send.bind(session);
-                return await withAbort(send(method, params ?? {}), signal);
+                // A CDP command has no timeout of its own either, and some of them
+                // (screenshots, layout dumps) run page script internally. Same budget as
+                // a page read; the CDP session itself stays usable, only this call dies.
+                return await withDeadline(withAbort(send(method, params ?? {}), signal), this.timeoutMs(), 'running CDP command ' + method, undefined, 'reject', 'The command was abandoned; the page may still be working on it. Take a fresh snapshot to see where it landed.');
             }
             catch (error) {
-                if (isAbortError(error))
+                // A deadline and a cancel both mean what they say: never relabel them as
+                // a protocol failure (the wrapping below only owns real CDP errors).
+                if (isAbortError(error) || isReadTimeout(error))
                     throw error;
-                // CDP protocol errors are already structured ("Protocol error
-                // (DOM.foo): ..."); wrap non-abort failures in a stable code.
                 const detail = error instanceof Error ? error.message : String(error);
                 if (/Protocol error/.test(detail)) {
                     const m = /\(([^)]+)\): ([\s\S]+)/.exec(detail);

package/lib/settings-card.js

@@ -63,6 +63,7 @@ import * as runtimeState from "./runtime-state.js";
 // The patch writer lives in its own dependency-free module so it can be tested
 // without a DSH host (a half-written patch layer would break every plugin load).
 import { homePatchPath, parseGatesBlock, writeGates } from "./gates-patch.js";
+import { onPersistPlayedChanged, resetPlayed } from "./swarm-intro.js";
 import { readFileSync } from 'node:fs';
 import { clean, isTargetId, resolvePaths, scan } from "./cache-clean.js";
 const { getEnabled, setEnabled, getEffectiveEngine, setSnapshotEngine, isEngineUserChosen } = runtimeState;
@@ -238,9 +239,119 @@ function registerWindowRoute(ctx) {
         },
     }));
 }
+/**
+ * POST /swarm { enabled } — 进场特效的开关。
+ *
+ * 只是用户在设置卡上的选择，落盘后立刻生效：下一次导航就会按新值决定播不播，
+ * 不用重启，也不用断开已经开着的窗口。
+ */
+function registerSwarmRoute(ctx) {
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: PREFIX + '/swarm',
+        handler: async (req, res) => {
+            if (req.method !== 'POST')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'POST only' } });
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            const body = await readBody(req);
+            if (!body.ok)
+                return sendJson(res, 400, { error: { code: 'BODY_READ', message: body.error } });
+            let payload;
+            try {
+                payload = JSON.parse(body.text || '{}');
+            }
+            catch {
+                return sendJson(res, 400, { error: { code: 'INVALID_JSON', message: 'body must be JSON' } });
+            }
+            if (payload.enabled !== undefined && typeof payload.enabled !== 'boolean')
+                return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`enabled` must be a boolean' } });
+            // 清空播放记录：打开开关之后想让每个网站重新播一遍，就顺手清一下。
+            const reset = payload.resetPlayed === true;
+            if (reset) {
+                try {
+                    resetPlayed();
+                }
+                catch {
+                    /* 文件不存在就是已经清过了 */
+                }
+            }
+            let changed = false;
+            if (typeof payload.enabled === 'boolean')
+                changed = runtimeState.setSwarm(payload.enabled) || changed;
+            // 播放参数：速度 1–3；时长 0（完整播完）或 3000–30000 毫秒；是否每站只播一次。
+            const patch = {};
+            if (payload.speed !== undefined) {
+                const speed = Number(payload.speed);
+                if (!Number.isFinite(speed) || speed < 1 || speed > 3)
+                    return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`speed` must be 1–3' } });
+                patch.speed = Math.round(speed);
+            }
+            if (payload.maxMs !== undefined) {
+                const maxMs = Number(payload.maxMs);
+                if (!Number.isFinite(maxMs) || (maxMs !== 0 && (maxMs < 3000 || maxMs > 30000)))
+                    return sendJson(res, 400, {
+                        error: { code: 'INVALID_BODY', message: '`maxMs` must be 0 or 3000–30000' },
+                    });
+                patch.maxMs = Math.round(maxMs);
+            }
+            if (payload.oncePerSite !== undefined) {
+                if (typeof payload.oncePerSite !== 'boolean')
+                    return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`oncePerSite` must be a boolean' } });
+                patch.oncePerSite = payload.oncePerSite;
+            }
+            if (payload.playOnVeiled !== undefined) {
+                if (typeof payload.playOnVeiled !== 'boolean')
+                    return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`playOnVeiled` must be a boolean' } });
+                patch.playOnVeiled = payload.playOnVeiled;
+            }
+            if (payload.whileAiWorks !== undefined) {
+                if (payload.whileAiWorks !== 'auto-close' && payload.whileAiWorks !== 'keep-alive')
+                    return sendJson(res, 400, {
+                        error: { code: 'INVALID_BODY', message: '`whileAiWorks` must be auto-close or keep-alive' },
+                    });
+                patch.whileAiWorks = payload.whileAiWorks;
+            }
+            if (payload.range !== undefined) {
+                if (payload.range !== 'viewport' && payload.range !== 'page')
+                    return sendJson(res, 400, {
+                        error: { code: 'INVALID_BODY', message: '`range` must be viewport or page' },
+                    });
+                patch.range = payload.range;
+            }
+            if (payload.persistPlayed !== undefined) {
+                if (typeof payload.persistPlayed !== 'boolean')
+                    return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`persistPlayed` must be a boolean' } });
+                patch.persistPlayed = payload.persistPlayed;
+            }
+            const wasPersist = runtimeState.getSwarmTuning().persistPlayed === true;
+            if (Object.keys(patch).length > 0)
+                changed = runtimeState.setSwarmTuning(patch) || changed;
+            // 开关真的翻了才动记录：打开立刻把这趟落盘，关掉删盘（防幽灵复活）。
+            const nowPersist = runtimeState.getSwarmTuning().persistPlayed === true;
+            if (nowPersist !== wasPersist)
+                onPersistPlayedChanged(nowPersist);
+            const tuning = runtimeState.getSwarmTuning();
+            sendJson(res, 200, {
+                swarm: runtimeState.getSwarm(),
+                swarmSpeed: tuning.speed ?? null,
+                swarmMaxMs: tuning.maxMs ?? null,
+                swarmOncePerSite: tuning.oncePerSite ?? null,
+                swarmPlayOnVeiled: tuning.playOnVeiled ?? null,
+                swarmWhileAiWorks: tuning.whileAiWorks ?? null,
+                swarmRange: tuning.range ?? null,
+                swarmPersistPlayed: tuning.persistPlayed ?? null,
+                changed,
+                resetPlayed: reset,
+                appliedOn: 'next-navigation',
+            });
+        },
+    }));
+}
 export function apply(ctx) {
     registerDiskRoutes(ctx);
     registerWindowRoute(ctx);
+    registerSwarmRoute(ctx);
     ctx.effect(() => ctx.webServer.register({
         kind: 'exact',
         path: `${PREFIX}/state`,
@@ -265,6 +376,18 @@ export function apply(ctx) {
                 headless: runtimeState.getEffectiveHeadless(),
                 headlessUserChosen: runtimeState.isHeadlessUserChosen(),
                 headlessConfigured: runtimeState.getConfiguredHeadless(),
+                // 进场特效：null = 用户没表态，跟配置默认（出厂开）。
+                swarm: runtimeState.getSwarm() ?? null,
+                swarmUserChosen: runtimeState.isSwarmUserChosen(),
+                // 播放参数：undefined = 跟配置默认（3× / 15 秒 / 每站一次）。
+                swarmSpeed: runtimeState.getSwarmTuning().speed ?? null,
+                swarmMaxMs: runtimeState.getSwarmTuning().maxMs ?? null,
+                swarmOncePerSite: runtimeState.getSwarmTuning().oncePerSite ?? null,
+                // null = 跟配置默认（遮罩不播 / AI 动手时自动关闭动画）。
+                swarmPlayOnVeiled: runtimeState.getSwarmTuning().playOnVeiled ?? null,
+                swarmWhileAiWorks: runtimeState.getSwarmTuning().whileAiWorks ?? null,
+                swarmRange: runtimeState.getSwarmTuning().range ?? null,
+                swarmPersistPlayed: runtimeState.getSwarmTuning().persistPlayed ?? null,
                 // What the user's own layer says right now. Differs from the above
                 // between a write and the live reload that applies it.
                 patchGates: managedBlockGates() ?? null,

package/lib/snapshot-render.js

@@ -42,6 +42,21 @@ const TRACKING_PARAMS = new Set([
 ]);
 /** Default cap for a rendered href, in characters. */
 export const MAX_HREF_LENGTH = 160;
+/**
+ * Path shapes that mark a redirect-wrapping URL — a link that does not point at
+ * its destination but at the site's own click-tracking endpoint, which forwards
+ * there. Search engines wrap every organic result this way (Bing `/ck/a?...`,
+ * Google `/url?q=...`, Facebook `l.php?u=...`). The real destination is encoded
+ * in a long query parameter, so the rendered href is 160 characters of base64
+ * that says nothing the link's own name does not — and it repeats for every
+ * result on the page.
+ *
+ * This is a generic category (a tracking endpoint on the same origin as the
+ * page), not a per-site special case. When one matches we render a short marker
+ * instead of the wrapped URL: the ref is what clicks, and the link's name plus
+ * any destination node already carry the meaning.
+ */
+const REDIRECT_WRAPPERS = [/\/ck\/a\?/i, /\/url\?q=/i, /l\.php\?u=/i];
 /** Clip a string to a display budget, marking the cut. */
 function clip(value, maxLength) {
     return value.length <= maxLength ? value : value.slice(0, maxLength - 1) + '…';
@@ -56,6 +71,13 @@ function clip(value, maxLength) {
  * @returns the shortened href
  */
 export function trimUrlForDisplay(href, maxLength = MAX_HREF_LENGTH) {
+    // A redirect-wrapping href (search-engine click tracker) is 160 characters of
+    // encoded destination that says nothing the link's name does not. Render a
+    // short marker instead; the ref is what clicks, so this never changes where a
+    // click lands — only what the model reads.
+    if (REDIRECT_WRAPPERS.some((re) => re.test(href))) {
+        return '→ (redirect wrapper)';
+    }
     const hashAt = href.indexOf('#');
     const hash = hashAt >= 0 ? href.slice(hashAt) : '';
     const head = hashAt >= 0 ? href.slice(0, hashAt) : href;
@@ -94,13 +116,14 @@ function isTransparentWrapper(node) {
         node.level === undefined &&
         node.checked === undefined &&
         node.selected === undefined &&
-        node.disabled === undefined);
+        node.disabled === undefined &&
+        node.value === undefined);
 }
 /** Render one node line into the accumulating line list. */
-function renderNode(node, depth, lines) {
+function renderNode(node, depth, lines, seenHrefs) {
     if (isTransparentWrapper(node)) {
         for (const child of node.children)
-            renderNode(child, depth, lines);
+            renderNode(child, depth, lines, seenHrefs);
         return;
     }
     const indent = '  '.repeat(depth);
@@ -116,15 +139,33 @@ function renderNode(node, depth, lines) {
         flags.push('selected');
     if (node.disabled === true)
         flags.push('disabled');
+    // The current value of a text entry field: without it the model cannot see
+    // what a fill actually left behind, which read as "no visible change".
+    if (node.value !== undefined && node.value !== '')
+        flags.push('value=' + node.value);
     if (node.ref !== undefined)
         flags.push('ref=' + node.ref);
     if (flags.length > 0)
         line += ' [' + flags.join(', ') + ']';
-    if (node.href !== undefined)
-        line += ' -> ' + trimUrlForDisplay(node.href);
+    if (node.href !== undefined) {
+        // Same href, second and later occurrence within ONE snapshot: the URL is
+        // already printed at its first occurrence, so repeat only a pointer to it.
+        // Every ref and element stays — this trims bytes, never click targets. Only
+        // absolute URLs are deduped (a bare "/docs" can name different pages).
+        const abs = /^https?:\/\//i.test(node.href);
+        const firstRef = abs ? seenHrefs.get(node.href) : undefined;
+        if (firstRef !== undefined && firstRef !== node.ref) {
+            line += ' -> (same as ' + firstRef + ')';
+        }
+        else {
+            line += ' -> ' + trimUrlForDisplay(node.href);
+            if (abs && node.ref !== undefined)
+                seenHrefs.set(node.href, node.ref);
+        }
+    }
     lines.push(line);
     for (const child of node.children)
-        renderNode(child, depth + 1, lines);
+        renderNode(child, depth + 1, lines, seenHrefs);
 }
 /**
  * Render a node tree as indented lines, one element per line.
@@ -133,8 +174,12 @@ function renderNode(node, depth, lines) {
  */
 export function renderSnapshotTree(nodes) {
     const lines = [];
+    // href -> ref of its first occurrence in THIS snapshot. Same href second and
+    // later renders as "(same as <ref>)" instead of repeating the URL. Scoped to
+    // one snapshot on purpose: a fresh snapshot after navigation re-prints URLs.
+    const seenHrefs = new Map();
     for (const node of nodes)
-        renderNode(node, 0, lines);
+        renderNode(node, 0, lines, seenHrefs);
     return lines.join('\n');
 }
 /**