dsh-inner-browser-use 0.43.0 → 0.45.0

package/read.js

@@ -1124,10 +1124,12 @@ export async function findOnPage(page, query, options = {}) {
 }
 
 /**
- * Collect the page as blocks of prose, each with the heading it sits under and
- * how much of it is links. Navigation, sidebars and footers are mostly links;
- * Readability's oldest signal is that such a block is not the content, and it
- * costs one number to carry instead of a guess.
+ * Collect the page as blocks of prose. Each block carries the trail of headings
+ * it sits under, how much of it is links, and one number for how much of it
+ * reads like written content: navigation, sidebars and footers are mostly links
+ * and mostly short, which is Readability's oldest signal. A table row is one
+ * block, with its column names written into it, so a fact that lives in a table
+ * costs a line instead of a page.
  * @param {number} budget - characters of block text to collect.
  * @returns {string} an expression to evaluate.
  */
@@ -1136,32 +1138,66 @@ export function blocks(budget) {
   const root = document.querySelector('article, main, [role="main"]') || document.body
   if (!root) return JSON.stringify({ blocks: [] })
   const limit = ${budget}
-  const BLOCK = new Set(['P', 'LI', 'TD', 'TH', 'BLOCKQUOTE', 'PRE', 'FIGCAPTION', 'DD', 'DT', 'SUMMARY'])
+  const guard = limit * 6
+  const BLOCK = new Set(['P', 'LI', 'BLOCKQUOTE', 'PRE', 'FIGCAPTION', 'DD', 'DT', 'SUMMARY'])
   const SKIP = new Set(['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE', 'SVG', 'IFRAME', 'CANVAS', 'VIDEO', 'HEADER', 'FOOTER', 'NAV', 'ASIDE', 'FORM', 'BUTTON', 'SELECT', 'TEXTAREA'])
   const out = []
   const seen = new Set()
+  const stack = []
   let chars = 0
-  let heading = ''
   const flatten = (text) => String(text ?? '').replace(/\\s+/g, ' ').trim()
+  const trail = () => stack.filter((one) => one !== '').join(' \\u203a ')
+  const said = () => stack.filter((one) => one !== '').pop() ?? ''
+  /* How much of a block reads like prose rather than a list of links: ends of
+     sentences per word, plus a length floor. One number, no dictionary. */
+  const written = (text) => {
+    const words = text.toLowerCase().match(/[a-z0-9]+|[\\u3400-\\u9fff]/g) ?? []
+    if (words.length === 0) return 0
+    const ends = text.match(/[.!?\\u3002\\uff01\\uff1f;\\uff1b]/g) ?? []
+    return Math.min(1, (ends.length / words.length) * 12)
+  }
+  const quality = (text, density) => Math.round((0.45 * (1 - density) + 0.35 * written(text) + 0.2 * Math.min(1, text.length / 180)) * 100) / 100
   const push = (el) => {
-    if (chars >= limit) return
+    if (chars >= guard) return
     const text = flatten(el.innerText ?? el.textContent ?? '')
     if (text === '' || text.length > 4000) return
     let linkChars = 0
     for (const link of el.querySelectorAll('a')) linkChars += flatten(link.innerText ?? '').length
     if (el.tagName === 'A') linkChars += text.length
-    const density = text.length === 0 ? 0 : Math.min(1, linkChars / text.length)
-    out.push({ h: heading, t: text, d: Math.round(density * 100) / 100 })
+    const density = Math.min(1, linkChars / text.length)
+    /* A block that is almost all link and short is a menu item, not a sentence;
+       carrying it only spends the budget. */
+    if (density >= 0.8 && text.length < 80) return
+    const path = trail()
+    out.push({ h: said(), p: path, t: text, d: Math.round(density * 100) / 100, q: quality(text, density) })
     chars += text.length
   }
+  const row = (tr) => {
+    if (chars >= guard) return
+    const cells = Array.from(tr.children).filter((cell) => cell.tagName === 'TD' || cell.tagName === 'TH')
+    const words = cells.map((cell) => flatten(cell.innerText ?? ''))
+    if (words.filter((one) => one !== '').length < 2) return
+    const table = tr.closest('table')
+    const first = table === null ? null : table.querySelector('tr')
+    const head = first === null || first === tr ? [] : Array.from(first.children).map((cell) => flatten(cell.innerText ?? ''))
+    const line = words.map((one, at) => (head[at] === undefined || head[at] === '' || head[at] === one ? one : head[at] + ': ' + one)).join(' | ')
+    out.push({ h: said(), p: trail(), t: line, d: 0, q: 0.95, r: 1 })
+    chars += line.length
+  }
   const walk = (el) => {
-    if (chars >= limit || el === null) return
+    if (el === null || chars >= guard) return
     const tag = el.tagName
     if (SKIP.has(tag) || el.hidden === true || el.getAttribute?.('aria-hidden') === 'true') return
     const style = getComputedStyle(el)
     if (style.display === 'none' || style.visibility === 'hidden') return
     if (/^H[1-6]$/.test(tag)) {
-      heading = flatten(el.innerText ?? '')
+      const level = Number(tag.slice(1))
+      stack.length = level
+      stack[level - 1] = flatten(el.innerText ?? '')
+      return
+    }
+    if (tag === 'TR') {
+      if (!seen.has(el)) { seen.add(el); row(el) }
       return
     }
     if (BLOCK.has(tag)) {
@@ -1172,7 +1208,23 @@ export function blocks(budget) {
   }
   walk(root)
   const title = document.title
-  return JSON.stringify({ title, blocks: out })
+  /* The page arrives in document order, so a menu at the top would spend the
+     whole budget before the article starts. Keep the blocks that read like
+     content, still in page order, until the budget is spent. */
+  let kept = out
+  const total = out.reduce((sum, block) => sum + block.t.length, 0)
+  if (total > limit) {
+    const byQuality = out.map((block, at) => ({ block, at })).sort((a, b) => b.block.q - a.block.q || a.at - b.at)
+    const keep = new Set()
+    let used = 0
+    for (const one of byQuality) {
+      if (used + one.block.t.length > limit) continue
+      keep.add(one.at)
+      used += one.block.t.length
+    }
+    kept = out.filter((block, at) => keep.has(at))
+  }
+  return JSON.stringify({ title, blocks: kept })
 })()`
 }
 
@@ -1217,6 +1269,20 @@ function brief(value) {
   return body.length > 260 ? `${body.slice(0, 260).replace(/\s+\S*$/, '')}…` : body
 }
 
+/**
+ * The trail of headings a block sits under, when it says more than the nearest
+ * one: "Pricing › Refunds" tells a caller where a fact lives, which a bare
+ * sentence cannot. Kept short so location never costs more than it explains.
+ * @param {{h?: string, p?: string}} block - the block.
+ * @returns {string} what to print above the passage.
+ */
+export function trailOf(block) {
+  const path = String(block?.p ?? '')
+  const near = String(block?.h ?? '')
+  if (path === '' || path === near || path.length > 90) return near
+  return path
+}
+
 /**
  * Rank blocks against a query the way a search engine ranks a passage: BM25,
  * with the heading counted as a place a term can match. Then read only the
@@ -1228,7 +1294,7 @@ function brief(value) {
 export function rank(blocks, query) {
   const asked = terms(query)
   if (asked.length === 0) return []
-  const docs = blocks.map((block) => ({ block, terms: terms(`${block.h ?? ''} ${block.t}`) }))
+  const docs = blocks.map((block) => ({ block, terms: terms(`${block.p ?? ''} ${block.h ?? ''} ${block.t}`) }))
   const average = docs.reduce((sum, one) => sum + one.terms.length, 0) / Math.max(1, docs.length)
   const seen = new Map()
   for (const one of docs) for (const term of new Set(one.terms)) seen.set(term, (seen.get(term) ?? 0) + 1)
@@ -1250,6 +1316,9 @@ export function rank(blocks, query) {
     /* A block that is nearly all link is a menu: it matches words without
        saying anything about them. */
     score *= 1 - 0.8 * Number(one.block.d ?? 0)
+    /* Prose that answers a question outranks a fragment of navigation that
+       happens to contain the same words; the quality number says which. */
+    score *= 0.85 + 0.15 * Number(one.block.q ?? 0.5)
     if (score > 0) scored.push({ block: one.block, score })
   }
   scored.sort((a, b) => b.score - a.score)
@@ -1297,7 +1366,7 @@ export function evidence(blocks, query, options = {}) {
   const near = rank(blocks, query).slice(0, Math.max(1, Math.min(60, Number(options.blocks ?? 40))))
   const units = []
   for (const row of near) {
-    const heading = String(row.block.h ?? '')
+    const heading = trailOf(row.block)
     const body = String(row.block.t ?? '')
     const parts = sentences(body)
     for (let step = 0; step < parts.length; step += 1) {
@@ -1339,8 +1408,9 @@ export function evidence(blocks, query, options = {}) {
        both say "this is the right place", so they lift their sentences. */
     const headingHit = asked.filter((term) => terms(unit.heading).includes(term)).length
     /* A menu sentence can match the words without saying anything about them;
-       the paragraph's link density is what tells the two apart. */
-    const linkish = 1 - 0.8 * Number(unit.block?.d ?? 0)
+       the paragraph's link density and how much it reads like prose tell the
+       two apart, and a table row is data rather than a sentence to distrust. */
+    const linkish = (1 - 0.8 * Number(unit.block?.d ?? 0)) * (unit.block?.r === 1 ? 1 : 0.9 + 0.1 * Number(unit.block?.q ?? 0.5))
     unit.score = score * linkish * (1 + 0.25 * headingHit) * (1 + 0.5 * (unit.prior > 0 ? 1 : 0))
   }
   /* Below a fifth of the best sentence, a match is coincidence rather than
@@ -1424,7 +1494,7 @@ export async function readRelevant(page, query, options = {}) {
     for (const row of pieces.slice(0, limit)) {
       const body = String(row.block.t ?? '')
       if (used + body.length > budget) continue
-      const heading = String(row.block.h ?? '')
+      const heading = trailOf(row.block)
       if (heading !== '' && heading !== lastHeading) { lines.push(`## ${heading}`); lastHeading = heading }
       lines.push(body)
       used += body.length

package/scripts/check-flash-tools.mjs

@@ -28,6 +28,10 @@ try {
   await sidecar.watch(() => {})
   await sidecar.page.navigate(url).catch(() => {})
   await wait(9000)
+  /* A port that answers is not a plugin that loaded: ask the page, because a
+     missing plugin shows up as a black movie and reads like a slow one. */
+  const plugin = sidecar.flashCheck ?? (await sidecar.checkFlash())
+  const pluginOk = plugin?.ok === true
   const said = []
   const timed = async (name, args) => {
     const started = Date.now()
@@ -64,8 +68,8 @@ try {
      up whole. Otherwise a bad minute at the site reads as a regression here. */
   const degraded = said[0].chars < 300 || said[0].text.includes('page trouble')
   const fast = () => degraded || (median(clicks) < 120 && median(types) < 120)
-  ok = clicks.length === 5 && fast() && clicks.every(within) && types.every(within) && Number(last?.chars ?? 0) > 0 && viewAgain.chars < said[0].chars && viewThird.chars < said[0].chars
-  console.log(JSON.stringify({ view: said[0], clickMedianMs: median(clicks), clickMaxMs: Math.max(...clicks.map((one) => one.ms)), typeMedianMs: median(types), typeMaxMs: Math.max(...types.map((one) => one.ms)), clickChars: clicks[0].chars, typeChars: types[0].chars, viewAgainChars: viewAgain.chars, viewThirdChars: viewThird.chars, viewAgainText: viewAgain.text, degraded, ok }))
+  ok = pluginOk && clicks.length === 5 && fast() && clicks.every(within) && types.every(within) && Number(last?.chars ?? 0) > 0 && viewAgain.chars < said[0].chars && viewThird.chars < said[0].chars
+  console.log(JSON.stringify({ plugin, view: said[0], clickMedianMs: median(clicks), clickMaxMs: Math.max(...clicks.map((one) => one.ms)), typeMedianMs: median(types), typeMaxMs: Math.max(...types.map((one) => one.ms)), clickChars: clicks[0].chars, typeChars: types[0].chars, viewAgainChars: viewAgain.chars, viewThirdChars: viewThird.chars, viewAgainText: viewAgain.text, degraded, ok }))
 } catch (error) {
   console.log(JSON.stringify({ ok: false, error: String(error?.message ?? error).slice(0, 160) }))
 } finally {

package/scripts/check-look.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * browser_look against a real Chrome and a page that draws itself.
+ *
+ *   node scripts/check-look.mjs
+ *
+ * Paints a canvas, reads the screen as letters, paints one square, reads again
+ * and reports whether the second read named only that square. Exits non-zero
+ * when the tool stops being able to see a self-drawn page.
+ */
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-look-'))
+const folder = mkdtempSync(join(tmpdir(), 'dsh-look-page-'))
+writeFileSync(join(folder, 'index.html'), `<!doctype html><meta charset="utf-8">
+<style>html,body{margin:0;height:100%;background:#101010}canvas{display:block}</style>
+<canvas id="c"></canvas>
+<script>
+const c = document.getElementById('c')
+c.width = innerWidth
+c.height = innerHeight
+const g = c.getContext('2d')
+g.fillStyle = '#202020'
+g.fillRect(0, 0, c.width, c.height)
+g.fillStyle = '#e0e0e0'
+g.fillRect(0, 0, c.width, c.height / 2)
+</script>`)
+
+const { Sidecar } = await import('../sidecar.js')
+const { sidecarTools, sessionScope, workScope } = await import('../tools.js')
+
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'look-check', headless: true })
+const tools = sidecarTools(sidecar, { byChat: new Map() }, {})
+const tool = (name) => tools.find((one) => one.name === name)
+/* Every tool path reads the chat from the scope it is called in, so the check
+   binds the same chat the plugin would bind for a real conversation. */
+const run = (name, args) => sessionScope.run('look-check', () => workScope.run(folder, () => tool(name).execute(args, { agent: { id: 'look-check' } })))
+let failed = 0
+const check = (ok, what) => {
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${what}`)
+  if (!ok) failed += 1
+}
+try {
+  await sidecar.launch('about:blank')
+  await sidecar.watch(() => {})
+  const page = await sidecar.ensure({ session: 'look-check' })
+  await page.navigate(pathToFileURL(join(folder, 'index.html')).href).catch(() => {})
+  await wait(900)
+
+  const first = await run('browser_look', { cols: 12 })
+  const firstText = String(first?.text ?? '')
+  console.log('--- first look ---\n' + firstText)
+  check(/^look 12x\d+ of the screen/m.test(firstText), 'the whole screen is read as a 12-wide grid')
+  check(/1 canvas/.test(firstText), 'the call says the page draws itself')
+  check((firstText.match(/^[.:+\-*#rgbcmyopn]+$/gm) ?? []).length >= 6, 'the grid arrives as rows of palette letters')
+  check(/first look at this screen/.test(firstText), 'the first look says there is nothing to compare yet')
+
+  const painted = await run('browser_eval', { code: "(() => { const c = document.querySelector('canvas'); const g = c.getContext('2d'); g.fillStyle = '#ff2020'; g.fillRect(c.width * 0.2, c.height * 0.15, c.width * 0.4, c.height * 0.2); return 'painted' })()" })
+  check(/painted/.test(String(painted?.text ?? '')), 'the page can be asked to paint a square')
+  await wait(300)
+
+  const second = await run('browser_look', { cols: 12 })
+  const secondText = String(second?.text ?? '')
+  console.log('--- second look ---\n' + secondText)
+  check(/changed: \d+ cells? in box \d+,\d+ \d+x\d+/.test(secondText), 'the second look names only the part that moved')
+  /* Red has to be in the changed box, not anywhere in a page that may already
+     use it: the diff block is only palette rows, so one of those rows must
+     carry r. */
+  const diffBlock = secondText.slice(secondText.search(/changed:/))
+  check(/^[.:+*#rgbcmyopn-]*r[.:+*#rgbcmyopn-]*$/m.test(diffBlock), 'the picture of the change shows red where the square is')
+
+  const same = await run('browser_look', { cols: 12 })
+  check(/nothing changed since the last look/.test(String(same?.text ?? '')), 'a look that sees nothing new says so')
+  const chars = firstText.length + secondText.length + String(same?.text ?? '').length
+  console.log(`three looks cost ${chars} characters and no picture`)
+} catch (error) {
+  console.error('look check failed:', error)
+  failed += 1
+} finally {
+  await sidecar.close?.().catch(() => {})
+}
+process.exitCode = failed === 0 ? 0 : 1

package/scripts/check-sites.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * What the second read of the same site costs.
+ *
+ *   node scripts/check-sites.mjs
+ *
+ * Serves two pages on two origins: an app shell with three hundred buttons and
+ * a document of twelve thousand characters. Reads each one three times and
+ * checks that the first read teaches the next — the app opens as a map, the
+ * document is asked for less — and that the lesson is on disk for the next run.
+ * Exits non-zero when a site stops being learned.
+ */
+import { createServer } from 'node:http'
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-sites-'))
+
+const buttons = Array.from({ length: 300 }, (_, i) => `<button>action ${i + 1}</button>`).join('')
+const app = `<!doctype html><meta charset="utf-8"><title>app shell</title>
+<h1>app shell</h1><p>a shell with three hundred things to click.</p><div>${buttons}</div>`
+const words = Array.from({ length: 240 }, (_, i) => `Paragraph ${i + 1}: ` + 'the quick brown fox jumps over the lazy dog and keeps running through the field '.repeat(3)).join('</p><p>')
+const doc = `<!doctype html><meta charset="utf-8"><title>long document</title>
+<article><h1>long document</h1><p>${words}</p></article>`
+
+const server = createServer((request, response) => {
+  const body = String(request.url ?? '').startsWith('/doc') ? doc : app
+  response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+  response.end(body)
+})
+await new Promise((done) => server.listen(0, '127.0.0.1', done))
+const port = server.address().port
+const appUrl = `http://127.0.0.1:${port}/app`
+const docUrl = `http://localhost:${port}/doc`
+
+const { Sidecar } = await import('../sidecar.js')
+const { saveTactics, sidecarTools, sessionScope, workScope } = await import('../tools.js')
+
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'sites-check', headless: true })
+const tools = sidecarTools(sidecar, { byChat: new Map() }, {})
+const tool = (name) => tools.find((one) => one.name === name)
+const cwd = mkdtempSync(join(tmpdir(), 'dsh-sites-cwd-'))
+/* Same binding the plugin does: the chat and the project a call belongs to. */
+const run = (name, args) => sessionScope.run('sites-check', () => workScope.run(cwd, () => tool(name).execute(args, { agent: { id: 'sites-check' } })))
+let failed = 0
+const check = (ok, what) => {
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${what}`)
+  if (!ok) failed += 1
+}
+const text = (said) => String(said?.text ?? '')
+try {
+  await sidecar.launch('about:blank')
+  await sidecar.watch(() => {})
+  await sidecar.ensure({ session: 'sites-check' })
+
+  await run('browser_open', { url: appUrl })
+  const appFirst = text(await run('browser_view', {}))
+  const appSecond = text(await run('browser_view', {}))
+  const appThird = text(await run('browser_view', {}))
+  console.log('--- app, third read ---\n' + appThird.slice(0, 1200))
+  check(!/^map: /m.test(appFirst), 'the first read of a big site is the page itself')
+  check(!/^map: /m.test(appSecond), 'one read is not yet a lesson')
+  check(/^map: \d+ controls/m.test(appThird), 'the third read opens as a map of what is there')
+  check(/this site reads big \(2 read\(s\)/.test(appThird), 'the map says which site it learned and why')
+  check(appThird.length < appFirst.length, `the map costs less than the page (${String(appThird.length)} < ${String(appFirst.length)} chars)`)
+
+  await run('browser_open', { url: docUrl })
+  const docFirst = text(await run('browser_read', {}))
+  const docSecond = text(await run('browser_read', { force: true }))
+  const docThird = text(await run('browser_read', {}))
+  console.log('--- doc, third read (head) ---\n' + docThird.slice(0, 400))
+  console.log('--- doc, third read (tail) ---\n' + docThird.slice(-300))
+  check(docFirst.length > 4000, `a long document really is long (${String(docFirst.length)} chars)`)
+  check(docSecond.length > 4000, 'the forced second read is the whole thing again')
+  check(/this site reads long \(2 read\(s\), ~\d{4,} chars of text\): cut at 3500 characters/.test(docThird), 'the third read says it was cut short and how to go past it')
+  check(docThird.length < docFirst.length, `the learned read costs less (${String(docThird.length)} < ${String(docFirst.length)} chars)`)
+
+  await saveTactics()
+  const file = join(process.env.DSH_INNER_BROWSER_STATE_DIR, 'sites.json')
+  check(existsSync(file), 'the lesson is written where the next run will find it')
+  const kept = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {}
+  check(kept[`http://127.0.0.1:${port}`]?.controls >= 60, 'the app origin remembers how many controls it has')
+  check(kept[`http://localhost:${port}`]?.text >= 5000, 'the document origin remembers how long its text is')
+} catch (error) {
+  failed += 1
+  console.log('FAIL ' + String(error?.stack ?? error))
+} finally {
+  await sidecar.close?.().catch(() => {})
+  server.close()
+}
+console.log(failed === 0 ? 'sites: ok' : `sites: ${String(failed)} failed`)
+process.exitCode = failed === 0 ? 0 : 1

package/scripts/soak.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Does a long session grow without bound?
+ *
+ *   node scripts/soak.mjs [cycles]
+ *
+ * One headless browser, one tab, one chat, over and over: open a page, read it,
+ * take a snapshot, read the same page again (the unchanged short-circuit), open
+ * the other page. Memory and page count are sampled every few cycles. The run
+ * fails when RSS climbs past the ceiling or a second tab appears, so a leak in
+ * the screencast, the CDP client or the read cache shows up as a number here
+ * instead of as a slow machine next week.
+ *
+ * Bounded on purpose: 24 cycles by default, about twenty seconds, no internet.
+ */
+import { createServer } from 'node:http'
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-soak-'))
+const cycles = Math.max(4, Math.min(Number(process.argv[2] ?? 24) || 24, 200))
+
+const buttons = Array.from({ length: 120 }, (_, i) => `<button>action ${i + 1}</button>`).join('')
+const words = Array.from({ length: 80 }, (_, i) => `Paragraph ${i + 1}: ` + 'the quick brown fox jumps over the lazy dog. '.repeat(6)).join('</p><p>')
+const pages = {
+  '/app': `<!doctype html><meta charset="utf-8"><title>app shell</title><h1>app shell</h1><div>${buttons}</div>`,
+  '/doc': `<!doctype html><meta charset="utf-8"><title>long document</title><article><h1>long document</h1><p>${words}</p></article>`,
+}
+
+const server = createServer((request, response) => {
+  const body = pages[String(request.url ?? '').split('?')[0]] ?? pages['/app']
+  response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+  response.end(body)
+})
+await new Promise((done) => server.listen(0, '127.0.0.1', done))
+const port = server.address().port
+const appUrl = `http://127.0.0.1:${port}/app`
+const docUrl = `http://127.0.0.1:${port}/doc`
+
+const { Sidecar } = await import('../sidecar.js')
+const { sidecarTools, sessionScope, workScope } = await import('../tools.js')
+
+const sidecar = new Sidecar({ profile: 'soak', headless: true })
+const tools = sidecarTools(sidecar, { byChat: new Map() }, {})
+const tool = (name) => tools.find((one) => one.name === name)
+const cwd = mkdtempSync(join(tmpdir(), 'dsh-soak-cwd-'))
+/* Same binding the plugin does: the chat and the project a call belongs to. */
+const run = (name, args) => sessionScope.run('soak', () => workScope.run(cwd, () => tool(name).execute(args, { agent: { id: 'soak' } })))
+const text = (said) => String(said?.text ?? '')
+
+/* macOS reports every renderer's RSS in full, shared pages included, so a
+   healthy headless tree sits far above what one page needs; the bar is a
+   ceiling this machine never approaches plus growth over the run. */
+const ceilingMb = 2500
+const samples = []
+let failed = 0
+const check = (ok, what) => {
+  console.log(`${ok ? 'ok  ' : 'FAIL'} ${what}`)
+  if (!ok) failed += 1
+}
+
+const startedAt = Date.now()
+try {
+  await sidecar.launch('about:blank')
+  await sidecar.watch(() => {})
+  await sidecar.ensure({ session: 'soak' })
+
+  let reads = 0
+  let snapshots = 0
+  for (let i = 0; i < cycles; i += 1) {
+    const url = i % 2 === 0 ? appUrl : docUrl
+    await run('browser_open', { url })
+    reads += text(await run('browser_view', {})).length > 0 ? 1 : 0
+    await run('browser_view', {})
+    if (i % 3 === 0) {
+      snapshots += 1
+      await run('browser_shot', {})
+    }
+    if (i % 2 === 1) await run('browser_read', {})
+    if (i % 4 === 3 || i === cycles - 1) {
+      /* sidecar.state() already reports what the whole process tree holds, so
+         no pid has to be found and no second sampling path exists. */
+      const state = await sidecar.state()
+      const mb = Math.round(Number(state?.memory ?? 0) / 1e6)
+      samples.push({ cycle: i + 1, mb, pages: Number(state?.pages ?? 0) })
+      console.log(`     cycle ${String(i + 1).padStart(3)} · ${String(mb)} MB · pages ${String(state?.pages)}`)
+    }
+    /* A quiet moment, so a leak in the close/reopen path is not hidden by the
+       next navigation arriving before the old page is gone. */
+    if (i % 6 === 5) await new Promise((settle) => setTimeout(settle, 250))
+  }
+
+  const first = samples[0] ?? { mb: 0 }
+  const last = samples.at(-1) ?? first
+  const growth = last.mb - first.mb
+  const seconds = Math.round((Date.now() - startedAt) / 100) / 10
+  check(reads > 0, `the browser answered every cycle (${String(reads)} of ${String(cycles)})`)
+  check(samples.every((one) => one.pages <= 1), `one page per chat is kept (max ${String(Math.max(...samples.map((one) => one.pages)))})`)
+  check(last.mb < ceilingMb, `RSS stays inside this machine's ceiling (${String(last.mb)} < ${String(ceilingMb)} MB)`)
+  check(growth < 250, `RSS growth over ${String(cycles)} cycles is bounded (${growth >= 0 ? '+' : ''}${String(growth)} MB)`)
+  console.log(`soak: ${failed === 0 ? 'ok' : `${String(failed)} failed`} · ${String(cycles)} cycles, ${String(seconds)} s, rss ${String(first.mb)} → ${String(last.mb)} MB, pages ${String(last.pages)}, ${String(snapshots)} shots, ${String(reads)} reads`)
+} catch (error) {
+  failed += 1
+  console.log('FAIL ' + String(error?.stack ?? error))
+} finally {
+  await sidecar.close?.().catch(() => {})
+  server.close()
+}
+process.exitCode = failed === 0 ? 0 : 1

package/sidecar.js

@@ -175,6 +175,19 @@ export function flashRuntime() {
   return { binary: ready.electron, plugin: ready.plugin, version }
 }
 
+/**
+ * What the browser said about its own plugin list. A plugin runtime that opens
+ * its port but carries no PPAPI module looks fine from outside and plays
+ * nothing, so the list is read and turned into a sentence rather than trusted.
+ * @param {unknown} names - plugin names from the page.
+ * @returns {{ok: boolean, name: string}} whether a Flash plugin is there.
+ */
+export function flashVerdict(names) {
+  const list = (Array.isArray(names) ? names : []).map((one) => String(one ?? ''))
+  const found = list.find((one) => one.toLowerCase().includes('shockwave'))
+  return { ok: found !== undefined, name: found ?? '' }
+}
+
 /* A chat's tab address outlives a plugin reload: the browser is still running
    with that tab, and the chat that returns should get its page back, not a
    blank one. */
@@ -2118,6 +2131,9 @@ export class Sidecar {
     /* A movie page needs a runtime Chrome no longer has; the switch is the
        person's, and it swaps the browser rather than the protocol. */
     this.flash = options.flash === undefined ? process.env.DSH_INNER_BROWSER_FLASH === '1' || readFlashChoice() : options.flash === true
+    /* Whether the launched runtime really carries the plugin, asked once at
+       launch: null means it has not been asked. */
+    this.flashCheck = null
     /* The Flash app serves its own frames; the screencast cannot see a plugin. */
     this.flashBridge = null
     this.headless = true
@@ -2634,6 +2650,29 @@ export class Sidecar {
     return this.starting
   }
 
+  /**
+   * Ask the Flash-era browser which plugins it actually loaded.
+   * @returns {Promise<{ok: boolean, name: string} | null>} the answer, or null when it could not be asked.
+   */
+  async checkFlash() {
+    this.flashCheck = null
+    const page = this.page
+    if (page === null || page === undefined) return null
+    try {
+      const out = await page.cdp.send('Runtime.evaluate', {
+        expression: 'JSON.stringify(Array.from(navigator.plugins).map((one) => one.name))',
+        returnByValue: true,
+      })
+      const said = out?.result?.value
+      const names = JSON.parse(typeof said === 'string' ? said : '[]')
+      this.flashCheck = flashVerdict(names)
+    } catch {
+      /* A page that cannot answer is not evidence either way. */
+      this.flashCheck = null
+    }
+    return this.flashCheck
+  }
+
   /** @param {string | undefined} url - first address. @returns {Promise<SidecarPage>} the page. */
   async launch(url) {
     /* Chromium 87 opening the profile a current Chrome owns would downgrade it
@@ -2656,6 +2695,10 @@ export class Sidecar {
     await this.restoreSessionCookies()
     await this.page.cast()
     if (url !== undefined && url !== '') await this.page.navigate(url)
+    /* A runtime that opens a port is not yet a runtime that plays: ask the page
+       whether the plugin is really in it, so a broken install is said out loud
+       instead of showing up as a black movie. */
+    if (this.flash) await this.checkFlash()
     this.touch()
     /* Sign-ins outlive this browser: what works now is worth a copy, taken
        while the cookies are known good rather than after they are lost. */
@@ -3326,6 +3369,8 @@ export class Sidecar {
       alive: this.alive, // ui-copy-ignore
       profile: this.profile, // ui-copy-ignore
       headless: this.headless, // ui-copy-ignore
+      flash: this.flash, // ui-copy-ignore
+      flashCheck: this.flashCheck, // ui-copy-ignore
       url: this.page?.url ?? '', // ui-copy-ignore
       pages: this.pages.size,
       title: this.page?.title ?? '',