@jitsusama/agentic-harness.core 0.1.0

package/dist/web/environment/view.js

@@ -0,0 +1,42 @@
+/**
+ * Reading the emulated environment back.
+ *
+ * Led by what the page observes rather than by what was asked
+ * for, so a setting that did not take cannot read as though it
+ * did.
+ */
+/** What the page is experiencing, and where that differs from the ask. */
+export function renderEnvironment(asked, observed, gaps) {
+    const lines = [
+        "The page reports:",
+        `  ${observed.width} by ${observed.height} at ${observed.devicePixelRatio}x`,
+        `  colour scheme ${observed.colorScheme}` +
+            `, contrast ${observed.contrast}` +
+            `, reduced motion ${observed.reducedMotion ? "on" : "off"}` +
+            `, forced colours ${observed.forcedColors ? "on" : "off"}`,
+        `  ${observed.language} in ${observed.timezone}`,
+        `  ${observed.maxTouchPoints > 0
+            ? `${observed.maxTouchPoints} touch points`
+            : "no touch"}${observed.touchEvents ? ", touch events present" : ""}` +
+            `${observed.print ? ", print stylesheet active" : ""}`,
+    ];
+    // Vision deficiency is a filter over what is painted, so no
+    // media query reports it and the page cannot be asked. It is
+    // the one thing here that has to be taken on our own word.
+    if (asked.vision !== undefined && asked.vision !== "none") {
+        lines.push(`  simulating ${asked.vision}, which paints differently but is ` +
+            "invisible to the page's own scripts");
+    }
+    if (asked.cpuThrottle !== undefined && asked.cpuThrottle > 1) {
+        lines.push(`  cpu slowed ${asked.cpuThrottle} times`);
+    }
+    if (gaps.length > 0) {
+        lines.push("", "Asked for, but not what the page sees:");
+        for (const gap of gaps) {
+            lines.push(`  ${gap.what}: asked ${gap.asked}, got ${gap.observed}`);
+            if (gap.note)
+                lines.push(`    ${gap.note}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/web/evaluate/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Running an expression in the page, and reading back what it
+ * said, including how it failed.
+ */
+export { describeThrow, type EvalFrame, type EvalOutcome, type EvalThrew, type EvalValue, MAX_INLINE_RESULT, type RawExceptionDetails, renderEvaluation, } from "./outcome.js";
+export { evaluationSource, SERIALIZE_BREADTH, SERIALIZE_DEPTH, SERIALIZE_STRING, } from "./probe.js";

package/dist/web/evaluate/index.js

@@ -0,0 +1,6 @@
+/**
+ * Running an expression in the page, and reading back what it
+ * said, including how it failed.
+ */
+export { describeThrow, MAX_INLINE_RESULT, renderEvaluation, } from "./outcome.js";
+export { evaluationSource, SERIALIZE_BREADTH, SERIALIZE_DEPTH, SERIALIZE_STRING, } from "./probe.js";

package/dist/web/evaluate/outcome.d.ts

@@ -0,0 +1,74 @@
+/**
+ * What came back from running an expression in the page.
+ *
+ * An exception is a result, not an error to swallow: running
+ * code against a live page to find out how it fails is the whole
+ * point of being able to run code against a live page.
+ */
+import type { AuthoredPosition } from "../sourcemap/index.js";
+/** One frame of a page-side stack. */
+export interface EvalFrame {
+    readonly functionName: string;
+    readonly url: string;
+    readonly lineNumber: number;
+    readonly columnNumber: number;
+    /** Where the frame was authored, when a source map said. */
+    readonly authored?: AuthoredPosition;
+}
+/** The page threw. */
+export interface EvalThrew {
+    readonly message: string;
+    readonly className?: string;
+    readonly frames: readonly EvalFrame[];
+    /** Whether it came out of a promise rather than directly. */
+    readonly fromPromise: boolean;
+}
+/** The page answered. */
+export interface EvalValue {
+    readonly type: string;
+    readonly value: unknown;
+    /** Whether anything was left out to keep the answer a size. */
+    readonly clipped: boolean;
+}
+/** How an evaluation ended. */
+export type EvalOutcome = {
+    readonly ok: true;
+    readonly result: EvalValue;
+} | {
+    readonly ok: false;
+    readonly threw: EvalThrew;
+} | {
+    readonly ok: false;
+    readonly refused: string;
+};
+/** Runtime.exceptionDetails, as the protocol sends it. */
+export interface RawExceptionDetails {
+    readonly text?: string;
+    readonly lineNumber?: number;
+    readonly columnNumber?: number;
+    readonly exception?: {
+        readonly className?: string;
+        readonly description?: string;
+    };
+    readonly stackTrace?: {
+        readonly callFrames?: readonly {
+            readonly functionName?: string;
+            readonly url?: string;
+            readonly lineNumber?: number;
+            readonly columnNumber?: number;
+        }[];
+    };
+}
+/**
+ * Read the protocol's account of a thrown exception.
+ *
+ * The useful message is on the exception's description, not on
+ * the details' text, which is only ever "Uncaught" or "Uncaught
+ * (in promise)". Reporting the text would tell the caller
+ * nothing they did not already know.
+ */
+export declare function describeThrow(details: RawExceptionDetails): EvalThrew;
+/** How much of a rendered value to inline before diverting it. */
+export declare const MAX_INLINE_RESULT = 4096;
+/** Say what happened. */
+export declare function renderEvaluation(outcome: EvalOutcome): string;

package/dist/web/evaluate/outcome.js

@@ -0,0 +1,91 @@
+/**
+ * What came back from running an expression in the page.
+ *
+ * An exception is a result, not an error to swallow: running
+ * code against a live page to find out how it fails is the whole
+ * point of being able to run code against a live page.
+ */
+/**
+ * Read the protocol's account of a thrown exception.
+ *
+ * The useful message is on the exception's description, not on
+ * the details' text, which is only ever "Uncaught" or "Uncaught
+ * (in promise)". Reporting the text would tell the caller
+ * nothing they did not already know.
+ */
+export function describeThrow(details) {
+    const description = details.exception?.description;
+    const message = description ?? details.text ?? "Something threw.";
+    return {
+        // The description carries its own stack after the first
+        // line, which the frames already say more precisely.
+        message: message.split("\n")[0] ?? message,
+        ...(details.exception?.className === undefined
+            ? {}
+            : { className: details.exception.className }),
+        frames: (details.stackTrace?.callFrames ?? []).map((frame) => ({
+            functionName: frame.functionName || "(anonymous)",
+            url: frame.url ?? "",
+            lineNumber: frame.lineNumber ?? 0,
+            columnNumber: frame.columnNumber ?? 0,
+        })),
+        fromPromise: (details.text ?? "").includes("in promise"),
+    };
+}
+/** How much of a rendered value to inline before diverting it. */
+export const MAX_INLINE_RESULT = 4096;
+/**
+ * Say where a frame is, preferring where it was written.
+ *
+ * The generated position is kept beside the authored one rather
+ * than replaced by it. They disagree often enough, through a
+ * stale map or a bundler quirk, that hiding what the browser
+ * actually reported would remove the only way to notice.
+ */
+function describeFrame(frame) {
+    const generated = `${frame.url}:${frame.lineNumber + 1}:${frame.columnNumber}`;
+    if (!frame.authored)
+        return generated;
+    const { source, line, column, name } = frame.authored;
+    const called = name === undefined ? "" : ` (${name})`;
+    return `${source}:${line + 1}:${column}${called}\n    built from ${generated}`;
+}
+/** Say what happened. */
+export function renderEvaluation(outcome) {
+    if (!outcome.ok && "refused" in outcome)
+        return outcome.refused;
+    if (!outcome.ok) {
+        const { threw } = outcome;
+        const lines = [
+            threw.fromPromise
+                ? `The page rejected: ${threw.message}`
+                : `The page threw: ${threw.message}`,
+        ];
+        // A stack of one anonymous frame at the top of the
+        // expression says only what the message already said.
+        const useful = threw.frames.filter((frame) => frame.url !== "" || frame.functionName !== "(anonymous)");
+        if (useful.length > 0) {
+            lines.push("");
+            for (const frame of useful) {
+                lines.push(`  ${frame.functionName} ${describeFrame(frame)}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    const { result } = outcome;
+    if (result.type === "undefined" || result.value === "[undefined]") {
+        return "The expression returned undefined.";
+    }
+    const body = typeof result.value === "string"
+        ? result.value
+        : JSON.stringify(result.value, null, 2);
+    const head = `${result.type}:`;
+    if (body.length <= MAX_INLINE_RESULT) {
+        return result.clipped
+            ? `${head} ${body}\n\n(Parts were left out to keep this a size.)`
+            : `${head} ${body}`;
+    }
+    return (`${head} ${body.slice(0, MAX_INLINE_RESULT)}\n\n` +
+        `... ${body.length - MAX_INLINE_RESULT} more characters. Narrow the ` +
+        `expression, or pick out the part you want.`);
+}

package/dist/web/evaluate/probe.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Turning a page value into something that can be carried back.
+ *
+ * Serialization happens in the page, not in the protocol, and
+ * that is a deliberate choice rather than a convenience. Asking
+ * the protocol to return a circular object by value does not
+ * fail politely: it rejects the whole call with "object
+ * reference chain is too long", which takes the evaluation and
+ * any honest report of it down together. A DOM node and a
+ * function fare no better, coming back as an empty object that
+ * says nothing about what they were.
+ *
+ * This is a presentational judgment and is labelled as one. What
+ * a value *is* comes from the browser; how it reads once it has
+ * crossed the wire is ours to decide.
+ *
+ * It ships as a source string because it declares helpers of its
+ * own, and the bundler rewrites every named inner binding
+ * through a wrapper the page has never heard of.
+ */
+/** How deep into a structure to go before saying "more". */
+export declare const SERIALIZE_DEPTH = 4;
+/** How many entries of a collection to show. */
+export declare const SERIALIZE_BREADTH = 30;
+/** How long a single string may be before it is clipped. */
+export declare const SERIALIZE_STRING = 2048;
+/**
+ * Build the expression that evaluates a caller's code and
+ * describes whatever comes back.
+ */
+export declare function evaluationSource(expression: string): string;

package/dist/web/evaluate/probe.js

@@ -0,0 +1,303 @@
+/**
+ * Turning a page value into something that can be carried back.
+ *
+ * Serialization happens in the page, not in the protocol, and
+ * that is a deliberate choice rather than a convenience. Asking
+ * the protocol to return a circular object by value does not
+ * fail politely: it rejects the whole call with "object
+ * reference chain is too long", which takes the evaluation and
+ * any honest report of it down together. A DOM node and a
+ * function fare no better, coming back as an empty object that
+ * says nothing about what they were.
+ *
+ * This is a presentational judgment and is labelled as one. What
+ * a value *is* comes from the browser; how it reads once it has
+ * crossed the wire is ours to decide.
+ *
+ * It ships as a source string because it declares helpers of its
+ * own, and the bundler rewrites every named inner binding
+ * through a wrapper the page has never heard of.
+ */
+/** How deep into a structure to go before saying "more". */
+export const SERIALIZE_DEPTH = 4;
+/** How many entries of a collection to show. */
+export const SERIALIZE_BREADTH = 30;
+/** How long a single string may be before it is clipped. */
+export const SERIALIZE_STRING = 2048;
+/**
+ * Whether a source text is a single JavaScript expression.
+ *
+ * Decided here rather than in the page. The page could answer it
+ * with new Function, but that is exactly what a strict
+ * Content-Security-Policy forbids, and an inspection tool must
+ * not fail on the pages most worth inspecting. The grammar is
+ * the same in both runtimes, and compiling is not running: this
+ * never executes the caller's code, so a reference to a page
+ * global that does not exist here is irrelevant.
+ */
+function isExpression(source) {
+    try {
+        new Function(`return (${source});`);
+        return true;
+    }
+    catch {
+        // A syntax error means it is not one expression. Whether it is
+        // valid at all is the page's business to report, not ours.
+        return false;
+    }
+}
+/**
+ * The offsets of semicolons that end a statement at the top
+ * level, ignoring any inside brackets, strings, templates,
+ * regular expressions or comments.
+ *
+ * Enough to find where the last statement begins. Anything it
+ * gets wrong is caught by compiling the result before use, so a
+ * wrong guess costs the old behaviour rather than a broken call.
+ */
+function topLevelBreaks(source) {
+    const breaks = [];
+    let depth = 0;
+    let quote = null;
+    let comment = null;
+    for (let at = 0; at < source.length; at++) {
+        const char = source[at];
+        const next = source[at + 1];
+        if (comment === "line") {
+            if (char === "\n")
+                comment = null;
+            continue;
+        }
+        if (comment === "block") {
+            if (char === "*" && next === "/") {
+                comment = null;
+                at++;
+            }
+            continue;
+        }
+        if (quote) {
+            if (char === "\\")
+                at++;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            comment = "line";
+            at++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            comment = "block";
+            at++;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "(" || char === "[" || char === "{")
+            depth++;
+        else if (char === ")" || char === "]" || char === "}")
+            depth--;
+        else if (char === ";" && depth === 0)
+            breaks.push(at);
+    }
+    return breaks;
+}
+/**
+ * A statement list rewritten so its last expression is its value.
+ *
+ * A console shows the completion value of what you typed, so
+ * `var a = 1; a + 41` answers 42. Run as a plain function body it
+ * answers undefined, because a function returns nothing unless
+ * told to, and that is what this used to do: people paste a
+ * snippet ending in the thing they want to see and got nothing
+ * back, then retyped it with a return. Nobody reads that as the
+ * tool being careful.
+ *
+ * Rewriting rather than using the page's own eval, which would
+ * give these semantics for free, because a page whose policy
+ * forbids eval must still be able to answer.
+ *
+ * Returns undefined when the last statement is not an expression
+ * (a declaration, a loop, a block), since prefixing those with
+ * return is a syntax error. The rewrite is compiled here before
+ * it is offered, so a wrong guess falls back instead of failing
+ * in the page.
+ */
+function withCompletionValue(source) {
+    const trimmed = source.trimEnd().replace(/;$/, "");
+    const breaks = topLevelBreaks(trimmed);
+    const lastBreak = breaks[breaks.length - 1];
+    if (lastBreak === undefined)
+        return undefined;
+    const head = trimmed.slice(0, lastBreak + 1);
+    const tail = trimmed.slice(lastBreak + 1).trim();
+    if (tail === "")
+        return undefined;
+    const rewritten = `${head} return (${tail});`;
+    try {
+        new Function(rewritten);
+        return rewritten;
+    }
+    catch {
+        // The last statement was not an expression, so it cannot be
+        // returned. The caller still gets the statement list.
+        return undefined;
+    }
+}
+/**
+ * How the caller's code is turned into one value.
+ *
+ * An expression is parenthesized so an object literal reads as a
+ * value rather than a block, which is the syntax people trip
+ * over constantly. Anything else is run as a statement list, the
+ * way a console accepts one, because `scrollTo(0, 400); check()`
+ * is a thing people type and it used to come back as
+ * "SyntaxError: Unexpected token ';'", which reads as the
+ * caller's mistake rather than ours. A statement list answers
+ * with its last expression, as a console does, and an explicit
+ * return still wins.
+ */
+function producer(expression) {
+    if (isExpression(expression))
+        return `(${expression})`;
+    const completing = withCompletionValue(expression);
+    return `(() => { ${completing ?? expression} })()`;
+}
+/**
+ * Build the expression that evaluates a caller's code and
+ * describes whatever comes back.
+ */
+export function evaluationSource(expression) {
+    return `(() => {
+	const DEPTH = ${SERIALIZE_DEPTH};
+	const BREADTH = ${SERIALIZE_BREADTH};
+	const STRING = ${SERIALIZE_STRING};
+	// The chain of ancestors currently being walked, not every
+	// object ever seen: a value reachable by two paths is shared,
+	// and only a value that contains itself is circular.
+	const path = new Set();
+	let clipped = false;
+
+	const describeNode = (node) => {
+		if (node.nodeType === 3) return "#text " + JSON.stringify(
+			(node.nodeValue || "").slice(0, 40));
+		if (node.nodeType === 9) return "#document";
+		const id = node.id ? "#" + node.id : "";
+		const cls = node.classList && node.classList.length
+			? "." + [...node.classList].join(".") : "";
+		return "<" + node.tagName.toLowerCase() + id + cls + ">";
+	};
+
+	const walk = (value, depth) => {
+		if (value === null) return null;
+		const kind = typeof value;
+		if (kind === "undefined") return "[undefined]";
+		if (kind === "boolean") return value;
+		// JSON has no NaN and no Infinity, so passing them straight
+		// through turned three of the answers a console most often
+		// gives into "number: null", which is a wrong answer wearing a
+		// right one's clothes. bigint below is tagged for this reason.
+		if (kind === "number") {
+			return Number.isFinite(value) ? value : String(value);
+		}
+		if (kind === "bigint") return String(value) + "n";
+		if (kind === "symbol") return String(value);
+		if (kind === "string") {
+			if (value.length <= STRING) return value;
+			clipped = true;
+			return value.slice(0, STRING) + "... (" + value.length + " chars)";
+		}
+		if (kind === "function") {
+			return "[function " + (value.name || "anonymous") + "]";
+		}
+
+		if (value instanceof Error) {
+			return "[" + value.name + ": " + value.message + "]";
+		}
+		if (typeof Node !== "undefined" && value instanceof Node) {
+			return describeNode(value);
+		}
+		if (typeof Window !== "undefined" && value instanceof Window) {
+			return "[window]";
+		}
+
+		// Circularity is checked before descending, so a structure
+		// that points at itself is named rather than followed.
+		//
+		// Only an ancestor counts. This used to be every object ever
+		// visited, never unwound, so an object holding the same store
+		// under two keys reported the second as circular when nothing
+		// pointed at itself. The unwind is in the finally below so no
+		// branch can forget it.
+		if (path.has(value)) return "[circular]";
+		path.add(value);
+		try {
+			return descend(value, depth);
+		} finally {
+			path.delete(value);
+		}
+	};
+
+	const descend = (value, depth) => {
+		if (depth >= DEPTH) {
+			clipped = true;
+			return Array.isArray(value) ? "[array, deeper]" : "[object, deeper]";
+		}
+
+		if (Array.isArray(value)) {
+			const shown = value.slice(0, BREADTH).map((item) => walk(item, depth + 1));
+			if (value.length > BREADTH) {
+				clipped = true;
+				shown.push("... " + (value.length - BREADTH) + " more");
+			}
+			return shown;
+		}
+		if (value instanceof Map || value instanceof Set) {
+			const items = [...value].slice(0, BREADTH)
+				.map((item) => walk(item, depth + 1));
+			if (value.size > BREADTH) {
+				clipped = true;
+				items.push("... " + (value.size - BREADTH) + " more");
+			}
+			return { ["[" + value.constructor.name + "]"]: items };
+		}
+		if (typeof NodeList !== "undefined" && value instanceof NodeList) {
+			return [...value].slice(0, BREADTH).map(describeNode);
+		}
+
+		const out = {};
+		const keys = Object.keys(value);
+		for (const key of keys.slice(0, BREADTH)) {
+			try {
+				out[key] = walk(value[key], depth + 1);
+			} catch (error) {
+				// A getter that throws is the page's problem, not a
+				// reason to lose everything else on the object.
+				out[key] = "[threw: " + error.message + "]";
+			}
+		}
+		if (keys.length > BREADTH) {
+			clipped = true;
+			out["..."] = (keys.length - BREADTH) + " more keys";
+		}
+		return out;
+	};
+
+	const typeOf = (value) => {
+		if (value === null) return "null";
+		if (Array.isArray(value)) return "array";
+		if (typeof Node !== "undefined" && value instanceof Node) return "node";
+		return typeof value;
+	};
+
+	const value = ${producer(expression)};
+	return Promise.resolve(value).then((settled) => ({
+		type: typeOf(settled),
+		value: walk(settled, 0),
+		clipped,
+	}));
+})()`;
+}

package/dist/web/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Driving a browser, and reading back everything it knows.
+ *
+ * This barrel is the front door: the session that drives a real
+ * Chrome, the one-shot page reader, and web search. Everything
+ * else lives in a subdomain barrel beside it, because the whole
+ * surface in one namespace would be several hundred names, and
+ * a consumer who wants contrast arithmetic should not have to
+ * load a browser to get it.
+ *
+ * The subdomains, and what each is for:
+ *
+ * - `a11y/`      the accessibility tree, reading order, live
+ *                region announcements, keyboard walks
+ * - `audit/`     verdicts: axe, structural and layout rules,
+ *                contrast and target-size arithmetic, sweeps
+ * - `compare/`   diffing a page against a baseline of itself
+ * - `design/`    what a page is built from, and its drift
+ * - `element/`   one element in depth: box, styles, listeners,
+ *                animations, actionability
+ * - `envelope/`  paging, budgets and the on-disk artifact sink
+ * - `environment/` emulation, storage, network shaping, status
+ * - `evaluate/`  running an expression and surviving the result
+ * - `input/`     key chords, pointer paths, touch gestures
+ * - `perf/`      web vitals from the browser's own observers
+ * - `snapshot/`  the whole page flattened, frames and shadow
+ *                content included, and queries over it
+ * - `sourcemap/` where generated code was authored
+ * - `styles/`    computed style curation and cascade tracing
+ * - `target/`    naming an element by role and accessible name
+ * - `telemetry/` console, network, dialogs, downloads, lifecycle
+ * - `wait/`      conditions worth waiting for
+ *
+ * Every subdomain but `session` is pure and capture-agnostic:
+ * serializable data in, answers out. That is what lets the same
+ * analysis run against a live page, a stored capture, or one
+ * taken by something that is not this library at all. Only
+ * `session` and `browser` reach for puppeteer, so importing an
+ * analysis module never starts a browser.
+ */
+export { type AxNode, type AxProperties, normalizeAxTree, type RawAxNode, renderAxOutline, } from "./a11y/index.js";
+export { BrowserLaunchFailed, closeBrowser, killBrowserSync, } from "./browser.js";
+export { type MermaidRender, MermaidRenderError, renderMermaid, } from "./mermaid.js";
+export { AuthSetupNeeded, cleanupSessionBundles, type PageBundle, readPage, reapAbandonedBundles, } from "./reader.js";
+export { type SearchResult, webSearch } from "./search.js";
+export { type ActResult, BrowserSession, type Observation, type PageAction, } from "./session.js";
+export { resolveTarget, type Target as SemanticTarget, type TargetResolution, } from "./target/index.js";

package/dist/web/index.js

@@ -0,0 +1,47 @@
+/**
+ * Driving a browser, and reading back everything it knows.
+ *
+ * This barrel is the front door: the session that drives a real
+ * Chrome, the one-shot page reader, and web search. Everything
+ * else lives in a subdomain barrel beside it, because the whole
+ * surface in one namespace would be several hundred names, and
+ * a consumer who wants contrast arithmetic should not have to
+ * load a browser to get it.
+ *
+ * The subdomains, and what each is for:
+ *
+ * - `a11y/`      the accessibility tree, reading order, live
+ *                region announcements, keyboard walks
+ * - `audit/`     verdicts: axe, structural and layout rules,
+ *                contrast and target-size arithmetic, sweeps
+ * - `compare/`   diffing a page against a baseline of itself
+ * - `design/`    what a page is built from, and its drift
+ * - `element/`   one element in depth: box, styles, listeners,
+ *                animations, actionability
+ * - `envelope/`  paging, budgets and the on-disk artifact sink
+ * - `environment/` emulation, storage, network shaping, status
+ * - `evaluate/`  running an expression and surviving the result
+ * - `input/`     key chords, pointer paths, touch gestures
+ * - `perf/`      web vitals from the browser's own observers
+ * - `snapshot/`  the whole page flattened, frames and shadow
+ *                content included, and queries over it
+ * - `sourcemap/` where generated code was authored
+ * - `styles/`    computed style curation and cascade tracing
+ * - `target/`    naming an element by role and accessible name
+ * - `telemetry/` console, network, dialogs, downloads, lifecycle
+ * - `wait/`      conditions worth waiting for
+ *
+ * Every subdomain but `session` is pure and capture-agnostic:
+ * serializable data in, answers out. That is what lets the same
+ * analysis run against a live page, a stored capture, or one
+ * taken by something that is not this library at all. Only
+ * `session` and `browser` reach for puppeteer, so importing an
+ * analysis module never starts a browser.
+ */
+export { normalizeAxTree, renderAxOutline, } from "./a11y/index.js";
+export { BrowserLaunchFailed, closeBrowser, killBrowserSync, } from "./browser.js";
+export { MermaidRenderError, renderMermaid, } from "./mermaid.js";
+export { AuthSetupNeeded, cleanupSessionBundles, readPage, reapAbandonedBundles, } from "./reader.js";
+export { webSearch } from "./search.js";
+export { BrowserSession, } from "./session.js";
+export { resolveTarget, } from "./target/index.js";

package/dist/web/input/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Raw input: chords, pointer gestures and touch gestures.
+ *
+ * Everything here is pure composition. A gesture is described as
+ * the ordered events a real hand would produce, and dispatching
+ * them is the session's job, so the shape of an interaction can
+ * be checked without a browser.
+ */
+export { type Chord, type ChordRefusal, MODIFIER_BITS, type ModifierName, parseChords, } from "./keys.js";
+export { composeClick, composeDrag, type DragOptions, interpolate, type MouseButton, type Point, type PointerEventStep, ratios, } from "./pointer.js";
+export { composeLongPress, composePinch, composeSwipe, composeTap, LONG_PRESS_MS, type TouchPoint, type TouchStep, } from "./touch.js";

package/dist/web/input/index.js

@@ -0,0 +1,11 @@
+/**
+ * Raw input: chords, pointer gestures and touch gestures.
+ *
+ * Everything here is pure composition. A gesture is described as
+ * the ordered events a real hand would produce, and dispatching
+ * them is the session's job, so the shape of an interaction can
+ * be checked without a browser.
+ */
+export { MODIFIER_BITS, parseChords, } from "./keys.js";
+export { composeClick, composeDrag, interpolate, ratios, } from "./pointer.js";
+export { composeLongPress, composePinch, composeSwipe, composeTap, LONG_PRESS_MS, } from "./touch.js";