webrecipe 0.1.0

package/dist/src/read.js

@@ -0,0 +1,83 @@
+import { load } from 'cheerio';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { UserError, atomicWrite } from './local.js';
+// Below this much visible text the server HTML is treated as a shell for a script to fill.
+const MIN_TEXT = 200;
+const BLOCK_STATUSES = new Set([401, 403, 429, 503]);
+/** Host plus path, with id- and slug-like segments collapsed, so pages of one structure share a key. */
+export function urlShape(url) {
+    const u = new URL(url);
+    const segments = u.pathname.split('/').filter(Boolean)
+        .map(s => /\d/.test(s) || s.split('-').length >= 3 || s.length >= 16 ? '*' : s);
+    return `${u.host}/${segments.join('/')}`;
+}
+const HIDDEN = 'script, style, noscript, template, svg, iframe';
+// Site chrome repeats on every page and can outweigh the content many times over.
+const CHROME = 'nav, header, footer, aside, [role=navigation], [role=banner], [role=contentinfo]';
+const BLOCKS = 'p, div, li, dt, dd, h1, h2, h3, h4, h5, h6, br, tr, section, article, main, ul, ol, table, pre, blockquote, figcaption';
+export function visibleText(html) {
+    const $ = load(html);
+    const title = $('title').first().text().trim();
+    $(HIDDEN).remove();
+    $(CHROME).remove();
+    $(BLOCKS).after('\n');
+    const main = $('main, [role=main], article').first();
+    const root = main.length && main.text().trim() ? main : $('body');
+    const text = root.text().replace(/[ \t\f\v\r]+/g, ' ').replace(/\s*\n\s*/g, '\n').trim();
+    return { title, text };
+}
+export async function readUrl(url, deps) {
+    if (!(await deps.isAllowed(url)))
+        throw new UserError('ROBOTS_DISALLOWED', `robots.txt disallows ${url}`);
+    const shape = urlShape(url);
+    let reason = 'remembered: this URL shape needed a browser before';
+    if ((await deps.methods.get(shape)) !== 'browser') {
+        const res = await deps.fetch(url);
+        const type = res.headers['content-type'] ?? '';
+        if (res.status >= 200 && res.status < 300 && !/html/i.test(type)) {
+            await deps.methods.set(shape, 'http');
+            return { url, method: 'http', reason: `server returned ${type || 'a non-HTML body'}`, title: '', text: res.body };
+        }
+        if (res.status >= 200 && res.status < 300) {
+            const page = visibleText(res.body);
+            if (page.text.length >= MIN_TEXT) {
+                await deps.methods.set(shape, 'http');
+                return { url, method: 'http', reason: 'server HTML carries the text; not the rendered page', ...page };
+            }
+            reason = `server HTML is a shell (${page.text.length} chars of text)`;
+        }
+        else if (BLOCK_STATUSES.has(res.status)) {
+            reason = `HTTP ${res.status}`;
+        }
+        else {
+            throw new UserError('EXECUTION_FAILED', `HTTP ${res.status} for ${url}`);
+        }
+    }
+    const page = visibleText(await deps.render(url));
+    if (page.text.length === 0)
+        throw new UserError('UNVERIFIED_RESULT', `the rendered page has no text: an empty page, an access block, or content that needs interaction (${reason})`);
+    await deps.methods.set(shape, 'browser');
+    return { url, method: 'browser', reason, ...page };
+}
+/** Remembered methods per URL shape, one small JSON file. */
+export function methodStore(root) {
+    const path = join(root, 'read-methods.json');
+    const load = async () => {
+        try {
+            return JSON.parse(await readFile(path, 'utf8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    return {
+        get: async (shape) => (await load())[shape],
+        set: async (shape, method) => {
+            const all = await load();
+            if (all[shape] === method)
+                return;
+            await atomicWrite(path, JSON.stringify({ ...all, [shape]: method }, null, 1));
+        },
+    };
+}

package/dist/src/recipes/fingerprint.js

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto';
+const SEPARATOR = '::';
+/**
+ * Structural paths of a payload. Arrays collapse to `key[]` and every element
+ * is merged, so a schema change is visible but a data change is not.
+ */
+export function collectPaths(value, prefix = '') {
+    const out = new Set();
+    const walk = (node, path) => {
+        if (Array.isArray(node)) {
+            if (path !== '')
+                out.add(path);
+            const arrayPath = `${path}[]`;
+            out.add(arrayPath);
+            for (const element of node)
+                walk(element, arrayPath);
+            return;
+        }
+        if (node !== null && typeof node === 'object') {
+            if (path !== '')
+                out.add(path);
+            for (const [key, child] of Object.entries(node)) {
+                walk(child, path === '' ? key : `${path}.${key}`);
+            }
+            return;
+        }
+        if (path !== '')
+            out.add(path);
+    };
+    walk(value, prefix);
+    return [...out];
+}
+export function computeFingerprint(endpoint, sample) {
+    const paths = collectPaths(sample).sort();
+    return createHash('sha256')
+        .update(endpoint)
+        .update(SEPARATOR)
+        .update(paths.join('\n'))
+        .digest('hex')
+        .slice(0, 16);
+}

package/dist/src/recipes/paths.js

@@ -0,0 +1,14 @@
+/** Minimal JSONPath subset: `$`, `$.key`, `$.a.b`. Enough for recipe output specs. */
+export function resolvePath(root, path) {
+    if (path === '$')
+        return root;
+    if (!path.startsWith('$.'))
+        throw new Error(`unsupported path: ${path}`);
+    let current = root;
+    for (const key of path.slice(2).split('.')) {
+        if (current === null || typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}

package/dist/src/recipes/registry.js

@@ -0,0 +1,81 @@
+import { atomicWrite, siteName, intentName } from '../local.js';
+import { mkdir, readFile, readdir, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+import { RecipeSchema } from './schema.js';
+export class RecipeRegistry {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    dir(site) { return join(this.root, siteName(site)); }
+    file(site, intent) { return join(this.dir(site), `${intentName(intent)}.yaml`); }
+    async load(site, intent) {
+        let raw;
+        try {
+            raw = await readFile(this.file(site, intent), 'utf8');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return null;
+            throw err;
+        }
+        return RecipeSchema.parse(parse(raw));
+    }
+    /**
+     * Saving over an existing recipe archives it as `<intent>.<timestamp>.yaml`,
+     * unless the recipe is the one already stored.
+     */
+    async save(recipe) {
+        const parsed = RecipeSchema.parse(recipe);
+        await mkdir(this.dir(parsed.site), { recursive: true });
+        const target = this.file(parsed.site, parsed.intent);
+        const body = stringify(parsed);
+        try {
+            const stored = await readFile(target, 'utf8');
+            // An identical recipe is not a new version: archiving it buries the
+            // versions that do differ under copies of the one still in use, which is
+            // what a site serving the engine a different page produced every task.
+            if (stored === body)
+                return target;
+            const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+            await rename(target, join(this.dir(parsed.site), `${parsed.intent}.${stamp}.yaml`));
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        await atomicWrite(target, body);
+        return target;
+    }
+    async remove(site, intent) {
+        await rm(this.file(site, intent), { force: true });
+    }
+    failureFile(site, intent) { return join(this.dir(site), `${intentName(intent)}.failure.json`); }
+    async learningFailure(site, intent) {
+        try {
+            const state = JSON.parse(await readFile(this.failureFile(site, intent), 'utf8'));
+            return typeof state.reason === 'string' && state.until > Date.now() ? state.reason : null;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    async setLearningFailure(site, intent, reason) {
+        await atomicWrite(this.failureFile(site, intent), JSON.stringify({ reason, until: Date.now() + 24 * 60 * 60_000 }));
+    }
+    async clearLearningFailure(site, intent) {
+        await rm(this.failureFile(site, intent), { force: true });
+    }
+    async versions(site, intent) {
+        try {
+            const entries = await readdir(this.dir(site));
+            return entries.filter((f) => f.startsWith(`${intent}.`) && f.endsWith('.yaml') && f !== `${intentName(intent)}.yaml`).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/src/recipes/schema.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export const RecipeSchema = z.object({
+    site: z.string().min(1),
+    intent: z.enum(['search', 'list', 'detail']),
+    inputs: z.record(z.object({ type: z.enum(['string', 'number']) })),
+    strategy: z.object({ type: z.enum(['http-json', 'http-html', 'browser']) }),
+    request: z.object({
+        method: z.enum(['GET', 'POST']),
+        /** Set when the data request lives on another host than the site, e.g. a search vendor. */
+        origin: z.string().url().optional(),
+        path: z.string(),
+        query: z.record(z.string()).optional(),
+        headers: z.record(z.string()).optional(),
+        body: z.string().optional(),
+    }),
+    output: z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('json'),
+            items: z.object({ path: z.string(), fields: z.record(z.string()) }),
+        }),
+        z.object({
+            type: z.literal('html'),
+            /** A field value of `@attr` reads that attribute off the item element; anything else is a CSS selector. */
+            items: z.object({ selector: z.string(), fields: z.record(z.string()) }),
+        }),
+    ]),
+    validation: z.object({
+        status: z.number().int(),
+        required: z.array(z.string()),
+        minItems: z.number().int().default(1),
+    }),
+    fingerprint: z.object({
+        endpoint: z.string(),
+        hash: z.string(),
+        responseFields: z.array(z.string()),
+    }),
+    fallback: z.object({ type: z.literal('browser') }),
+});

package/dist/src/recipes/template.js

@@ -0,0 +1,33 @@
+import { UserError } from '../local.js';
+const PLACEHOLDER = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+export function render(template, input) {
+    return template.replace(PLACEHOLDER, (_match, key) => {
+        if (!(key in input))
+            throw new Error(`no value supplied for placeholder "${key}"`);
+        return String(input[key]);
+    });
+}
+export function renderQuery(query, input) {
+    return Object.fromEntries(Object.entries(query).map(([k, v]) => [k, render(v, input)]));
+}
+/** Encode user values as URL data, retaining slash-separated detail identifiers. */
+export function renderPath(template, input) {
+    return render(template, Object.fromEntries(Object.entries(input).map(([k, v]) => [k, String(v).split('/').map(encodeURIComponent).join('/')])));
+}
+export function renderUrlTemplate(origin, template, input) {
+    const accepted = new Set([...template.matchAll(PLACEHOLDER)].map(match => match[1]));
+    for (const key of Object.keys(input)) {
+        if (!accepted.has(key))
+            throw new UserError('INVALID_INPUT', `The saved task does not use input "${key}". Teach a URL containing that input first.`);
+    }
+    const at = template.indexOf('?');
+    const path = at === -1 ? template : template.slice(0, at);
+    const url = new URL(renderPath(path, input), origin);
+    if (url.origin !== new URL(origin).origin)
+        throw new Error('plan URL escaped its origin');
+    if (at !== -1) {
+        for (const [key, value] of new URLSearchParams(template.slice(at + 1)))
+            url.searchParams.append(key, render(value, input));
+    }
+    return url.toString();
+}

package/dist/src/recorder/body.js

@@ -0,0 +1,59 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+/** Bodies at or below this stay in the trace; larger ones spill to a file. */
+const INLINE_LIMIT_BYTES = 256 * 1024;
+/** A body this large is a mistake, not a page. Recorded as truncated. */
+const SAFETY_CAP_BYTES = 64 * 1024 * 1024;
+/**
+ * Preserves response bodies of any size.
+ *
+ * A fixed inline cap silently dropped flathub.org's 662KB search page, which
+ * left the html compiler with nothing to work from — the strategy was not
+ * refused, it was absent. Size is a property of the page, not a reason to lose
+ * the observation, so large bodies go to a file and the trace keeps a pointer.
+ * That also keeps a serialised trace small enough to read.
+ */
+export class BodyStore {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    static async create() {
+        return new BodyStore(await mkdtemp(join(tmpdir(), 'fwa-bodies-')));
+    }
+    async put(key, buffer, cap = SAFETY_CAP_BYTES) {
+        const bodySize = buffer.byteLength;
+        if (bodySize > cap) {
+            return { body: null, bodyPath: null, bodySize, truncated: true };
+        }
+        if (bodySize <= INLINE_LIMIT_BYTES) {
+            return { body: buffer.toString('utf8'), bodyPath: null, bodySize, truncated: false };
+        }
+        const name = createHash('sha256').update(key).digest('hex').slice(0, 16);
+        const bodyPath = join(this.dir, `${name}.body`);
+        await writeFile(bodyPath, buffer);
+        return { body: null, bodyPath, bodySize, truncated: false };
+    }
+    async dispose() {
+        await rm(this.dir, { recursive: true, force: true });
+    }
+}
+/**
+ * The body of a recorded request, wherever it was kept. Synchronous because
+ * every caller is a compiler reading one trace, not a hot path.
+ */
+export function readBody(request) {
+    if (request.body !== null)
+        return request.body;
+    if (request.bodyPath === null)
+        return null;
+    try {
+        return readFileSync(request.bodyPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/recorder/index.js

@@ -0,0 +1,151 @@
+import { openSession } from '../browser/session.js';
+import { BodyStore } from './body.js';
+import { navigateAndSettle } from '../browser/navigate.js';
+/** A DOM mutation this soon after a response is treated as caused by it. */
+const DOM_SETTLE_MS = 800;
+/**
+ * Records DOM mutations and request completions on the *page's* clock.
+ *
+ * Both must come from inside the page. A response event observed in Node and a
+ * mutation observed in the page are recorded at different stages of the
+ * pipeline, so under load their order can invert and a later request steals
+ * credit for an earlier response's DOM change. Inside the page the ordering is
+ * guaranteed by the event loop: the mutation callback is a microtask that runs
+ * before any subsequent `await fetch(...)` resolves.
+ *
+ * Observes `document`, not `document.documentElement`: init scripts run at
+ * document-start, where documentElement is still null and observing it throws.
+ */
+const PAGE_PROBE = `
+window.__fwaMutations = []
+new MutationObserver(() => { window.__fwaMutations.push(Date.now()) })
+  .observe(document, { childList: true, subtree: true, characterData: true })
+
+window.__fwaCompletions = []
+const __fwaRecord = (raw) => {
+  try {
+    window.__fwaCompletions.push({ url: new URL(raw, location.href).href, at: Date.now() })
+  } catch {}
+}
+
+const __fwaFetch = window.fetch
+window.fetch = async function (...args) {
+  const response = await __fwaFetch.apply(this, args)
+  const first = args[0]
+  __fwaRecord(typeof first === 'string' ? first : (first && first.url) || String(first))
+  return response
+}
+
+const __fwaOpen = XMLHttpRequest.prototype.open
+const __fwaSend = XMLHttpRequest.prototype.send
+XMLHttpRequest.prototype.open = function (method, url, ...rest) {
+  this.__fwaUrl = url
+  return __fwaOpen.call(this, method, url, ...rest)
+}
+XMLHttpRequest.prototype.send = function (...args) {
+  this.addEventListener('loadend', () => { __fwaRecord(this.__fwaUrl) })
+  return __fwaSend.apply(this, args)
+}
+`;
+/**
+ * Replaces each request's Node-observed timestamp with the page-observed one
+ * where the page saw it, so that mutations and completions share a clock.
+ */
+export function alignToPageClock(requests, completions) {
+    const unused = [...completions];
+    for (const request of requests) {
+        const idx = unused.findIndex((c) => c.url === request.url);
+        if (idx === -1)
+            continue;
+        request.at = unused[idx].at;
+        unused.splice(idx, 1);
+    }
+}
+/**
+ * Credits each DOM mutation to the single most recent response that preceded
+ * it. Marking every response inside a time window instead would be useless on
+ * a fast site, where a decoy landing 1ms before the real response would be
+ * credited with the same mutation.
+ *
+ * `requests` must be in arrival order, which is how the response handler builds it.
+ */
+export function attributeMutations(requests, mutations) {
+    for (const at of mutations) {
+        let cause = null;
+        for (const request of requests) {
+            if (request.at <= at && at - request.at <= DOM_SETTLE_MS)
+                cause = request;
+        }
+        if (cause)
+            cause.domChanged = true;
+    }
+}
+/**
+ * A trace owns the files its large bodies were spilled into, so a caller that
+ * keeps the trace past the call must dispose of it.
+ */
+export async function record(plan, task, sites) {
+    const origin = sites.origin(task.site);
+    const session = await openSession();
+    const actions = [];
+    const pending = [];
+    const bodyReads = [];
+    const bodies = await BodyStore.create();
+    try {
+        await session.page.addInitScript(PAGE_PROBE);
+        session.page.on('response', (response) => {
+            const request = response.request();
+            const contentType = response.headers()['content-type'] ?? null;
+            const entry = {
+                method: request.method(),
+                url: response.url(),
+                resourceType: request.resourceType(),
+                status: response.status(),
+                contentType,
+                body: null,
+                bodyPath: null,
+                bodySize: 0,
+                truncated: false,
+                postData: request.postData(),
+                requestHeaders: request.headers(),
+                at: Date.now(),
+                afterAction: actions.length === 0 ? null : actions.length - 1,
+                domChanged: false,
+            };
+            pending.push(entry);
+            if (contentType && /json|text\/plain|text\/html/.test(contentType)) {
+                bodyReads.push(response
+                    .body()
+                    .then(async (buf) => {
+                    Object.assign(entry, await bodies.put(`${entry.method} ${entry.url} ${entry.at}`, buf));
+                })
+                    .catch(() => undefined));
+            }
+        });
+        const target = plan.url(origin, task);
+        actions.push({ index: 0, type: 'navigate', value: target, at: Date.now() });
+        await navigateAndSettle(session.page, target, plan.itemSelector);
+        const mutations = (await session.page.evaluate('window.__fwaMutations || []'));
+        const completions = (await session.page.evaluate('window.__fwaCompletions || []'));
+        // Align first: attribution compares these timestamps against each other.
+        alignToPageClock(pending, completions);
+        attributeMutations(pending, mutations);
+        const finalHtml = await session.page.content();
+        await Promise.all(bodyReads);
+        return {
+            site: task.site,
+            intent: task.intent,
+            input: task.input,
+            origin,
+            actions,
+            requests: pending,
+            finalHtml,
+            ...(session.page.viewportSize() === null ? {} : { viewport: session.page.viewportSize() }),
+            cost: session.cost,
+            dispose: () => bodies.dispose(),
+        };
+    }
+    finally {
+        await session.close();
+    }
+}

package/dist/src/recorder/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/sites.js

@@ -0,0 +1,45 @@
+export class StaticSiteResolver {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    origin(site) {
+        const origin = this.map[site];
+        if (!origin)
+            throw new Error(`no origin registered for site "${site}"`);
+        return origin;
+    }
+}
+/** Origins for the wild benchmark set. Fixture origins are supplied per-run. */
+export const WILD_ORIGINS = {
+    'pkg.go.dev': 'https://pkg.go.dev',
+    'crates.io': 'https://crates.io',
+    'hn.algolia.com': 'https://hn.algolia.com',
+    // Held-out set: chosen after the engine was written, and run without tuning.
+    'hex.pm': 'https://hex.pm',
+    'docs.rs': 'https://docs.rs',
+    'flathub.org': 'https://flathub.org',
+    'jsr.io': 'https://jsr.io',
+    // Held-out 2: chosen for families the engine has never seen — a forum, two
+    // job boards, a marketplace, and a shadow-DOM SPA.
+    'tildes.net': 'https://tildes.net',
+    'remoteok.com': 'https://remoteok.com',
+    'itch.io': 'https://itch.io',
+    'arbeitnow.com': 'https://www.arbeitnow.com',
+    'archive.org': 'https://archive.org',
+    // Held-out 3: drawn under a frozen pre-registration, four challenge slots and
+    // one positive control. Every one of them disallows /search, so each task
+    // addresses the site's own browse axis instead.
+    'meta.discourse.org': 'https://meta.discourse.org',
+    'loc.gov': 'https://www.loc.gov',
+    'bandcamp.com': 'https://bandcamp.com',
+    'lemmy.world': 'https://lemmy.world',
+    'openlibrary.org': 'https://openlibrary.org',
+    // Held-out 4: two fediverse apps of different software drawn for cursor
+    // pagination, a metadata catalog, a client-heavy forum, and a control.
+    'mastodon.social': 'https://mastodon.social',
+    'pixelfed.social': 'https://pixelfed.social',
+    'musicbrainz.org': 'https://musicbrainz.org',
+    'dev.to': 'https://dev.to',
+    'npmjs.com': 'https://www.npmjs.com',
+};

package/dist/src/tasks.js

@@ -0,0 +1,37 @@
+import { localPaths, verifyReadable, verificationWarnings, UserError } from './local.js';
+import { buildEngine } from './wiring.js';
+import { loadLearnedPlans, mergePlans } from './authoring/plans.js';
+import { PLANS } from '../benchmark/plans.js';
+import { WILD_ORIGINS } from './sites.js';
+/** The hand-written plans, with anything saved layered over them. */
+export async function allPlans(planDir) {
+    const learned = await loadLearnedPlans(planDir);
+    return { plans: mergePlans(PLANS, learned.plans), origins: learned.origins, verifications: learned.verifications };
+}
+/** Every saved task, as `site/intent`, with its storage directory. */
+export async function listTasks(dataDir) {
+    const paths = localPaths(dataDir);
+    const { plans } = await loadLearnedPlans(paths.plans);
+    const tasks = Object.entries(plans).flatMap(([site, intents]) => Object.keys(intents).map((intent) => `${site}/${intent}`));
+    return { root: paths.root, tasks };
+}
+export async function fetchTask(site, intent, input, opts = {}) {
+    const paths = localPaths(opts.dataDir);
+    const { plans, origins, verifications } = await allPlans(paths.plans);
+    const plan = plans[site]?.[intent];
+    if (!plan)
+        throw new UserError('NOT_TAUGHT', `No recipe saved as ${site}/${intent}. Run inspect on the page, then save.`);
+    // Reject missing placeholders before starting a browser or making a request.
+    plan.url(origins[site] ?? WILD_ORIGINS[site], { id: 'check', site, intent, input });
+    const engine = buildEngine({ recipeDir: paths.recipes, plans, origins, heal: opts.heal });
+    try {
+        const outcome = await engine.executor.run({ id: opts.runId ?? 'fetch', site, intent, input });
+        const verification = verifyReadable(outcome.items, Object.keys(plan.fields), verifications[site]?.[intent]);
+        // Derived from the checks, so a run that proves more says less.
+        const warnings = [...outcome.reasons, ...verificationWarnings(verification)];
+        return { outcome, verification, warnings };
+    }
+    finally {
+        await engine.warm.close();
+    }
+}

package/dist/src/types.js

@@ -0,0 +1,32 @@
+/**
+ * What a task cost in total, not what the attempt that happened to answer it
+ * cost. A run that tried a recipe, lost, fell back to a browser and re-recorded
+ * on the way paid for all three; reporting only the last describes a cheaper
+ * run than the one that happened.
+ *
+ * `answered` is the attempt that produced the items, so it keeps the strategy
+ * name and the token count: the agent reads one answer, not three.
+ */
+export function addMeta(answered, ...spent) {
+    return spent.reduce((total, one) => ({
+        ...total,
+        latencyMs: total.latencyMs + one.latencyMs,
+        browserLaunches: total.browserLaunches + one.browserLaunches,
+        pageNavigations: total.pageNavigations + one.pageNavigations,
+        networkRequests: total.networkRequests + one.networkRequests,
+        bytesDownloaded: total.bytesDownloaded + one.bytesDownloaded,
+        politenessWaitMs: total.politenessWaitMs + one.politenessWaitMs,
+    }), answered);
+}
+export function emptyMeta(strategy) {
+    return {
+        strategy,
+        latencyMs: 0,
+        browserLaunches: 0,
+        pageNavigations: 0,
+        networkRequests: 0,
+        bytesDownloaded: 0,
+        llmTokens: 0,
+        politenessWaitMs: 0,
+    };
+}