waygraph 0.15.47 → 0.15.49

package/dist/auto-session-ipc.js

@@ -1,497 +0,0 @@
-/**
- * Unix-socket transport for `waygraph auto --cli --detach` / `send` / `status` /
- * `attach`. Session identity lives under a per-project `.waygraph-auto/`
- * directory, mirroring the existing `.waygraph-traverse/` dotdir convention.
- * See openspec/changes/waygraph-auto-cli-session-control.
- */
-import { createServer, connect } from "node:net";
-import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync, openSync, } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { randomBytes } from "node:crypto";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { AutoSession, } from "./auto-session.js";
-function sessionDir(projectDir) {
-    return join(projectDir, ".waygraph-auto");
-}
-function metaPath(projectDir, sessionId) {
-    return join(sessionDir(projectDir), `${sessionId}.json`);
-}
-/** Global index so session control works even when cwd ≠ the project that spawned the session. */
-function globalMetaPath(sessionId) {
-    return join(socketDir(), `${sessionId}.meta.json`);
-}
-function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Deliberately NOT under the project directory (unlike meta/log files) -
- * a real bug found while proving out openspec/changes/waygraph-map's own
- * "waypack" loading claim: a project loaded through a consumer's own deeply
- * nested `node_modules/<pkg>` path can push the socket's absolute path past
- * the OS's AF_UNIX `sun_path` limit (~108 bytes on Linux), failing with
- * `listen EINVAL`. A short, fixed-location directory sidesteps this
- * regardless of how deep `projectDir` itself is nested. `sessionId` alone
- * (8 hex chars, `generateSessionId()`) is enough to keep this collision-safe
- * across every project on the machine sharing this one flat directory - the
- * same randomness space this package already relied on per-project.
- */
-function socketDir() {
-    return join(tmpdir(), "waygraph-auto");
-}
-function socketPathFor(sessionId) {
-    return join(socketDir(), `${sessionId}.sock`);
-}
-function logPathFor(projectDir, sessionId) {
-    return join(sessionDir(projectDir), `${sessionId}.log`);
-}
-function generateSessionId() {
-    return randomBytes(4).toString("hex");
-}
-export function readSessionMeta(projectDir, sessionId) {
-    const p = metaPath(projectDir, sessionId);
-    if (!existsSync(p))
-        return null;
-    try {
-        return JSON.parse(readFileSync(p, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Resolve session metadata from a project hint (cwd) or the global registry.
- * Fixes "session unreachable" when the agent calls status/send from a different
- * directory or pane than the one that ran `pilot start`.
- */
-export function resolveSessionMeta(sessionId, projectDirHint) {
-    if (projectDirHint) {
-        const local = readSessionMeta(projectDirHint, sessionId);
-        if (local)
-            return local;
-    }
-    const globalPath = globalMetaPath(sessionId);
-    if (existsSync(globalPath)) {
-        try {
-            return JSON.parse(readFileSync(globalPath, "utf-8"));
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-function writeGlobalSessionMeta(meta) {
-    mkdirSync(socketDir(), { recursive: true });
-    writeFileSync(globalMetaPath(meta.sessionId), JSON.stringify(meta, null, 2));
-}
-function removeSessionFiles(projectDir, sessionId) {
-    for (const p of [
-        metaPath(projectDir, sessionId),
-        globalMetaPath(sessionId),
-        socketPathFor(sessionId),
-    ]) {
-        try {
-            rmSync(p, { force: true });
-        }
-        catch {
-            /* ignore */
-        }
-    }
-}
-/** Reads newline-delimited JSON off a socket, one message at a time. */
-function readOneMessage(sock, timeoutMs) {
-    return new Promise((resolvePromise, reject) => {
-        let buf = "";
-        const timer = setTimeout(() => {
-            cleanup();
-            reject(new Error(`timed out after ${timeoutMs}ms waiting for a response`));
-        }, timeoutMs);
-        const onData = (chunk) => {
-            buf += chunk.toString("utf-8");
-            const nl = buf.indexOf("\n");
-            if (nl === -1)
-                return;
-            const line = buf.slice(0, nl);
-            cleanup();
-            try {
-                resolvePromise(JSON.parse(line));
-            }
-            catch (err) {
-                reject(new Error(`malformed response: ${err instanceof Error ? err.message : String(err)}`));
-            }
-        };
-        const onError = (err) => {
-            cleanup();
-            reject(err);
-        };
-        const onClose = () => {
-            cleanup();
-            reject(new Error("connection closed before a response arrived"));
-        };
-        function cleanup() {
-            clearTimeout(timer);
-            sock.off("data", onData);
-            sock.off("error", onError);
-            sock.off("close", onClose);
-        }
-        sock.on("data", onData);
-        sock.on("error", onError);
-        sock.on("close", onClose);
-    });
-}
-export async function requestSession(projectDir, sessionId, request, timeoutMs = 15_000) {
-    const meta = resolveSessionMeta(sessionId, projectDir);
-    if (!meta) {
-        return {
-            ok: false,
-            error: `no such session "${sessionId}" (no metadata under ${projectDir}/.waygraph-auto/ or global registry) — ` +
-                "run from the project that started the session, or `waygraph pilot sessions` to list live ids",
-        };
-    }
-    if (!isPidAlive(meta.pid)) {
-        removeSessionFiles(meta.projectDir, sessionId);
-        return {
-            ok: false,
-            error: `session "${sessionId}" is not running (pid ${meta.pid} exited) — start a new session with pilot/browser start`,
-        };
-    }
-    return new Promise((resolvePromise) => {
-        const sock = connect(meta.socketPath);
-        const connectTimer = setTimeout(() => {
-            sock.destroy();
-            resolvePromise({ ok: false, error: `session "${sessionId}" is unreachable (socket did not respond)` });
-        }, timeoutMs);
-        sock.on("connect", () => {
-            sock.write(JSON.stringify(request) + "\n");
-        });
-        sock.on("error", () => {
-            clearTimeout(connectTimer);
-            resolvePromise({
-                ok: false,
-                error: `session "${sessionId}" is unreachable (stale socket - the process may have crashed)`,
-            });
-        });
-        readOneMessage(sock, timeoutMs)
-            .then((res) => {
-            clearTimeout(connectTimer);
-            resolvePromise(res);
-        })
-            .catch((err) => {
-            clearTimeout(connectTimer);
-            resolvePromise({ ok: false, error: err instanceof Error ? err.message : String(err) });
-        })
-            .finally(() => sock.end());
-    });
-}
-/**
- * Server-side: runs `session` behind a unix socket at
- * `.waygraph-auto/<sessionId>.sock`, writing session metadata only once the
- * socket is actually listening (the metadata file's existence is the
- * "session is ready" signal a spawning parent polls for). Requests are
- * processed one at a time via a queue - Node's single-threaded event loop
- * already prevents true parallelism, but two overlapping `await`-heavy
- * handlers could still interleave against the same page/mem.
- */
-export async function serveSession(session, projectDir, sessionId, headless = true) {
-    mkdirSync(sessionDir(projectDir), { recursive: true });
-    mkdirSync(socketDir(), { recursive: true });
-    const socketPath = socketPathFor(sessionId);
-    rmSync(socketPath, { force: true });
-    let queue = Promise.resolve();
-    const enqueue = (fn) => {
-        const next = queue.then(fn, fn);
-        queue = next.catch(() => { });
-        return next;
-    };
-    const server = createServer((sock) => {
-        let buf = "";
-        sock.on("data", (chunk) => {
-            buf += chunk.toString("utf-8");
-            let nl;
-            while ((nl = buf.indexOf("\n")) !== -1) {
-                const line = buf.slice(0, nl);
-                buf = buf.slice(nl + 1);
-                void handleLine(line, sock);
-            }
-        });
-    });
-    async function handleLine(line, sock) {
-        let request;
-        try {
-            request = JSON.parse(line);
-        }
-        catch {
-            sock.write(JSON.stringify({ ok: false, error: "malformed request (invalid JSON)" }) + "\n");
-            return;
-        }
-        await enqueue(async () => {
-            let response;
-            let shouldQuit = false;
-            try {
-                if (request.op === "status") {
-                    response = { ok: true, snapshot: await session.currentSnapshot(), quit: false };
-                }
-                else if (request.op === "send") {
-                    const result = await session.applyPick(request.pick);
-                    response = result.ok
-                        ? { ok: true, snapshot: result.snapshot, quit: result.quit }
-                        : { ok: false, error: result.error };
-                    shouldQuit = result.ok && result.quit;
-                }
-                else if (request.op === "dom") {
-                    const { op: _op, ...domOpts } = request;
-                    response = await session.inspectDom(domOpts);
-                }
-                else if (request.op === "trace") {
-                    response = { ok: true, trace: session.getTrace() };
-                }
-                else if (request.op === "console") {
-                    response = { ok: true, consoleLog: session.getConsoleLog() };
-                }
-                else if (request.op === "storage") {
-                    response = { ok: true, ...(await session.inspectStorage()) };
-                }
-                else if (request.op === "upload") {
-                    response = await session.rawUpload(request.selector, request.stub);
-                }
-                else if (request.op === "click") {
-                    response = await session.rawClick(request.selector);
-                }
-                else if (request.op === "type") {
-                    response = await session.rawType(request.selector, request.text);
-                }
-                else if (request.op === "press") {
-                    response = await session.rawPress(request.selector, request.key);
-                }
-                else if (request.op === "goto") {
-                    response = await session.rawGoto(request.url);
-                }
-                else if (request.op === "reload") {
-                    await session.reloadLibrary();
-                    response = { ok: true, snapshot: await session.currentSnapshot(), quit: false };
-                }
-                else if (request.op === "reach") {
-                    response = await session.applyPath(request.checkpoint);
-                }
-                else if (request.op === "resync") {
-                    response = await session.resync();
-                }
-                else if (request.op === "highlight") {
-                    const { op: _op, ...fixtures } = request;
-                    response = await session.applyHighlight(fixtures);
-                }
-                else {
-                    response = { ok: false, error: `unknown op "${request.op}"` };
-                }
-            }
-            catch (err) {
-                // Real, confirmed bug this fixes: an uncaught rejection here (e.g. a
-                // Playwright locator timing out because the element it found a
-                // moment ago - via `.count()`, which does NOT auto-wait - is gone by
-                // the time a slower call like `.evaluate()` re-resolves it, which
-                // DOES auto-wait) used to escape `handleLine`'s returned promise
-                // uncaught, crashing the whole detached session process on a single
-                // bad request. One request failing must never take the rest of the
-                // still-live session (browser/page/socket) down with it.
-                response = { ok: false, error: err instanceof Error ? err.message : String(err) };
-            }
-            sock.write(JSON.stringify(response) + "\n");
-            if (shouldQuit) {
-                setImmediate(() => void shutdown());
-            }
-        });
-    }
-    let shuttingDown = false;
-    async function shutdown() {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        server.close();
-        await session.close().catch(() => { });
-        removeSessionFiles(projectDir, sessionId);
-        process.exit(0);
-    }
-    await new Promise((resolvePromise, reject) => {
-        server.on("error", reject);
-        server.listen(socketPath, resolvePromise);
-    });
-    const meta = {
-        sessionId,
-        socketPath,
-        pid: process.pid,
-        projectDir,
-        startedAt: new Date().toISOString(),
-        headless,
-    };
-    writeFileSync(metaPath(projectDir, sessionId), JSON.stringify(meta, null, 2));
-    writeGlobalSessionMeta(meta);
-    process.on("SIGTERM", () => void shutdown());
-    process.on("SIGINT", () => void shutdown());
-}
-/** Entry point for the hidden `__auto-serve` CLI command (runs in the detached child). */
-export async function runAutoServeCommand(init, sessionId) {
-    const session = await AutoSession.start({ ...init, sessionId });
-    await serveSession(session, init.projectDir, sessionId, init.headless ?? true);
-    // Keep the event loop alive - the listening server already does this,
-    // but await forever here documents the intent for a reader.
-    await new Promise(() => { });
-}
-/**
- * Parent-side: spawns a detached background process running the same
- * explore session as a socket server, waits for it to signal readiness (its
- * metadata file appearing), and returns its identity. Recurses through the
- * existing `bin/waygraph` launcher (same tsx/esm registration every other
- * invocation already gets) with the hidden `__auto-serve` command, rather
- * than re-implementing that resolution here.
- */
-export async function spawnDetachedSession(init, readyTimeoutMs = 20_000) {
-    const sessionId = generateSessionId();
-    mkdirSync(sessionDir(init.projectDir), { recursive: true });
-    const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
-    const require = createRequire(join(pkgRoot, "package.json"));
-    const tsxEsm = require.resolve("tsx/esm");
-    const cli = join(pkgRoot, "dist", "cli.js");
-    const logFd = openSync(logPathFor(init.projectDir, sessionId), "a");
-    const args = ["--import", tsxEsm, cli, "__auto-serve", init.projectDir, "--session-id", sessionId];
-    if (init.baseURL)
-        args.push("--base-url", init.baseURL);
-    if (init.startUrl)
-        args.push("--goto", init.startUrl);
-    if (init.skipInitialNavigation)
-        args.push("--blank");
-    if (init.headless === false)
-        args.push("--non-headless");
-    if (init.headless === true)
-        args.push("--headless");
-    for (const p of init.inject ?? []) {
-        args.push("--inject", p);
-    }
-    // Spawn cli.js directly — not bin/waygraph (which would fork a second Node).
-    const child = spawn(process.execPath, args, {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        windowsHide: true,
-        env: process.env,
-    });
-    child.unref();
-    const deadline = Date.now() + readyTimeoutMs;
-    while (Date.now() < deadline) {
-        const meta = readSessionMeta(init.projectDir, sessionId);
-        if (meta)
-            return meta;
-        await new Promise((r) => setTimeout(r, 150));
-    }
-    throw new Error(`session "${sessionId}" did not become ready within ${readyTimeoutMs}ms - ` +
-        `check ${logPathFor(init.projectDir, sessionId)} for errors`);
-}
-/** Stop one detached session (SIGTERM + cleanup metadata/socket). */
-export function stopBrowserSession(projectDir, sessionId) {
-    const meta = resolveSessionMeta(sessionId, projectDir);
-    if (!meta)
-        return false;
-    try {
-        process.kill(meta.pid, "SIGTERM");
-    }
-    catch {
-        /* already gone */
-    }
-    removeSessionFiles(meta.projectDir, sessionId);
-    return true;
-}
-/** Stop every live session registered for a project. */
-export function stopAllBrowserSessions(projectDir) {
-    const sessions = listBrowserSessions(projectDir);
-    for (const meta of sessions) {
-        stopBrowserSession(meta.projectDir, meta.sessionId);
-    }
-    return sessions.length;
-}
-/** Live browser sessions for a project (metadata + socket + pid still present). */
-export function listBrowserSessions(projectDir) {
-    const dir = sessionDir(projectDir);
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    for (const f of readdirSync(dir)) {
-        if (!f.endsWith(".json"))
-            continue;
-        const id = f.slice(0, -".json".length);
-        const meta = readSessionMeta(projectDir, id);
-        if (!meta)
-            continue;
-        if (!existsSync(socketPathFor(id)))
-            continue;
-        if (!isPidAlive(meta.pid)) {
-            removeSessionFiles(projectDir, id);
-            continue;
-        }
-        out.push(meta);
-    }
-    return out.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-}
-function printSnapshotMenu(snapshot) {
-    console.log("");
-    console.log(`You are here: ${snapshot.here ?? "Unknown (pick Start here)"}`);
-    if (snapshot.lastRunNote)
-        console.log(snapshot.lastRunNote);
-    console.log("");
-    if (snapshot.done) {
-        console.log("  (no moves available on this page)");
-    }
-    for (const section of snapshot.sections) {
-        console.log(`  -- ${section.title} --`);
-        for (const edge of section.edges) {
-            if (edge.label) {
-                console.log(`  [${edge.index}] ${edge.label}`);
-            }
-            else {
-                const desc = edge.description ? ` - ${edge.description}` : "";
-                console.log(`  [${edge.index}] ${edge.block} (${edge.kind}) -> ${edge.to}${desc}`);
-            }
-        }
-    }
-    console.log("  [q] quit");
-    console.log("");
-}
-/**
- * Client-only interactive loop against a running detached session - reopens
- * the same rendering/parsing the foreground `--cli` loop uses, driven purely
- * through `status`/`send`. No server-side support beyond those two ops.
- */
-export async function runAttachLoop(projectDir, sessionId) {
-    const rl = createInterface({ input, output });
-    try {
-        for (;;) {
-            const statusRes = await requestSession(projectDir, sessionId, { op: "status" });
-            if (!statusRes.ok) {
-                console.error(`waygraph auto attach: ${statusRes.error}`);
-                return;
-            }
-            printSnapshotMenu(statusRes.snapshot);
-            const ans = await rl.question("Choose: ");
-            const sendRes = await requestSession(projectDir, sessionId, { op: "send", pick: ans });
-            if (!sendRes.ok) {
-                console.error(`waygraph auto attach: ${sendRes.error}`);
-                continue;
-            }
-            if (sendRes.quit) {
-                console.error("waygraph auto attach: session quit.");
-                return;
-            }
-        }
-    }
-    finally {
-        rl.close();
-    }
-}

package/dist/block-inject.d.ts

@@ -1,15 +0,0 @@
-export declare function packageRoot(): string;
-/** Human label for an injected root (used in merged `file` paths). */
-export declare function injectLabel(root: string): string;
-/**
- * Display path for a Block discovered under an inject root (not the host cwd).
- * Primary project files stay relative as-is; injected ones are tagged `@label/...`.
- */
-export declare function injectTaggedFile(hostDir: string, root: string, relFile: string): string;
-/**
- * Resolve one `--inject` token to an absolute directory (preset name or path).
- */
-export declare function resolveInjectRoot(token: string, cwd?: string): string;
-export declare function resolveInjectRoots(tokens: string[], cwd?: string): string[];
-/** Roots to scan: host project first, then each inject path (deduped). */
-export declare function exploreRoots(projectDir: string, inject?: string[]): string[];

package/dist/block-inject.js

@@ -1,91 +0,0 @@
-/**
- * Merge Block libraries / graphs from extra project roots into a host session
- * (waygraph browser `--inject`). Presets name bundled or well-known checkouts.
- */
-import { existsSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
-export function packageRoot() {
-    return resolve(dirname(fileURLToPath(import.meta.url)), "..");
-}
-/** Human label for an injected root (used in merged `file` paths). */
-export function injectLabel(root) {
-    return basename(root.replace(/\/$/, ""));
-}
-/**
- * Display path for a Block discovered under an inject root (not the host cwd).
- * Primary project files stay relative as-is; injected ones are tagged `@label/...`.
- */
-export function injectTaggedFile(hostDir, root, relFile) {
-    const host = resolve(hostDir);
-    const r = resolve(root);
-    if (r === host)
-        return relFile.replace(/\\/g, "/");
-    return `@${injectLabel(r)}/${relFile.replace(/\\/g, "/")}`;
-}
-const PRESETS = {
-    saucedemo: () => join(packageRoot(), "examples", "saucedemo"),
-    demosauce: () => join(packageRoot(), "examples", "saucedemo"),
-    veciro: () => {
-        if (process.env.WAYGRAPH_INJECT_VECIRO) {
-            return resolve(process.env.WAYGRAPH_INJECT_VECIRO);
-        }
-        for (const c of [
-            join(homedir(), "Desktop", "Work", "veciro-waygraph"),
-            join(homedir(), "Desktop", "Projects", "veciro-waygraph"),
-        ]) {
-            if (existsSync(c))
-                return c;
-        }
-        return null;
-    },
-};
-/**
- * Resolve one `--inject` token to an absolute directory (preset name or path).
- */
-export function resolveInjectRoot(token, cwd = process.cwd()) {
-    const raw = token.trim();
-    if (!raw)
-        throw new Error("waygraph inject: empty --inject value");
-    const preset = PRESETS[raw.toLowerCase()];
-    if (preset) {
-        const dir = preset();
-        if (!dir || !existsSync(dir)) {
-            throw new Error(`waygraph inject: preset "${raw}" not found on disk (pass an absolute path to the Block library root)`);
-        }
-        return resolve(dir);
-    }
-    const abs = resolve(cwd, raw);
-    if (!existsSync(abs)) {
-        throw new Error(`waygraph inject: no such directory: ${abs}`);
-    }
-    return abs;
-}
-export function resolveInjectRoots(tokens, cwd = process.cwd()) {
-    const seen = new Set();
-    const out = [];
-    for (const t of tokens) {
-        const abs = resolveInjectRoot(t, cwd);
-        if (seen.has(abs))
-            continue;
-        seen.add(abs);
-        out.push(abs);
-    }
-    return out;
-}
-/** Roots to scan: host project first, then each inject path (deduped). */
-export function exploreRoots(projectDir, inject) {
-    const host = resolve(projectDir);
-    const extra = inject ?? [];
-    const seen = new Set([host]);
-    const roots = [host];
-    for (const r of extra) {
-        const abs = resolve(r);
-        if (seen.has(abs))
-            continue;
-        seen.add(abs);
-        roots.push(abs);
-    }
-    return roots;
-}

package/dist/browser.d.ts

@@ -1,15 +0,0 @@
-import type { AutoSessionInit } from "./auto-session.js";
-export interface BrowserStartInit extends AutoSessionInit {
-    /** Preset names or paths; resolved before spawn. */
-    injectTokens?: string[];
-}
-export interface BrowserStartResult {
-    sessionId: string;
-    socketPath: string;
-    headless: boolean;
-    /** Resolved inject roots merged into this session (host project excluded). */
-    inject: string[];
-}
-/** Always spawns a new detached session — does not stop or reuse existing ones. */
-export declare function browserStart(init: BrowserStartInit): Promise<BrowserStartResult>;
-export { listBrowserSessions, stopBrowserSession, stopAllBrowserSessions, type SessionMeta, } from "./auto-session-ipc.js";

package/dist/browser.js

@@ -1,29 +0,0 @@
-/**
- * `waygraph browser` — persistent Playwright session with the project's Block
- * library loaded (and optional `--inject` roots). Pilot drives these sessions
- * via `browser send|status|highlight|…`; it does not spawn its own browser.
- *
- * Session lifecycle is explicit: `browser sessions` lists what's live;
- * `browser start` always opens another; `browser attach` / `browser stop` pick one up or shut it down.
- */
-import { spawnDetachedSession } from "./auto-session-ipc.js";
-import { resolveInjectRoots } from "./block-inject.js";
-/** Always spawns a new detached session — does not stop or reuse existing ones. */
-export async function browserStart(init) {
-    const inject = init.inject ??
-        (init.injectTokens?.length ? resolveInjectRoots(init.injectTokens, init.projectDir) : []);
-    const headless = init.headless ?? false;
-    const meta = await spawnDetachedSession({
-        ...init,
-        inject,
-        headless,
-        skipInitialNavigation: init.skipInitialNavigation ?? true,
-    });
-    return {
-        sessionId: meta.sessionId,
-        socketPath: meta.socketPath,
-        headless: meta.headless,
-        inject,
-    };
-}
-export { listBrowserSessions, stopBrowserSession, stopAllBrowserSessions, } from "./auto-session-ipc.js";

package/dist/coverage-gap.d.ts

@@ -1,11 +0,0 @@
-import type { BlockEntry } from "./auto-explore.js";
-/** Collect selector strings from NavClick blocks and Block/*Sel source files. */
-export declare function collectKnownInteractionSelectors(projectDir: string, library: {
-    navBlocks: BlockEntry[];
-}, inject?: string[]): string[];
-export interface UnmappedInteractionPayload {
-    knownPathnames: string[];
-    knownSelectors: string[];
-}
-/** Page-side: warn once per unmapped same-origin href or visible button. */
-export declare function unmappedInteractionsPageScript(payload: UnmappedInteractionPayload): void;