dsh-browser-verify 0.1.0

package/lib/index.js

@@ -0,0 +1,470 @@
+import { t as BrowserDriver } from "./driver-DxMldTYf.js";
+import { exec } from "node:child_process";
+import { readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { AttachmentError, AttachmentId } from "@deepseek-ai/dsh-attachment";
+//#region src/cleanup.ts
+/**
+* Orphan cleanup for dsh-browser-verify: temp dirs and zombie Chromium
+* processes left by crashes. Parsers are pure; callers do the I/O.
+* @module dsh-browser-verify/cleanup
+*/
+/** One line from `ps -Ao pid=,ppid=,command=` (macOS). */
+function parseZombiePids(psText, prefix, selfPid) {
+	const pids = [];
+	for (const line of psText.split("\n")) {
+		const match = /^\s*(\d+)\s+\d+\s+(.+)$/.exec(line);
+		if (match === null) continue;
+		const pid = Number(match[1]);
+		if (pid === selfPid) continue;
+		if (match[2].includes(`--user-data-dir=${join(tmpdir(), prefix)}`)) pids.push(pid);
+	}
+	return pids;
+}
+/** Pick degraded-run temp dirs: name prefixed, old enough, not the current pid dir. */
+function selectOrphanDirs(entries, nowMs, ageMs, prefix) {
+	return entries.filter((e) => e.path.includes(`/${prefix}`) && nowMs - e.mtimeMs > ageMs).sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+//#endregion
+//#region src/attachments.ts
+function imageRefFromValue(image) {
+	return {
+		attachmentId: AttachmentId(image.attachmentId),
+		mediaType: image.mediaType,
+		bytes: image.bytes,
+		width: image.width,
+		height: image.height,
+		...image.name === void 0 ? {} : { name: image.name }
+	};
+}
+function renderScreenshotBlocks(value) {
+	const dup = value.identicalToPrevious ? "（与上一张截图哈希相同，疑似页面未刷新；请 browser_open 重开场景后重试）" : "";
+	return [{
+		type: "text",
+		text: `<type>screenshot</type>\n<content>\n${value.image.mediaType}, ${value.image.width}x${value.image.height} px, ${value.image.bytes} bytes, sha256 ${value.sha256.slice(0, 12)}${dup}\n</content>`
+	}, {
+		type: "image",
+		attachment: imageRefFromValue(value.image)
+	}];
+}
+/** Persist screenshot bytes, mapping store refusals to actionable errors. */
+async function saveScreenshot(ctx, data, name) {
+	const attachments = ctx.get("attachments");
+	if (attachments === void 0) throw new Error("browser-verify: 附件存储未挂载，无法持久化截图。请检查当前 DSH 组合是否包含 attachment 插件。");
+	try {
+		return await attachments.saveImage({
+			data,
+			mediaType: "image/png",
+			...name === void 0 ? {} : { name }
+		});
+	} catch (error) {
+		if (!(error instanceof AttachmentError)) throw error;
+		if (error.code === "IMAGE_TOO_LARGE") throw new Error("browser-verify: 截图超过 attachment 存储字节上限。请改用 fullPage:false 或调低 deviceScaleFactor 后重试。", { cause: error });
+		if (error.code === "IMAGE_DIMENSION_TOO_LARGE" || error.code === "IMAGE_TOO_MANY_PIXELS") throw new Error("browser-verify: 截图尺寸超过 attachment 存储限制。请改用 fullPage:false 或调低 deviceScaleFactor 后重试。", { cause: error });
+		if (error.code === "IMAGE_TYPE_MISMATCH") throw new Error(`browser-verify: 截图格式校验失败：${error.message} 请改用其他附件类型或重试。`, { cause: error });
+		throw error;
+	}
+}
+/** Gate: the calling route must be able to see image input (mirror of read-image). */
+async function assertImageCapable(ctx, exec) {
+	const routed = exec.agent?.session?.requestHeader?.()?.config;
+	const provider = routed?.provider ?? exec.agent?.options?.provider;
+	const model = routed?.model ?? exec.agent?.options?.model;
+	const llm = ctx.get("llm");
+	if (provider === void 0 || model === void 0 || llm === void 0) throw new Error("browser-verify: 无法解析当前模型路由（或模型服务未挂载），无法判断图片输入能力。请检查当前会话的模型路由配置后重试。");
+	const active = await llm.resolveModelInfo(provider, model);
+	if (active.inputModalities === void 0 || !active.inputModalities.includes("image")) throw new Error("browser-verify: 当前模型不支持看图：请改用 browser_assert 做文本断言（更省 token），或切换到图片模型后重试。");
+}
+//#endregion
+//#region src/tools/timeout.ts
+/** Race a promise against a deadline; the loser's work is abandoned, not awaited. */
+function withTimeout(promise, ms, label) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`browser-verify: ${label} 超时（${ms}ms）。请检查页面或调大 DSH_BROWSER_VERIFY_TIMEOUT 后重试。`)), ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+//#endregion
+//#region src/tools/index.ts
+/** Parse a positive-integer env var; NaN/zero/negative falls back to the default. */
+const numberFromEnv = (name, fallback) => {
+	const value = Number(process.env[name] ?? fallback);
+	return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+const envTimeoutMs = () => numberFromEnv("DSH_BROWSER_VERIFY_TIMEOUT", 1e4);
+const envIdleMs = () => numberFromEnv("DSH_BROWSER_VERIFY_IDLE_MS", 6e5);
+function registerBrowserTools(ctx) {
+	const driver = new BrowserDriver({
+		timeoutMs: envTimeoutMs(),
+		idleMs: envIdleMs()
+	});
+	ctx.effect(() => () => {
+		driver.dispose();
+	});
+	ctx.tools.register(defineTool({
+		name: "browser_open",
+		description: "在无头浏览器中打开一个页面并返回页面状态（标题/状态码/可见文本摘要/console 错误）用于验证前端页面；可选 waitSelector 等待关键元素出现，默认视口 390×844 @2x（移动端形态）。可传 mocks 在打开时拦截接口（用于启动即依赖接口数据的页面）。验证顺序：先 browser_assert 做 DOM 断言，确需看版式再 browser_screenshot。",
+		parameters: {
+			url: {
+				type: "string",
+				required: true,
+				description: "页面地址，如 http://localhost:5173/hweb/pages/..."
+			},
+			viewport: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					width: {
+						type: "number",
+						required: true,
+						description: "视口宽"
+					},
+					height: {
+						type: "number",
+						required: true,
+						description: "视口高"
+					}
+				},
+				description: "视口尺寸 {width, height}，默认 390x844"
+			},
+			deviceScaleFactor: {
+				type: "number",
+				description: "缩放比，默认 2"
+			},
+			mocks: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						urlPattern: {
+							type: "string",
+							required: true,
+							description: "glob 模式，如 **/api/*.do*"
+						},
+						json: {
+							type: "json",
+							required: true,
+							description: "拦截响应体（任意 JSON）"
+						},
+						status: {
+							type: "number",
+							description: "响应状态码，默认 200"
+						}
+					}
+				},
+				description: "可选：页面启动前注册的接口拦截（glob urlPattern + json，如 [{urlPattern: \"**/api/*.do*\", json: {...}}]）"
+			},
+			waitSelector: {
+				type: "string",
+				description: "可选：等待该选择器出现后再返回（优先于固定等待）"
+			},
+			timeoutMs: {
+				type: "number",
+				description: `加载超时，默认 ${envTimeoutMs()}ms`
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					title: {
+						type: "string",
+						required: true
+					},
+					url: {
+						type: "string",
+						required: true
+					},
+					status: {
+						oneOf: [{ type: "number" }, { type: "null" }],
+						required: true
+					},
+					visible: {
+						type: "array",
+						items: { type: "string" },
+						required: true
+					},
+					consoleErrors: {
+						type: "array",
+						items: { type: "string" },
+						required: true
+					},
+					elapsedMs: {
+						type: "number",
+						required: true
+					},
+					browserKnown: {
+						type: "boolean",
+						required: true
+					},
+					versionHint: {
+						oneOf: [{ type: "string" }, { type: "null" }],
+						required: true,
+						description: "浏览器 revision 认证提示（null=认证通过）"
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(args) {
+			const timeoutMs = args.timeoutMs ?? envTimeoutMs();
+			return withTimeout(driver.startScenario({
+				url: args.url,
+				waitSelector: args.waitSelector,
+				timeoutMs,
+				viewport: args.viewport,
+				deviceScaleFactor: args.deviceScaleFactor,
+				mocks: args.mocks
+			}), timeoutMs, "browser_open");
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "browser_mock",
+		description: "为当前验证场景注册接口拦截并自动重新加载页面：urlPattern 用 playwright glob（如 **/api/lifeIndex.do*），拦截后返回指定 json，用于 mock 空态/异常态。与已注册 pattern 完全相同时报错；请先 browser_open。",
+		parameters: {
+			urlPattern: {
+				type: "string",
+				required: true,
+				description: "glob 模式，如 **/api/lifeIndex.do*"
+			},
+			json: {
+				type: "json",
+				description: "拦截响应体（任意 JSON）",
+				required: true
+			},
+			status: {
+				type: "number",
+				description: "响应状态码，默认 200"
+			},
+			reload: {
+				type: "boolean",
+				description: "注册后自动 reload 当前页，默认 true"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { patterns: {
+					type: "array",
+					items: { type: "string" },
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(args) {
+			return driver.withScenario(async (scenario) => ({ patterns: await scenario.addMock({
+				urlPattern: args.urlPattern,
+				json: args.json,
+				status: args.status,
+				reload: args.reload,
+				timeoutMs: envTimeoutMs()
+			}) }));
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "browser_assert",
+		description: "对当前页面 DOM 断言：selector 必须存在，可校验匹配数量（count，数字或 {min,max}）与文本包含（text）。不满足时返回 pass:false 并附差异、不抛错。这是最省 token 的验证手段，优先于截图。",
+		parameters: {
+			selector: {
+				type: "string",
+				required: true,
+				description: "CSS 选择器"
+			},
+			count: {
+				oneOf: [{ type: "number" }, {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						min: {
+							type: "number",
+							required: true
+						},
+						max: {
+							type: "number",
+							required: true
+						}
+					}
+				}],
+				description: "期望匹配数量：数字=精确，或 {min,max}=范围"
+			},
+			text: {
+				type: "string",
+				description: "期望包含于首个匹配元素文本（contains 谓词）"
+			},
+			timeoutMs: {
+				type: "number",
+				description: "等待选择器出现的超时，默认 5000ms"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					pass: {
+						type: "boolean",
+						required: true
+					},
+					count: {
+						type: "number",
+						required: true
+					},
+					actualText: {
+						oneOf: [{ type: "string" }, { type: "null" }],
+						required: true
+					},
+					elapsedMs: {
+						type: "number",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value)
+			}]
+		},
+		async execute(args) {
+			return driver.withScenario((scenario) => scenario.assert({
+				selector: args.selector,
+				count: args.count,
+				text: args.text,
+				timeoutMs: args.timeoutMs ?? 5e3
+			}));
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "browser_screenshot",
+		description: "截图当前页面并自动投影进模型上下文（图片块），返回尺寸与哈希；与上一张完全一致时 identicalToPrevious:true（疑似页面未刷新，请 browser_open 重开）。仅需要检查版式时使用——能断言就别截图。",
+		parameters: {
+			name: {
+				type: "string",
+				description: "可选命名（进入附件名）"
+			},
+			fullPage: {
+				type: "boolean",
+				description: "是否整页截图，默认 false"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					image: {
+						type: "object",
+						additionalProperties: false,
+						required: true,
+						properties: {
+							attachmentId: {
+								type: "string",
+								required: true
+							},
+							mediaType: {
+								type: "string",
+								enum: ["image/png"],
+								required: true
+							},
+							bytes: {
+								type: "integer",
+								required: true
+							},
+							width: {
+								type: "integer",
+								required: true
+							},
+							height: {
+								type: "integer",
+								required: true
+							},
+							name: { type: "string" }
+						}
+					},
+					sha256: {
+						type: "string",
+						required: true
+					},
+					identicalToPrevious: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => renderScreenshotBlocks(value)
+		},
+		async execute(args, exec) {
+			await assertImageCapable(ctx, exec);
+			return driver.withScenario(async (scenario) => {
+				const shot = await scenario.screenshot({ fullPage: args.fullPage });
+				const ref = await saveScreenshot(ctx, shot.data, args.name);
+				return {
+					image: {
+						attachmentId: String(ref.attachmentId),
+						mediaType: "image/png",
+						bytes: ref.bytes,
+						width: ref.width,
+						height: ref.height,
+						...ref.name === void 0 ? {} : { name: ref.name }
+					},
+					sha256: shot.sha256,
+					identicalToPrevious: shot.identicalToPrevious
+				};
+			});
+		}
+	}));
+}
+//#endregion
+//#region src/index.ts
+const name = "browser-verify";
+const inject = ["tools"];
+const prefix = "dsh-browser-verify-";
+/** One-shot startup sweep: old temp dirs + stray Chromium, limited to our prefix. */
+async function sweepOrphans() {
+	const root = tmpdir();
+	const entries = [];
+	const dirents = await readdir(root, { withFileTypes: true }).catch(() => []);
+	for (const dirent of dirents) {
+		if (dirent.name === `${prefix}${process.pid}`) continue;
+		if (!dirent.name.startsWith(prefix) || !dirent.isDirectory()) continue;
+		const full = join(root, dirent.name);
+		const info = await stat(full).catch(() => null);
+		if (info !== null) entries.push({
+			path: full,
+			mtimeMs: info.mtimeMs
+		});
+	}
+	for (const orphan of selectOrphanDirs(entries, Date.now(), 36e5, prefix)) await rm(orphan.path, {
+		recursive: true,
+		force: true
+	}).catch(() => void 0);
+	exec("ps -Ao pid=,ppid=,command=", (error, stdout) => {
+		if (error !== null) return;
+		for (const pid of parseZombiePids(String(stdout), prefix, process.pid)) try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+	});
+}
+function apply(ctx) {
+	sweepOrphans().catch(() => {});
+	registerBrowserTools(ctx);
+}
+//#endregion
+export { apply, inject, name };

package/lib/types/attachments.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Screenshot persistence + model projection, mirroring the read_image output
+ * direction: save into the durable attachment store, render a text envelope
+ * beside the image block the harness projects into the next model request.
+ * @module dsh-browser-verify/attachments
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImageAttachmentRef, ImageMediaType } from '@deepseek-ai/dsh-attachment';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+export interface ScreenshotImage {
+    attachmentId: string;
+    mediaType: ImageMediaType;
+    bytes: number;
+    width: number;
+    height: number;
+    name?: string;
+}
+export interface ScreenshotValue {
+    image: ScreenshotImage;
+    sha256: string;
+    identicalToPrevious: boolean;
+}
+export declare function imageRefFromValue(image: ScreenshotImage): ImageAttachmentRef;
+export declare function renderScreenshotBlocks(value: ScreenshotValue): ContentBlock[];
+/** Persist screenshot bytes, mapping store refusals to actionable errors. */
+export declare function saveScreenshot(ctx: Context, data: Buffer, name: string | undefined): Promise<ImageAttachmentRef>;
+/** Gate: the calling route must be able to see image input (mirror of read-image). */
+export declare function assertImageCapable(ctx: Context, exec: {
+    agent?: {
+        session?: {
+            requestHeader?: () => {
+                config?: {
+                    provider?: string;
+                    model?: string;
+                };
+            } | undefined;
+        };
+        options?: {
+            provider?: string;
+            model?: string;
+        };
+    };
+}): Promise<void>;
+//# sourceMappingURL=attachments.d.ts.map

package/lib/types/browser/discover.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Locate a Browser-for-Testing binary in the machine playwright cache. Pure:
+ * filesystem probing is injected so every branch is unit-testable.
+ * @module dsh-browser-verify/browser/discover
+ */
+export type BrowserKind = 'headless-shell' | 'chromium' | 'custom';
+/** Revision numbers verified against the matching playwright-core browsers.json. */
+export declare const KNOWN_REVISIONS: Readonly<Record<number, string>>;
+export interface DiscoveredBrowser {
+    executablePath: string;
+    kind: BrowserKind;
+    revision: number;
+    known: boolean;
+    versionHint: string | null;
+}
+export interface DiscoverOptions {
+    cacheDir?: string;
+    overridePath?: string;
+    exists?: (path: string) => boolean;
+    /** Directory listing of cacheDir; defaults to readdirSync(cacheDir) (throws → treated as missing). */
+    entries?: string[];
+}
+/** Default cache location on macOS. */
+export declare function defaultCacheDir(): string;
+/**
+ * Find the browser binary: env override wins, then headless shell (highest
+ * revision), then full chromium. Throws with an install hint when absent.
+ */
+export declare function discoverBrowser(opts?: DiscoverOptions): DiscoveredBrowser;
+//# sourceMappingURL=discover.d.ts.map

package/lib/types/browser/driver.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Browser driving: one lazy launch per process, one active verification
+ * scenario, FIFO-serialized tool access, idle reclamation, graceful close +
+ * temp dir removal on dispose. launch args are pure for unit tests.
+ * @module dsh-browser-verify/browser/driver
+ */
+import { type Browser } from 'playwright-core';
+import { discoverBrowser } from './discover.ts';
+import { Scenario, type OpenResult } from './scenario.ts';
+export interface OpenScenarioResult extends OpenResult {
+    browserKnown: boolean;
+    versionHint: string | null;
+}
+/**
+ * Headless launch args. Deviation D8-3: playwright-core >= 1.41 rejects
+ * `--user-data-dir` inside `args` (misuse error, both launch and
+ * launchPersistentContext); the user data dir must be passed as the
+ * launchPersistentContext first parameter. Only the headless-mode flag remains.
+ */
+export declare function buildLaunchArgs(headlessShell: boolean): string[];
+export declare class BrowserDriver {
+    private readonly opts;
+    private browser;
+    private discovered;
+    private scenario;
+    private readonly userDataDir;
+    private idleTimer;
+    private lockChain;
+    private disposed;
+    constructor(opts?: {
+        discover?: typeof discoverBrowser;
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        deviceScaleFactor?: number;
+        timeoutMs?: number;
+        idleMs?: number;
+    });
+    /** FIFO serialization: every tool op runs alone. */
+    private chain;
+    /** Reject new op entries once disposed; the engine cannot come back. */
+    private ensureNotDisposed;
+    /** Normalize errors at the driver boundary: prefix + context + advice. */
+    private wrapError;
+    withScenario<T>(fn: (scenario: Scenario) => Promise<T>): Promise<T>;
+    /** Open a fresh verification scenario; per design, each open = new context+page. */
+    startScenario(reset: {
+        url: string;
+        waitSelector?: string;
+        timeoutMs?: number;
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        deviceScaleFactor?: number;
+        mocks?: Array<{
+            urlPattern: string;
+            json: unknown;
+            status?: number;
+        }>;
+    }): Promise<OpenScenarioResult>;
+    private openScenario;
+    private resetIdleTimer;
+    ensureBrowser(): Promise<Browser>;
+    private requireScenario;
+    /**
+     * Reset on dispose: mark disposed first (idempotent, blocks new ops), then
+     * run the teardown serialized on the FIFO chain so it waits out any
+     * in-flight op and cannot interleave with a launch or scenario op.
+     */
+    dispose(): Promise<void>;
+    /** Best-effort teardown: close scenario + browser, delete the profile dir. */
+    private teardown;
+    /**
+     * Hard-kill fallback: SIGKILL every process whose command line still
+     * carries our user-data-dir (playwright appends `--user-data-dir` itself;
+     * our predictable temp dir is the reverse-lookup key, per design §6).
+     */
+    private hardKillChromium;
+}
+//# sourceMappingURL=driver.d.ts.map

package/lib/types/browser/scenario.d.ts

@@ -0,0 +1,76 @@
+/**
+ * One verification scenario = one page + its request mocks + assertion/shot
+ * state. Pure helpers are exported for unit tests; the IO methods use
+ * playwright-core. Polluting nothing outside the page's own requests.
+ * @module dsh-browser-verify/browser/scenario
+ */
+import type { BrowserContext, Page } from 'playwright-core';
+export interface MockRule {
+    json: unknown;
+    status: number;
+}
+export interface OpenResult {
+    title: string;
+    url: string;
+    status: number | null;
+    visible: string[];
+    consoleErrors: string[];
+    elapsedMs: number;
+}
+export interface AssertResult {
+    pass: boolean;
+    count: number;
+    actualText: string | null;
+    elapsedMs: number;
+}
+export declare function assertNoMockConflict(patterns: string[], next: string): void;
+export declare function normalizeCountSpec(count: number | {
+    min: number;
+    max: number;
+} | undefined): {
+    min: number;
+    max: number;
+} | null;
+export declare function summarizeVisibleText(texts: string[]): string[];
+export declare function capConsoleErrors(errors: string[]): string[];
+export declare function sha256Hex(data: Buffer): string;
+export declare function textDiff(actual: string | null, expected: string): string;
+/** Visible-text extraction, evaluated in the page: text of visible elements. */
+export declare const VISIBLE_TEXT_SCRIPT = "\nArray.from(document.querySelectorAll('body *')).map(el => {\n  const rect = el.getBoundingClientRect()\n  if (rect.width === 0 || rect.height === 0) return ''\n  const text = (el.childElementCount === 0 ? el.textContent ?? '' : '').trim()\n  return text.length > 0 ? text : ''\n})\n";
+export declare class Scenario {
+    readonly page: Page;
+    readonly context: BrowserContext;
+    readonly mocks: Map<string, MockRule>;
+    lastScreenshotHash: string | null;
+    constructor(page: Page, context: BrowserContext);
+    navigate(opts: {
+        url: string;
+        waitSelector?: string;
+        timeoutMs?: number;
+    }): Promise<OpenResult>;
+    addMock(rule: {
+        urlPattern: string;
+        json: unknown;
+        status?: number;
+        reload?: boolean;
+        timeoutMs?: number;
+    }): Promise<string[]>;
+    assert(opts: {
+        selector: string;
+        count?: number | {
+            min: number;
+            max: number;
+        };
+        text?: string;
+        timeoutMs: number;
+    }): Promise<AssertResult>;
+    screenshot(opts: {
+        fullPage?: boolean;
+    }): Promise<{
+        data: Buffer;
+        sha256: string;
+        identicalToPrevious: boolean;
+    }>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=scenario.d.ts.map