@ricsam/isolate 0.1.10 → 0.1.11

package/dist/types/internal/protocol/codec.d.ts

@@ -55,6 +55,7 @@ export interface IsolateRef {
 export interface CallbackRef {
     __type: "CallbackRef";
     callbackId: number;
+    callbackKind?: "asyncGenerator";
 }
 /**
  * Represents a reference to a stream.
@@ -180,12 +181,20 @@ export interface URLRef {
     __type: "URLRef";
     href: string;
 }
+/**
+ * Represents a serialized AbortSignal snapshot.
+ */
+export interface AbortSignalRef {
+    __type: "AbortSignalRef";
+    aborted: boolean;
+}
 /**
  * Represents a reference to a pending Promise.
  */
 export interface PromiseRef {
     __type: "PromiseRef";
     promiseId: number;
+    __resolveCallbackId?: number;
 }
 /**
  * Represents a reference to an async iterator.
@@ -197,7 +206,7 @@ export interface AsyncIteratorRef {
     __returnCallbackId?: number;
     __throwCallbackId?: number;
 }
-export type ExtensionType = IsolateRef | CallbackRef | StreamRef | ErrorRef | BlobRef | DateRef | RegExpRef | UndefinedRef | BigIntRef | RequestRef | ResponseRef | HeadersRef | FileRef | FormDataRef | URLRef | PromiseRef | AsyncIteratorRef;
+export type ExtensionType = IsolateRef | CallbackRef | StreamRef | ErrorRef | BlobRef | DateRef | RegExpRef | UndefinedRef | BigIntRef | RequestRef | ResponseRef | HeadersRef | FileRef | FormDataRef | URLRef | AbortSignalRef | PromiseRef | AsyncIteratorRef;
 /**
  * Encode a message to MessagePack bytes.
  */
@@ -215,7 +224,7 @@ export declare function encodeValue(value: unknown): Uint8Array;
  */
 export declare function decodeValue(data: Uint8Array): unknown;
 export declare function createIsolateRef(isolateId: string): IsolateRef;
-export declare function createCallbackRef(callbackId: number): CallbackRef;
+export declare function createCallbackRef(callbackId: number, callbackKind?: "asyncGenerator"): CallbackRef;
 export declare function createStreamRef(streamId: number, direction: "upload" | "download"): StreamRef;
 export declare function createErrorRef(name: string, message: string, stack?: string, code?: number): ErrorRef;
 export declare function createBlobRef(blobId: number, size: number, type: string): BlobRef;
@@ -238,5 +247,6 @@ export declare function createHeadersRef(pairs: [string, string][]): HeadersRef;
 export declare function createFileRef(name: string, type: string, lastModified: number, data: number[]): FileRef;
 export declare function createFormDataRef(entries: [string, string | FileRef][]): FormDataRef;
 export declare function createURLRef(href: string): URLRef;
+export declare function createAbortSignalRef(aborted: boolean): AbortSignalRef;
 export declare function createPromiseRef(promiseId: number): PromiseRef;
 export declare function createAsyncIteratorRef(iteratorId: number): AsyncIteratorRef;

package/dist/types/internal/protocol/marshalValue.d.ts

@@ -4,6 +4,7 @@
  * Provides type-preserving serialization for JavaScript types that would
  * otherwise lose fidelity when JSON stringified.
  */
+import { type PromiseRef, type AsyncIteratorRef } from "./codec.ts";
 /**
  * Error thrown when a value cannot be marshalled.
  */
@@ -30,9 +31,9 @@ export interface UnmarshalContext {
     /** Get a callback function by ID */
     getCallback?: (id: number) => ((...args: unknown[]) => unknown) | undefined;
     /** Create a proxy Promise for a PromiseRef */
-    createPromiseProxy?: (promiseId: number) => Promise<unknown>;
+    createPromiseProxy?: (promiseId: number, ref?: PromiseRef) => Promise<unknown>;
     /** Create a proxy AsyncIterator for an AsyncIteratorRef */
-    createIteratorProxy?: (iteratorId: number) => AsyncIterator<unknown>;
+    createIteratorProxy?: (iteratorId: number, ref?: AsyncIteratorRef) => AsyncIterator<unknown>;
     /** Get a Blob by ID */
     getBlob?: (blobId: number) => Blob | undefined;
 }

package/dist/types/internal/protocol/types.d.ts

@@ -105,7 +105,7 @@ export interface CustomFunctionRegistrations {
  * The client executes this operation on the real Page object.
  */
 export interface PlaywrightOperation {
-    type: "goto" | "reload" | "url" | "title" | "content" | "waitForSelector" | "waitForTimeout" | "waitForLoadState" | "evaluate" | "locatorAction" | "expectLocator" | "expectPage" | "request" | "goBack" | "goForward" | "waitForURL" | "waitForURLPredicate" | "waitForRequestStart" | "waitForRequestFinish" | "waitForRequestPredicateFinish" | "waitForResponseStart" | "waitForResponseFinish" | "waitForResponsePredicateFinish" | "clearCookies" | "screenshot" | "setViewportSize" | "viewportSize" | "emulateMedia" | "setExtraHTTPHeaders" | "bringToFront" | "close" | "isClosed" | "pdf" | "pause" | "frames" | "mainFrame" | "keyboardType" | "keyboardPress" | "keyboardDown" | "keyboardUp" | "keyboardInsertText" | "mouseMove" | "mouseClick" | "mouseDown" | "mouseUp" | "mouseWheel" | "addCookies" | "cookies" | "newContext" | "newPage" | "closeContext";
+    type: "goto" | "reload" | "url" | "title" | "content" | "waitForSelector" | "waitForTimeout" | "waitForLoadState" | "evaluate" | "locatorAction" | "expectLocator" | "expectPage" | "request" | "goBack" | "goForward" | "waitForURL" | "waitForURLPredicate" | "waitForRequestStart" | "waitForRequestFinish" | "waitForRequestPredicateFinish" | "waitForResponseStart" | "waitForResponseFinish" | "waitForResponsePredicateFinish" | "clearCookies" | "screenshot" | "setViewportSize" | "viewportSize" | "emulateMedia" | "setExtraHTTPHeaders" | "bringToFront" | "close" | "isClosed" | "pdf" | "pause" | "frames" | "mainFrame" | "keyboardType" | "keyboardPress" | "keyboardDown" | "keyboardUp" | "keyboardInsertText" | "mouseMove" | "mouseClick" | "mouseDown" | "mouseUp" | "mouseWheel" | "addCookies" | "cookies" | "contexts" | "pages" | "newContext" | "newPage" | "closeContext";
     args: unknown[];
     /** Target page ID (undefined = default page "page_0") */
     pageId?: string;
@@ -161,6 +161,8 @@ export interface TestEnvironmentOptionsProtocol {
 export interface PlaywrightOptionsProtocol {
     /** Default timeout for Playwright operations in ms */
     timeout?: number;
+    /** Whether the isolate should expose default page/context globals. */
+    hasDefaultPage?: boolean;
 }
 export interface CreateRuntimeRequest extends BaseMessage {
     type: typeof MessageType.CREATE_RUNTIME;
@@ -509,6 +511,8 @@ export interface WsClientErrorPayload {
  */
 export type PlaywrightEvent = {
     type: "browserConsoleLog";
+    contextId: string;
+    pageId: string;
     level: string;
     stdout: string;
     location?: {
@@ -519,12 +523,16 @@ export type PlaywrightEvent = {
     timestamp: number;
 } | {
     type: "pageError";
+    contextId: string;
+    pageId: string;
     name: string;
     message: string;
     stack?: string;
     timestamp: number;
 } | {
     type: "networkRequest";
+    contextId: string;
+    pageId: string;
     requestId: string;
     url: string;
     method: string;
@@ -534,6 +542,8 @@ export type PlaywrightEvent = {
     timestamp: number;
 } | {
     type: "networkResponse";
+    contextId: string;
+    pageId: string;
     requestId: string;
     url: string;
     status: number;
@@ -543,6 +553,8 @@ export type PlaywrightEvent = {
     timestamp: number;
 } | {
     type: "requestFailure";
+    contextId: string;
+    pageId: string;
     requestId: string;
     url: string;
     method: string;
@@ -801,6 +813,8 @@ export interface PlaywrightFileData {
 export interface PlaywrightOptions {
     /** Handler callback for Playwright operations (required when playwright is enabled) */
     handler: (op: PlaywrightOperation) => Promise<PlaywrightResult>;
+    /** Whether the isolate should expose default page/context globals. */
+    hasDefaultPage?: boolean;
     /** Default timeout for operations in ms */
     timeout?: number;
     /** If true, browser console logs are routed through console handler (or printed to stdout if no handler) */
@@ -927,6 +941,8 @@ export interface PlaywrightTestResult {
 export interface CollectedData {
     /** Browser console logs (from the page, not sandbox) */
     browserConsoleLogs: {
+        contextId: string;
+        pageId: string;
         level: string;
         stdout: string;
         location?: {
@@ -937,12 +953,16 @@ export interface CollectedData {
         timestamp: number;
     }[];
     pageErrors: {
+        contextId: string;
+        pageId: string;
         name: string;
         message: string;
         stack?: string;
         timestamp: number;
     }[];
     networkRequests: {
+        contextId: string;
+        pageId: string;
         requestId: string;
         url: string;
         method: string;
@@ -952,6 +972,8 @@ export interface CollectedData {
         timestamp: number;
     }[];
     networkResponses: {
+        contextId: string;
+        pageId: string;
         requestId: string;
         url: string;
         status: number;
@@ -961,6 +983,8 @@ export interface CollectedData {
         timestamp: number;
     }[];
     requestFailures: {
+        contextId: string;
+        pageId: string;
         requestId: string;
         url: string;
         method: string;

package/dist/types/internal/runtime/index.d.ts

@@ -115,6 +115,11 @@ export interface RuntimeTestEnvironmentHandle {
 export interface RuntimePlaywrightHandle {
     /** Get collected browser data (console logs, network requests/responses) */
     getCollectedData(): CollectedData;
+    /** Get tracked browser context/page ids */
+    getTrackedResources(): {
+        contexts: string[];
+        pages: string[];
+    };
     /** Clear collected browser data */
     clearCollectedData(): void;
 }

package/dist/types/internal/typecheck/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Type definitions and type-checking utilities for isolated-vm V8 sandbox code.
  */
-export { CORE_TYPES, CONSOLE_TYPES, CRYPTO_TYPES, ENCODING_TYPES, FETCH_TYPES, FS_TYPES, PATH_TYPES, TEST_ENV_TYPES, TIMERS_TYPES, PLAYWRIGHT_TYPES, TYPE_DEFINITIONS, type TypeDefinitionKey, } from "./isolate-types.ts";
+export { CORE_TYPES, CONSOLE_TYPES, CRYPTO_TYPES, ENCODING_TYPES, FETCH_TYPES, FS_TYPES, PATH_TYPES, TEST_ENV_TYPES, TIMERS_TYPES, PLAYWRIGHT_TYPES, SANDBOX_ISOLATE_TYPES, TYPE_DEFINITIONS, type TypeDefinitionKey, } from "./isolate-types.ts";
 export { typecheckIsolateCode, formatTypecheckErrors, type TypecheckResult, type TypecheckError, type TypecheckOptions, type LibraryTypes, type LibraryTypeFile, } from "./typecheck.ts";

package/dist/types/internal/typecheck/isolate-types.d.ts

@@ -69,15 +69,17 @@ export declare const TIMERS_TYPES = "/**\n * Global Type Definitions for ../time
 /**
  * Playwright types for isolated-vm.
  *
- * These types define the globals injected by setupPlaywright() into an isolated-vm context.
- * Playwright brings 3 globals: page, context, and browser.
+ * These types define the browser-facing globals and classes injected by
+ * setupPlaywright() into an isolated-vm context.
  */
-export declare const PLAYWRIGHT_TYPES = "\n/**\n * Locator represents an element or group of elements in the page.\n */\ndeclare class Locator {\n  /** Click the element */\n  click(): Promise<void>;\n  /** Double-click the element */\n  dblclick(): Promise<void>;\n  /** Fill an input element with text */\n  fill(text: string): Promise<void>;\n  /** Type text into an element (key by key) */\n  type(text: string): Promise<void>;\n  /** Check a checkbox or radio */\n  check(): Promise<void>;\n  /** Uncheck a checkbox */\n  uncheck(): Promise<void>;\n  /** Select an option in a dropdown */\n  selectOption(value: string | string[]): Promise<void>;\n  /** Clear an input element */\n  clear(): Promise<void>;\n  /** Press a key */\n  press(key: string): Promise<void>;\n  /** Hover over the element */\n  hover(): Promise<void>;\n  /** Focus the element */\n  focus(): Promise<void>;\n  /** Get text content of the element */\n  textContent(): Promise<string | null>;\n  /** Get the value of an input element */\n  inputValue(): Promise<string>;\n  /** Check if the element is visible */\n  isVisible(): Promise<boolean>;\n  /** Check if the element is enabled */\n  isEnabled(): Promise<boolean>;\n  /** Check if the element is checked */\n  isChecked(): Promise<boolean>;\n  /** Check if the element is disabled */\n  isDisabled(): Promise<boolean>;\n  /** Check if the element is hidden */\n  isHidden(): Promise<boolean>;\n  /** Get the count of matching elements */\n  count(): Promise<number>;\n  /** Get an attribute value */\n  getAttribute(name: string): Promise<string | null>;\n  /** Get innerHTML */\n  innerHTML(): Promise<string>;\n  /** Get innerText */\n  innerText(): Promise<string>;\n  /** Get all text contents */\n  allTextContents(): Promise<string[]>;\n  /** Get all inner texts */\n  allInnerTexts(): Promise<string[]>;\n  /** Wait for the element to match a state */\n  waitFor(options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Get bounding box */\n  boundingBox(): Promise<{ x: number; y: number; width: number; height: number } | null>;\n  /** Set input files for a file input */\n  setInputFiles(files: string | string[] | { name: string; mimeType: string; buffer: ArrayBuffer | Uint8Array | string }[]): Promise<void>;\n  /** Take a screenshot of the element */\n  screenshot(options?: { path?: string; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<string>;\n  /** Drag to another element */\n  dragTo(target: Locator): Promise<void>;\n  /** Scroll element into view */\n  scrollIntoViewIfNeeded(): Promise<void>;\n  /** Highlight the element for debugging */\n  highlight(): Promise<void>;\n  /** Evaluate a function in the context of the element */\n  evaluate<R>(fn: (el: Element, arg?: unknown) => R, arg?: unknown): Promise<R>;\n  /** Evaluate a function for all matching elements */\n  evaluateAll<R>(fn: (els: Element[], arg?: unknown) => R, arg?: unknown): Promise<R>;\n\n  // Chaining methods\n  /** Chain with another CSS selector */\n  locator(selector: string): Locator;\n  /** Chain with getByRole */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Chain with getByText */\n  getByText(text: string | RegExp): Locator;\n  /** Chain with getByLabel */\n  getByLabel(label: string | RegExp): Locator;\n  /** Chain with getByPlaceholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Chain with getByTestId */\n  getByTestId(testId: string): Locator;\n  /** Chain with getByAltText */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Chain with getByTitle */\n  getByTitle(title: string | RegExp): Locator;\n\n  // Subset selection\n  /** Get all matching locators as an array */\n  all(): Promise<Locator[]>;\n  /** Get the nth matching element */\n  nth(index: number): Locator;\n  /** Get the first matching element */\n  first(): Locator;\n  /** Get the last matching element */\n  last(): Locator;\n\n  // Filtering\n  /** Filter locators by additional criteria */\n  filter(options: { hasText?: string | RegExp; hasNotText?: string | RegExp; has?: Locator; hasNot?: Locator }): Locator;\n  /** Create a locator matching either this or the other locator */\n  or(other: Locator): Locator;\n  /** Create a locator matching both this and the other locator */\n  and(other: Locator): Locator;\n}\n\n/**\n * FrameLocator for interacting with elements inside iframes.\n */\ninterface FrameLocator {\n  locator(selector: string): Locator;\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  getByText(text: string | RegExp): Locator;\n  getByLabel(label: string | RegExp): Locator;\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  getByTestId(testId: string): Locator;\n  getByAltText(alt: string | RegExp): Locator;\n  getByTitle(title: string | RegExp): Locator;\n}\n\n/**\n * Keyboard API for simulating keyboard input.\n */\ninterface Keyboard {\n  type(text: string, options?: { delay?: number }): Promise<void>;\n  press(key: string, options?: { delay?: number }): Promise<void>;\n  down(key: string): Promise<void>;\n  up(key: string): Promise<void>;\n  insertText(text: string): Promise<void>;\n}\n\n/**\n * Mouse API for simulating mouse input.\n */\ninterface Mouse {\n  move(x: number, y: number, options?: { steps?: number }): Promise<void>;\n  click(x: number, y: number, options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number; delay?: number }): Promise<void>;\n  down(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  up(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  wheel(deltaX: number, deltaY: number): Promise<void>;\n}\n\n/**\n * API Response from page.request methods.\n */\ninterface APIResponse {\n  status(): number;\n  ok(): boolean;\n  headers(): Record<string, string>;\n  json(): Promise<unknown>;\n  text(): Promise<string>;\n  body(): Promise<ArrayBuffer>;\n}\n\n/**\n * Request API for making HTTP requests with page cookies.\n */\ninterface APIRequestContext {\n  fetch(url: string, options?: { method?: string; data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  get(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n  post(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  put(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  delete(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n}\n\n/**\n * Frame information.\n */\ninterface FrameInfo {\n  name: string;\n  url: string;\n}\n\n/**\n * Cookie data.\n */\ninterface Cookie {\n  name: string;\n  value: string;\n  domain?: string;\n  path?: string;\n  expires?: number;\n  httpOnly?: boolean;\n  secure?: boolean;\n  sameSite?: \"Strict\" | \"Lax\" | \"None\";\n}\n\n/**\n * IsolatePage - represents a browser page in the isolate.\n */\ndeclare class IsolatePage {\n  /** Navigate to a URL */\n  goto(url: string, options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Reload the page */\n  reload(): Promise<void>;\n  /** Get the current URL */\n  url(): Promise<string>;\n  /** Get the page title */\n  title(): Promise<string>;\n  /** Get the page HTML content */\n  content(): Promise<string>;\n  /** Wait for a selector to appear */\n  waitForSelector(selector: string, options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Wait for a specified time */\n  waitForTimeout(ms: number): Promise<void>;\n  /** Wait for a load state */\n  waitForLoadState(state?: \"load\" | \"domcontentloaded\" | \"networkidle\"): Promise<void>;\n  /** Wait for the URL to match */\n  waitForURL(url: string | RegExp, options?: { timeout?: number; waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Evaluate JavaScript in the browser context */\n  evaluate<R>(script: string | (() => R) | ((arg: unknown) => R), arg?: unknown): Promise<R>;\n  /** Create a locator by CSS selector */\n  locator(selector: string): Locator;\n  /** Create a locator by ARIA role */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Create a locator by text content */\n  getByText(text: string | RegExp): Locator;\n  /** Create a locator by label */\n  getByLabel(label: string | RegExp): Locator;\n  /** Create a locator by placeholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Create a locator by test ID */\n  getByTestId(testId: string): Locator;\n  /** Create a locator by alt text */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Create a locator by title */\n  getByTitle(title: string | RegExp): Locator;\n  /** Create a frame locator */\n  frameLocator(selector: string): FrameLocator;\n  /** Navigate back */\n  goBack(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Navigate forward */\n  goForward(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Click an element (shorthand) */\n  click(selector: string): Promise<void>;\n  /** Fill an input (shorthand) */\n  fill(selector: string, value: string): Promise<void>;\n  /** Take a screenshot */\n  screenshot(options?: { path?: string; fullPage?: boolean; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<string>;\n  /** Generate a PDF (Chromium only) */\n  pdf(options?: { path?: string; format?: string; landscape?: boolean; margin?: { top?: string; bottom?: string; left?: string; right?: string } }): Promise<string>;\n  /** Set the viewport size */\n  setViewportSize(size: { width: number; height: number }): Promise<void>;\n  /** Get the viewport size */\n  viewportSize(): Promise<{ width: number; height: number } | null>;\n  /** Emulate media type or color scheme */\n  emulateMedia(options: { media?: \"screen\" | \"print\" | null; colorScheme?: \"light\" | \"dark\" | \"no-preference\" | null }): Promise<void>;\n  /** Set extra HTTP headers */\n  setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;\n  /** Bring the page to front */\n  bringToFront(): Promise<void>;\n  /** Close the page */\n  close(): Promise<void>;\n  /** Check if the page is closed */\n  isClosed(): Promise<boolean>;\n  /** Pause execution (for debugging) */\n  pause(): Promise<void>;\n  /** Get all frames */\n  frames(): Promise<FrameInfo[]>;\n  /** Get the main frame */\n  mainFrame(): Promise<FrameInfo>;\n  /** Get the browser context for this page */\n  context(): IsolateContext;\n  /** Keyboard API */\n  readonly keyboard: Keyboard;\n  /** Mouse API */\n  readonly mouse: Mouse;\n  /** Request API for making HTTP requests */\n  readonly request: APIRequestContext;\n}\n\n/**\n * IsolateContext - represents a browser context in the isolate.\n */\ndeclare class IsolateContext {\n  /** Create a new page in this context (requires createPage callback) */\n  newPage(): Promise<IsolatePage>;\n  /** Close this context and all its pages */\n  close(): Promise<void>;\n  /** Clear all cookies */\n  clearCookies(): Promise<void>;\n  /** Add cookies */\n  addCookies(cookies: Cookie[]): Promise<void>;\n  /** Get cookies */\n  cookies(urls?: string | string[]): Promise<Cookie[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ninterface IsolateBrowser {\n  /** Create a new browser context (requires createContext callback) */\n  newContext(options?: {\n    viewport?: { width: number; height: number } | null;\n    userAgent?: string;\n    locale?: string;\n    timezoneId?: string;\n    geolocation?: { latitude: number; longitude: number; accuracy?: number };\n    permissions?: string[];\n    colorScheme?: \"light\" | \"dark\" | \"no-preference\";\n  }): Promise<IsolateContext>;\n}\n\n/**\n * The default page object.\n */\ndeclare const page: IsolatePage;\n\n/**\n * The default browser context.\n */\ndeclare const context: IsolateContext;\n\n/**\n * Browser object for creating new contexts.\n */\ndeclare const browser: IsolateBrowser;\n\n// ============================================================================\n// Playwright Expect Matchers (extends test-environment expect)\n// ============================================================================\n\n/**\n * Options for locator assertion timeouts.\n */\ninterface LocatorAssertionOptions {\n  timeout?: number;\n}\n\n/**\n * Locator-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(locator).\n */\ninterface PlaywrightLocatorMatchers {\n  /** Assert element is visible */\n  toBeVisible(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is hidden */\n  toBeHidden(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is enabled */\n  toBeEnabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is disabled */\n  toBeDisabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is checked */\n  toBeChecked(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is focused */\n  toBeFocused(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is empty */\n  toBeEmpty(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is attached to DOM */\n  toBeAttached(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is editable */\n  toBeEditable(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is in viewport */\n  toBeInViewport(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains text */\n  toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has exact text */\n  toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has value (for inputs) */\n  toHaveValue(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has attribute */\n  toHaveAttribute(name: string, value?: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element count */\n  toHaveCount(count: number, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has class */\n  toHaveClass(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains class */\n  toContainClass(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has id */\n  toHaveId(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has CSS property */\n  toHaveCSS(name: string, value: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has JavaScript property */\n  toHaveJSProperty(name: string, value: unknown, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible name */\n  toHaveAccessibleName(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible description */\n  toHaveAccessibleDescription(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has ARIA role */\n  toHaveRole(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightLocatorMatchers;\n}\n\n/**\n * Page-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(page).\n */\ninterface PlaywrightPageMatchers {\n  /** Assert page has URL */\n  toHaveURL(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert page has title */\n  toHaveTitle(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightPageMatchers;\n}\n";
+export declare const PLAYWRIGHT_TYPES = "\n/**\n * Locator represents an element or group of elements in the page.\n */\ndeclare class Locator {\n  /** Click the element */\n  click(): Promise<void>;\n  /** Double-click the element */\n  dblclick(): Promise<void>;\n  /** Fill an input element with text */\n  fill(text: string): Promise<void>;\n  /** Type text into an element (key by key) */\n  type(text: string): Promise<void>;\n  /** Check a checkbox or radio */\n  check(): Promise<void>;\n  /** Uncheck a checkbox */\n  uncheck(): Promise<void>;\n  /** Select an option in a dropdown */\n  selectOption(value: string | string[]): Promise<void>;\n  /** Clear an input element */\n  clear(): Promise<void>;\n  /** Press a key */\n  press(key: string): Promise<void>;\n  /** Hover over the element */\n  hover(): Promise<void>;\n  /** Focus the element */\n  focus(): Promise<void>;\n  /** Get text content of the element */\n  textContent(): Promise<string | null>;\n  /** Get the value of an input element */\n  inputValue(): Promise<string>;\n  /** Check if the element is visible */\n  isVisible(): Promise<boolean>;\n  /** Check if the element is enabled */\n  isEnabled(): Promise<boolean>;\n  /** Check if the element is checked */\n  isChecked(): Promise<boolean>;\n  /** Check if the element is disabled */\n  isDisabled(): Promise<boolean>;\n  /** Check if the element is hidden */\n  isHidden(): Promise<boolean>;\n  /** Get the count of matching elements */\n  count(): Promise<number>;\n  /** Get an attribute value */\n  getAttribute(name: string): Promise<string | null>;\n  /** Get innerHTML */\n  innerHTML(): Promise<string>;\n  /** Get innerText */\n  innerText(): Promise<string>;\n  /** Get all text contents */\n  allTextContents(): Promise<string[]>;\n  /** Get all inner texts */\n  allInnerTexts(): Promise<string[]>;\n  /** Wait for the element to match a state */\n  waitFor(options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Get bounding box */\n  boundingBox(): Promise<{ x: number; y: number; width: number; height: number } | null>;\n  /** Set input files for a file input */\n  setInputFiles(files: string | string[] | { name: string; mimeType: string; buffer: ArrayBuffer | Uint8Array | string }[]): Promise<void>;\n  /** Take a screenshot of the element */\n  screenshot(options?: { path?: string; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<void>;\n  /** Drag to another element */\n  dragTo(target: Locator): Promise<void>;\n  /** Scroll element into view */\n  scrollIntoViewIfNeeded(): Promise<void>;\n  /** Highlight the element for debugging */\n  highlight(): Promise<void>;\n  /** Evaluate a function in the context of the element */\n  evaluate<R>(fn: (el: Element, arg?: unknown) => R, arg?: unknown): Promise<R>;\n  /** Evaluate a function for all matching elements */\n  evaluateAll<R>(fn: (els: Element[], arg?: unknown) => R, arg?: unknown): Promise<R>;\n\n  // Chaining methods\n  /** Chain with another CSS selector */\n  locator(selector: string): Locator;\n  /** Chain with getByRole */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Chain with getByText */\n  getByText(text: string | RegExp): Locator;\n  /** Chain with getByLabel */\n  getByLabel(label: string | RegExp): Locator;\n  /** Chain with getByPlaceholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Chain with getByTestId */\n  getByTestId(testId: string): Locator;\n  /** Chain with getByAltText */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Chain with getByTitle */\n  getByTitle(title: string | RegExp): Locator;\n\n  // Subset selection\n  /** Get all matching locators as an array */\n  all(): Promise<Locator[]>;\n  /** Get the nth matching element */\n  nth(index: number): Locator;\n  /** Get the first matching element */\n  first(): Locator;\n  /** Get the last matching element */\n  last(): Locator;\n\n  // Filtering\n  /** Filter locators by additional criteria */\n  filter(options: { hasText?: string | RegExp; hasNotText?: string | RegExp; has?: Locator; hasNot?: Locator }): Locator;\n  /** Create a locator matching either this or the other locator */\n  or(other: Locator): Locator;\n  /** Create a locator matching both this and the other locator */\n  and(other: Locator): Locator;\n}\n\n/**\n * FrameLocator for interacting with elements inside iframes.\n */\ninterface FrameLocator {\n  locator(selector: string): Locator;\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  getByText(text: string | RegExp): Locator;\n  getByLabel(label: string | RegExp): Locator;\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  getByTestId(testId: string): Locator;\n  getByAltText(alt: string | RegExp): Locator;\n  getByTitle(title: string | RegExp): Locator;\n}\n\n/**\n * Keyboard API for simulating keyboard input.\n */\ninterface Keyboard {\n  type(text: string, options?: { delay?: number }): Promise<void>;\n  press(key: string, options?: { delay?: number }): Promise<void>;\n  down(key: string): Promise<void>;\n  up(key: string): Promise<void>;\n  insertText(text: string): Promise<void>;\n}\n\n/**\n * Mouse API for simulating mouse input.\n */\ninterface Mouse {\n  move(x: number, y: number, options?: { steps?: number }): Promise<void>;\n  click(x: number, y: number, options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number; delay?: number }): Promise<void>;\n  down(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  up(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  wheel(deltaX: number, deltaY: number): Promise<void>;\n}\n\n/**\n * API Response from page.request methods.\n */\ninterface APIResponse {\n  status(): number;\n  ok(): boolean;\n  headers(): Record<string, string>;\n  json(): Promise<unknown>;\n  text(): Promise<string>;\n  body(): Promise<ArrayBuffer>;\n}\n\n/**\n * Request API for making HTTP requests with page cookies.\n */\ninterface APIRequestContext {\n  fetch(url: string, options?: { method?: string; data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  get(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n  post(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  put(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  delete(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n}\n\n/**\n * Frame information.\n */\ninterface FrameInfo {\n  name: string;\n  url: string;\n}\n\n/**\n * Cookie data.\n */\ninterface Cookie {\n  name: string;\n  value: string;\n  domain?: string;\n  path?: string;\n  expires?: number;\n  httpOnly?: boolean;\n  secure?: boolean;\n  sameSite?: \"Strict\" | \"Lax\" | \"None\";\n}\n\n/**\n * IsolatePage - represents a browser page in the isolate.\n */\ndeclare class IsolatePage {\n  /** Navigate to a URL */\n  goto(url: string, options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Reload the page */\n  reload(): Promise<void>;\n  /** Get the current URL */\n  url(): Promise<string>;\n  /** Get the page title */\n  title(): Promise<string>;\n  /** Get the page HTML content */\n  content(): Promise<string>;\n  /** Wait for a selector to appear */\n  waitForSelector(selector: string, options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Wait for a specified time */\n  waitForTimeout(ms: number): Promise<void>;\n  /** Wait for a load state */\n  waitForLoadState(state?: \"load\" | \"domcontentloaded\" | \"networkidle\"): Promise<void>;\n  /** Wait for the URL to match */\n  waitForURL(url: string | RegExp, options?: { timeout?: number; waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Evaluate JavaScript in the browser context */\n  evaluate<R>(script: string | (() => R) | ((arg: unknown) => R), arg?: unknown): Promise<R>;\n  /** Create a locator by CSS selector */\n  locator(selector: string): Locator;\n  /** Create a locator by ARIA role */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Create a locator by text content */\n  getByText(text: string | RegExp): Locator;\n  /** Create a locator by label */\n  getByLabel(label: string | RegExp): Locator;\n  /** Create a locator by placeholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Create a locator by test ID */\n  getByTestId(testId: string): Locator;\n  /** Create a locator by alt text */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Create a locator by title */\n  getByTitle(title: string | RegExp): Locator;\n  /** Create a frame locator */\n  frameLocator(selector: string): FrameLocator;\n  /** Navigate back */\n  goBack(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Navigate forward */\n  goForward(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Click an element (shorthand) */\n  click(selector: string): Promise<void>;\n  /** Fill an input (shorthand) */\n  fill(selector: string, value: string): Promise<void>;\n  /** Take a screenshot */\n  screenshot(options?: { path?: string; fullPage?: boolean; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<void>;\n  /** Generate a PDF (Chromium only) */\n  pdf(options?: { path?: string; format?: string; landscape?: boolean; margin?: { top?: string; bottom?: string; left?: string; right?: string } }): Promise<string>;\n  /** Set the viewport size */\n  setViewportSize(size: { width: number; height: number }): Promise<void>;\n  /** Get the viewport size */\n  viewportSize(): Promise<{ width: number; height: number } | null>;\n  /** Emulate media type or color scheme */\n  emulateMedia(options: { media?: \"screen\" | \"print\" | null; colorScheme?: \"light\" | \"dark\" | \"no-preference\" | null }): Promise<void>;\n  /** Set extra HTTP headers */\n  setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;\n  /** Bring the page to front */\n  bringToFront(): Promise<void>;\n  /** Close the page */\n  close(): Promise<void>;\n  /** Check if the page is closed */\n  isClosed(): Promise<boolean>;\n  /** Pause execution (for debugging) */\n  pause(): Promise<void>;\n  /** Get all frames */\n  frames(): Promise<FrameInfo[]>;\n  /** Get the main frame */\n  mainFrame(): Promise<FrameInfo>;\n  /** Get the browser context for this page */\n  context(): IsolateContext;\n  /** Keyboard API */\n  readonly keyboard: Keyboard;\n  /** Mouse API */\n  readonly mouse: Mouse;\n  /** Request API for making HTTP requests */\n  readonly request: APIRequestContext;\n}\n\n/**\n * IsolateContext - represents a browser context in the isolate.\n */\ndeclare class IsolateContext {\n  /** Create a new page in this context (requires createPage callback) */\n  newPage(): Promise<IsolatePage>;\n  /** Get tracked pages for this context */\n  pages(): Promise<IsolatePage[]>;\n  /** Close this context and all its pages */\n  close(): Promise<void>;\n  /** Clear all cookies */\n  clearCookies(): Promise<void>;\n  /** Add cookies */\n  addCookies(cookies: Cookie[]): Promise<void>;\n  /** Get cookies */\n  cookies(urls?: string | string[]): Promise<Cookie[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ninterface IsolateBrowser {\n  /** Create a new browser context (requires createContext callback) */\n  newContext(options?: {\n    viewport?: { width: number; height: number } | null;\n    userAgent?: string;\n    locale?: string;\n    timezoneId?: string;\n    geolocation?: { latitude: number; longitude: number; accuracy?: number };\n    permissions?: string[];\n    colorScheme?: \"light\" | \"dark\" | \"no-preference\";\n  }): Promise<IsolateContext>;\n  /** Get tracked browser contexts */\n  contexts(): Promise<IsolateContext[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ndeclare const browser: IsolateBrowser;\n\n// ============================================================================\n// Playwright Expect Matchers (extends test-environment expect)\n// ============================================================================\n\n/**\n * Options for locator assertion timeouts.\n */\ninterface LocatorAssertionOptions {\n  timeout?: number;\n}\n\n/**\n * Locator-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(locator).\n */\ninterface PlaywrightLocatorMatchers {\n  /** Assert element is visible */\n  toBeVisible(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is hidden */\n  toBeHidden(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is enabled */\n  toBeEnabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is disabled */\n  toBeDisabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is checked */\n  toBeChecked(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is focused */\n  toBeFocused(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is empty */\n  toBeEmpty(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is attached to DOM */\n  toBeAttached(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is editable */\n  toBeEditable(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is in viewport */\n  toBeInViewport(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains text */\n  toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has exact text */\n  toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has value (for inputs) */\n  toHaveValue(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has attribute */\n  toHaveAttribute(name: string, value?: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element count */\n  toHaveCount(count: number, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has class */\n  toHaveClass(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains class */\n  toContainClass(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has id */\n  toHaveId(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has CSS property */\n  toHaveCSS(name: string, value: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has JavaScript property */\n  toHaveJSProperty(name: string, value: unknown, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible name */\n  toHaveAccessibleName(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible description */\n  toHaveAccessibleDescription(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has ARIA role */\n  toHaveRole(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightLocatorMatchers;\n}\n\n/**\n * Page-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(page).\n */\ninterface PlaywrightPageMatchers {\n  /** Assert page has URL */\n  toHaveURL(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert page has title */\n  toHaveTitle(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightPageMatchers;\n}\n";
+export declare const SANDBOX_ISOLATE_TYPES = "\ndeclare module \"@ricsam/isolate\" {\n  export interface NestedModuleImporter {\n    path: string;\n    resolveDir: string;\n  }\n\n  export interface NestedModuleSource {\n    code: string;\n    filename: string;\n    resolveDir: string;\n    static?: boolean;\n  }\n\n  export type NestedModuleResolveResult =\n    | string\n    | NestedModuleSource\n    | null\n    | undefined\n    | Promise<string | NestedModuleSource | null | undefined>;\n\n  export interface NestedFileBindings {\n    readFile?: (path: string) => Promise<ArrayBuffer>;\n    writeFile?: (path: string, data: ArrayBuffer) => Promise<void>;\n    unlink?: (path: string) => Promise<void>;\n    readdir?: (path: string) => Promise<string[]>;\n    mkdir?: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n    rmdir?: (path: string) => Promise<void>;\n    stat?: (\n      path: string,\n    ) => Promise<{ isFile: boolean; isDirectory: boolean; size: number }>;\n    rename?: (from: string, to: string) => Promise<void>;\n  }\n\n  export interface NestedBrowserBindings {\n    createContext?: (options: unknown) => Promise<unknown> | unknown;\n    createPage?: (contextHandle: unknown) => Promise<unknown> | unknown;\n  }\n\n  export interface NestedHostBindings {\n    console?: {\n      onEntry?: (entry: unknown) => void;\n    };\n    fetch?: (request: Request) => Response | Promise<Response>;\n    files?: NestedFileBindings;\n    modules?: {\n      resolve(\n        specifier: string,\n        importer: NestedModuleImporter,\n      ): NestedModuleResolveResult;\n    };\n    tools?: Record<string, (...args: any[]) => unknown>;\n    browser?: unknown;\n  }\n\n  export interface NestedRuntimeDiagnostics {\n    activeRequests: number;\n    activeResources: number;\n    pendingFiles: number;\n    pendingFetches: number;\n    pendingModules: number;\n    pendingTools: number;\n    streamCount: number;\n    lastError?: string;\n    reused?: boolean;\n    lifecycleState: \"idle\" | \"active\" | \"reloading\" | \"disposing\";\n  }\n\n  export interface NestedBrowserDiagnostics {\n    contexts: number;\n    pages: number;\n    browserConsoleLogs: number;\n    networkRequests: number;\n    networkResponses: number;\n    pageErrors: number;\n    requestFailures: number;\n    collectedData: {\n      browserConsoleLogs: unknown[];\n      pageErrors: unknown[];\n      networkRequests: unknown[];\n      networkResponses: unknown[];\n      requestFailures: unknown[];\n    };\n  }\n\n  export interface NestedRuntimeResourceDiagnostics {\n    runtime: NestedRuntimeDiagnostics;\n    browser?: NestedBrowserDiagnostics;\n  }\n\n  export interface NestedTestDiagnostics {\n    enabled: true;\n    registeredTests: number;\n    lastRun?: unknown;\n  }\n\n  export interface NestedTestRuntimeDiagnostics extends NestedRuntimeResourceDiagnostics {\n    test: NestedTestDiagnostics;\n  }\n\n  export interface NestedHostDiagnostics {\n    runtimes: number;\n    servers: number;\n    connected: boolean;\n  }\n\n  export type NestedRequestResult =\n    | { type: \"response\"; response: Response }\n    | { type: \"websocket\"; upgradeData: Record<string, unknown> };\n\n  export interface NestedScriptRuntime {\n    eval(\n      code: string,\n      options?: string | { filename?: string; executionTimeout?: number },\n    ): Promise<void>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n    diagnostics(): Promise<NestedRuntimeResourceDiagnostics>;\n    events: {\n      on(event: string, handler: (payload: unknown) => void): () => void;\n      emit(event: string, payload: unknown): Promise<void>;\n    };\n  }\n\n  export interface NestedAppServer {\n    handle(\n      request: Request | string,\n      options?: { requestId?: string; metadata?: Record<string, string> },\n    ): Promise<NestedRequestResult>;\n    ws: {\n      open(connectionId: string): Promise<void>;\n      message(connectionId: string, data: string | ArrayBuffer): Promise<void>;\n      close(connectionId: string, code: number, reason: string): Promise<void>;\n      error(connectionId: string, error: Error): Promise<void>;\n    };\n    reload(reason?: string): Promise<void>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n    diagnostics(): Promise<NestedRuntimeResourceDiagnostics>;\n  }\n\n  export interface NestedTestRuntime {\n    run(\n      code: string,\n      options?: { filename?: string; timeoutMs?: number },\n    ): Promise<unknown>;\n    diagnostics(): Promise<NestedTestRuntimeDiagnostics>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n  }\n\n  export interface NestedCreateRuntimeOptions {\n    key?: string;\n    bindings?: NestedHostBindings;\n    cwd?: string;\n    executionTimeout?: number;\n    memoryLimitMB?: number;\n  }\n\n  export interface NestedCreateTestRuntimeOptions extends NestedCreateRuntimeOptions {}\n\n  export interface NestedCreateAppServerOptions extends NestedCreateRuntimeOptions {\n    key: string;\n    entry: string;\n    entryFilename?: string;\n  }\n\n  export interface NestedIsolateHost {\n    createRuntime(options?: NestedCreateRuntimeOptions): Promise<NestedScriptRuntime>;\n    createAppServer(options: NestedCreateAppServerOptions): Promise<NestedAppServer>;\n    createTestRuntime(\n      options?: NestedCreateTestRuntimeOptions,\n    ): Promise<NestedTestRuntime>;\n    diagnostics(): Promise<NestedHostDiagnostics>;\n    close(): Promise<void>;\n  }\n\n  export function createIsolateHost(): NestedIsolateHost;\n}\n";
 /**
  * Map of package names to their type definitions.
  */
 export declare const TYPE_DEFINITIONS: {
     readonly core: "/**\n * Global Type Definitions for ../core/index.ts\n *\n * These types define the globals injected by setupCore() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n *\n * @example\n * // In your tsconfig.isolate.json\n * {\n *   \"compilerOptions\": {\n *     \"lib\": [\"ESNext\", \"DOM\"]\n *   }\n * }\n *\n * // Then reference this file or use ts-morph for code strings\n */\n\nexport {};\n\ndeclare global {\n  // ============================================\n  // Async Context\n  // ============================================\n\n  interface AsyncContextVariableOptions<T = unknown> {\n    defaultValue?: T;\n    name?: string;\n  }\n\n  interface AsyncContextVariable<T = unknown> {\n    readonly name: string;\n    run<R, A extends unknown[]>(value: T, fn: (...args: A) => R, ...args: A): R;\n    get(): T;\n  }\n\n  interface AsyncContextVariableConstructor {\n    new <T = unknown>(options?: AsyncContextVariableOptions<T>): AsyncContextVariable<T>;\n    readonly prototype: AsyncContextVariable<unknown>;\n  }\n\n  interface AsyncContextSnapshot {\n    run<R, A extends unknown[]>(fn: (...args: A) => R, ...args: A): R;\n  }\n\n  interface AsyncContextSnapshotConstructor {\n    new (): AsyncContextSnapshot;\n    wrap<T extends (...args: any[]) => any>(fn: T): T;\n    readonly prototype: AsyncContextSnapshot;\n  }\n\n  const AsyncContext: {\n    Variable: AsyncContextVariableConstructor;\n    Snapshot: AsyncContextSnapshotConstructor;\n  };\n\n  // ============================================\n  // Web Streams API\n  // ============================================\n\n  /**\n   * A readable stream of data.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream\n   */\n  const ReadableStream: typeof globalThis.ReadableStream;\n\n  /**\n   * A writable stream of data.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/WritableStream\n   */\n  const WritableStream: typeof globalThis.WritableStream;\n\n  /**\n   * A transform stream that can be used to pipe data through a transformer.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/TransformStream\n   */\n  const TransformStream: typeof globalThis.TransformStream;\n\n  /**\n   * Default reader for ReadableStream\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader\n   */\n  const ReadableStreamDefaultReader: typeof globalThis.ReadableStreamDefaultReader;\n\n  /**\n   * Default writer for WritableStream\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/WritableStreamDefaultWriter\n   */\n  const WritableStreamDefaultWriter: typeof globalThis.WritableStreamDefaultWriter;\n\n  // ============================================\n  // Blob and File APIs\n  // ============================================\n\n  /**\n   * A file-like object of immutable, raw data.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Blob\n   */\n  const Blob: typeof globalThis.Blob;\n\n  /**\n   * A file object representing a file.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/File\n   */\n  const File: typeof globalThis.File;\n\n  // ============================================\n  // URL APIs\n  // ============================================\n\n  /**\n   * Interface for URL manipulation.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/URL\n   */\n  const URL: typeof globalThis.URL;\n\n  /**\n   * Utility for working with URL query strings.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams\n   */\n  const URLSearchParams: typeof globalThis.URLSearchParams;\n\n  // ============================================\n  // DOM Parsing and Constructors\n  // ============================================\n\n  /**\n   * Parses HTML/XML strings into Document objects.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser\n   */\n  const DOMParser: typeof globalThis.DOMParser;\n\n  /**\n   * Base DOM node constructor.\n   */\n  const Node: typeof globalThis.Node;\n\n  /**\n   * DOM document constructor.\n   */\n  const Document: typeof globalThis.Document;\n\n  /**\n   * DOM document fragment constructor.\n   */\n  const DocumentFragment: typeof globalThis.DocumentFragment;\n\n  /**\n   * DOM document type constructor.\n   */\n  const DocumentType: typeof globalThis.DocumentType;\n\n  /**\n   * DOM element constructor.\n   */\n  const Element: typeof globalThis.Element;\n\n  /**\n   * DOM attribute constructor.\n   */\n  const Attr: typeof globalThis.Attr;\n\n  /**\n   * DOM text node constructor.\n   */\n  const Text: typeof globalThis.Text;\n\n  /**\n   * DOM comment node constructor.\n   */\n  const Comment: typeof globalThis.Comment;\n\n  /**\n   * DOM event constructor.\n   */\n  const Event: typeof globalThis.Event;\n\n  /**\n   * Base event target constructor.\n   */\n  const EventTarget: typeof globalThis.EventTarget;\n\n  /**\n   * Custom event constructor.\n   */\n  const CustomEvent: typeof globalThis.CustomEvent;\n\n  // ============================================\n  // Error Handling\n  // ============================================\n\n  /**\n   * Exception type for DOM operations.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n   */\n  const DOMException: typeof globalThis.DOMException;\n}\n";
+    readonly sandboxIsolate: "\ndeclare module \"@ricsam/isolate\" {\n  export interface NestedModuleImporter {\n    path: string;\n    resolveDir: string;\n  }\n\n  export interface NestedModuleSource {\n    code: string;\n    filename: string;\n    resolveDir: string;\n    static?: boolean;\n  }\n\n  export type NestedModuleResolveResult =\n    | string\n    | NestedModuleSource\n    | null\n    | undefined\n    | Promise<string | NestedModuleSource | null | undefined>;\n\n  export interface NestedFileBindings {\n    readFile?: (path: string) => Promise<ArrayBuffer>;\n    writeFile?: (path: string, data: ArrayBuffer) => Promise<void>;\n    unlink?: (path: string) => Promise<void>;\n    readdir?: (path: string) => Promise<string[]>;\n    mkdir?: (path: string, options?: { recursive?: boolean }) => Promise<void>;\n    rmdir?: (path: string) => Promise<void>;\n    stat?: (\n      path: string,\n    ) => Promise<{ isFile: boolean; isDirectory: boolean; size: number }>;\n    rename?: (from: string, to: string) => Promise<void>;\n  }\n\n  export interface NestedBrowserBindings {\n    createContext?: (options: unknown) => Promise<unknown> | unknown;\n    createPage?: (contextHandle: unknown) => Promise<unknown> | unknown;\n  }\n\n  export interface NestedHostBindings {\n    console?: {\n      onEntry?: (entry: unknown) => void;\n    };\n    fetch?: (request: Request) => Response | Promise<Response>;\n    files?: NestedFileBindings;\n    modules?: {\n      resolve(\n        specifier: string,\n        importer: NestedModuleImporter,\n      ): NestedModuleResolveResult;\n    };\n    tools?: Record<string, (...args: any[]) => unknown>;\n    browser?: unknown;\n  }\n\n  export interface NestedRuntimeDiagnostics {\n    activeRequests: number;\n    activeResources: number;\n    pendingFiles: number;\n    pendingFetches: number;\n    pendingModules: number;\n    pendingTools: number;\n    streamCount: number;\n    lastError?: string;\n    reused?: boolean;\n    lifecycleState: \"idle\" | \"active\" | \"reloading\" | \"disposing\";\n  }\n\n  export interface NestedBrowserDiagnostics {\n    contexts: number;\n    pages: number;\n    browserConsoleLogs: number;\n    networkRequests: number;\n    networkResponses: number;\n    pageErrors: number;\n    requestFailures: number;\n    collectedData: {\n      browserConsoleLogs: unknown[];\n      pageErrors: unknown[];\n      networkRequests: unknown[];\n      networkResponses: unknown[];\n      requestFailures: unknown[];\n    };\n  }\n\n  export interface NestedRuntimeResourceDiagnostics {\n    runtime: NestedRuntimeDiagnostics;\n    browser?: NestedBrowserDiagnostics;\n  }\n\n  export interface NestedTestDiagnostics {\n    enabled: true;\n    registeredTests: number;\n    lastRun?: unknown;\n  }\n\n  export interface NestedTestRuntimeDiagnostics extends NestedRuntimeResourceDiagnostics {\n    test: NestedTestDiagnostics;\n  }\n\n  export interface NestedHostDiagnostics {\n    runtimes: number;\n    servers: number;\n    connected: boolean;\n  }\n\n  export type NestedRequestResult =\n    | { type: \"response\"; response: Response }\n    | { type: \"websocket\"; upgradeData: Record<string, unknown> };\n\n  export interface NestedScriptRuntime {\n    eval(\n      code: string,\n      options?: string | { filename?: string; executionTimeout?: number },\n    ): Promise<void>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n    diagnostics(): Promise<NestedRuntimeResourceDiagnostics>;\n    events: {\n      on(event: string, handler: (payload: unknown) => void): () => void;\n      emit(event: string, payload: unknown): Promise<void>;\n    };\n  }\n\n  export interface NestedAppServer {\n    handle(\n      request: Request | string,\n      options?: { requestId?: string; metadata?: Record<string, string> },\n    ): Promise<NestedRequestResult>;\n    ws: {\n      open(connectionId: string): Promise<void>;\n      message(connectionId: string, data: string | ArrayBuffer): Promise<void>;\n      close(connectionId: string, code: number, reason: string): Promise<void>;\n      error(connectionId: string, error: Error): Promise<void>;\n    };\n    reload(reason?: string): Promise<void>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n    diagnostics(): Promise<NestedRuntimeResourceDiagnostics>;\n  }\n\n  export interface NestedTestRuntime {\n    run(\n      code: string,\n      options?: { filename?: string; timeoutMs?: number },\n    ): Promise<unknown>;\n    diagnostics(): Promise<NestedTestRuntimeDiagnostics>;\n    dispose(options?: { hard?: boolean; reason?: string }): Promise<void>;\n  }\n\n  export interface NestedCreateRuntimeOptions {\n    key?: string;\n    bindings?: NestedHostBindings;\n    cwd?: string;\n    executionTimeout?: number;\n    memoryLimitMB?: number;\n  }\n\n  export interface NestedCreateTestRuntimeOptions extends NestedCreateRuntimeOptions {}\n\n  export interface NestedCreateAppServerOptions extends NestedCreateRuntimeOptions {\n    key: string;\n    entry: string;\n    entryFilename?: string;\n  }\n\n  export interface NestedIsolateHost {\n    createRuntime(options?: NestedCreateRuntimeOptions): Promise<NestedScriptRuntime>;\n    createAppServer(options: NestedCreateAppServerOptions): Promise<NestedAppServer>;\n    createTestRuntime(\n      options?: NestedCreateTestRuntimeOptions,\n    ): Promise<NestedTestRuntime>;\n    diagnostics(): Promise<NestedHostDiagnostics>;\n    close(): Promise<void>;\n  }\n\n  export function createIsolateHost(): NestedIsolateHost;\n}\n";
     readonly console: "/**\n * Global Type Definitions for ../console/index.ts\n *\n * These types define the globals injected by setupConsole() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n */\n\nexport {};\n\ndeclare global {\n  /**\n   * Console interface for logging and debugging.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Console\n   */\n  interface Console {\n    /**\n     * Log a message to the console.\n     * @param data - Values to log\n     */\n    log(...data: unknown[]): void;\n\n    /**\n     * Log a warning message.\n     * @param data - Values to log\n     */\n    warn(...data: unknown[]): void;\n\n    /**\n     * Log an error message.\n     * @param data - Values to log\n     */\n    error(...data: unknown[]): void;\n\n    /**\n     * Log a debug message.\n     * @param data - Values to log\n     */\n    debug(...data: unknown[]): void;\n\n    /**\n     * Log an info message.\n     * @param data - Values to log\n     */\n    info(...data: unknown[]): void;\n\n    /**\n     * Log a stack trace.\n     * @param data - Values to log with the trace\n     */\n    trace(...data: unknown[]): void;\n\n    /**\n     * Display an object in a formatted way.\n     * @param item - Object to display\n     * @param options - Display options\n     */\n    dir(item: unknown, options?: object): void;\n\n    /**\n     * Display tabular data.\n     * @param tabularData - Data to display as a table\n     * @param properties - Optional array of property names to include\n     */\n    table(tabularData: unknown, properties?: string[]): void;\n\n    /**\n     * Start a timer.\n     * @param label - Timer label (default: \"default\")\n     */\n    time(label?: string): void;\n\n    /**\n     * End a timer and log the elapsed time.\n     * @param label - Timer label (default: \"default\")\n     */\n    timeEnd(label?: string): void;\n\n    /**\n     * Log the elapsed time of a timer without ending it.\n     * @param label - Timer label (default: \"default\")\n     * @param data - Additional values to log\n     */\n    timeLog(label?: string, ...data: unknown[]): void;\n\n    /**\n     * Log an error if the assertion is false.\n     * @param condition - Condition to test\n     * @param data - Values to log if assertion fails\n     */\n    assert(condition?: boolean, ...data: unknown[]): void;\n\n    /**\n     * Increment and log a counter.\n     * @param label - Counter label (default: \"default\")\n     */\n    count(label?: string): void;\n\n    /**\n     * Reset a counter.\n     * @param label - Counter label (default: \"default\")\n     */\n    countReset(label?: string): void;\n\n    /**\n     * Clear the console.\n     */\n    clear(): void;\n\n    /**\n     * Start an inline group.\n     * @param data - Group label\n     */\n    group(...data: unknown[]): void;\n\n    /**\n     * Start a collapsed inline group.\n     * @param data - Group label\n     */\n    groupCollapsed(...data: unknown[]): void;\n\n    /**\n     * End the current inline group.\n     */\n    groupEnd(): void;\n  }\n\n  /**\n   * Console object for logging and debugging.\n   */\n  const console: Console;\n}\n";
     readonly crypto: "/**\n * Global Type Definitions for ../crypto/index.ts\n *\n * These types define the globals injected by setupCrypto() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n *\n * @example\n * // Generate random bytes\n * const arr = new Uint8Array(16);\n * crypto.getRandomValues(arr);\n *\n * // Generate UUID\n * const uuid = crypto.randomUUID();\n *\n * // Use SubtleCrypto\n * const key = await crypto.subtle.generateKey(\n *   { name: \"AES-GCM\", length: 256 },\n *   true,\n *   [\"encrypt\", \"decrypt\"]\n * );\n */\n\nexport {};\n\ndeclare global {\n  /**\n   * CryptoKey represents a cryptographic key.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey\n   */\n  interface CryptoKey {\n    /**\n     * The type of key: \"public\", \"private\", or \"secret\".\n     */\n    readonly type: \"public\" | \"private\" | \"secret\";\n\n    /**\n     * Whether the key can be exported.\n     */\n    readonly extractable: boolean;\n\n    /**\n     * The algorithm used by this key.\n     */\n    readonly algorithm: KeyAlgorithm;\n\n    /**\n     * The usages allowed for this key.\n     */\n    readonly usages: ReadonlyArray<KeyUsage>;\n  }\n\n  /**\n   * CryptoKey constructor (keys cannot be constructed directly).\n   */\n  const CryptoKey: {\n    prototype: CryptoKey;\n  };\n\n  /**\n   * SubtleCrypto interface for cryptographic operations.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto\n   */\n  interface SubtleCrypto {\n    /**\n     * Generate a digest (hash) of the given data.\n     *\n     * @param algorithm - Hash algorithm (e.g., \"SHA-256\", \"SHA-384\", \"SHA-512\")\n     * @param data - Data to hash\n     * @returns Promise resolving to the hash as ArrayBuffer\n     */\n    digest(\n      algorithm: AlgorithmIdentifier,\n      data: BufferSource\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Generate a new cryptographic key or key pair.\n     *\n     * @param algorithm - Key generation algorithm\n     * @param extractable - Whether the key can be exported\n     * @param keyUsages - Allowed key usages\n     * @returns Promise resolving to a CryptoKey or CryptoKeyPair\n     */\n    generateKey(\n      algorithm: RsaHashedKeyGenParams | EcKeyGenParams | AesKeyGenParams | HmacKeyGenParams,\n      extractable: boolean,\n      keyUsages: KeyUsage[]\n    ): Promise<CryptoKey | CryptoKeyPair>;\n\n    /**\n     * Sign data using a private key.\n     *\n     * @param algorithm - Signing algorithm\n     * @param key - Private key to sign with\n     * @param data - Data to sign\n     * @returns Promise resolving to the signature as ArrayBuffer\n     */\n    sign(\n      algorithm: AlgorithmIdentifier,\n      key: CryptoKey,\n      data: BufferSource\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Verify a signature.\n     *\n     * @param algorithm - Signing algorithm\n     * @param key - Public key to verify with\n     * @param signature - Signature to verify\n     * @param data - Data that was signed\n     * @returns Promise resolving to true if valid, false otherwise\n     */\n    verify(\n      algorithm: AlgorithmIdentifier,\n      key: CryptoKey,\n      signature: BufferSource,\n      data: BufferSource\n    ): Promise<boolean>;\n\n    /**\n     * Encrypt data.\n     *\n     * @param algorithm - Encryption algorithm\n     * @param key - Encryption key\n     * @param data - Data to encrypt\n     * @returns Promise resolving to encrypted data as ArrayBuffer\n     */\n    encrypt(\n      algorithm: AlgorithmIdentifier,\n      key: CryptoKey,\n      data: BufferSource\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Decrypt data.\n     *\n     * @param algorithm - Decryption algorithm\n     * @param key - Decryption key\n     * @param data - Data to decrypt\n     * @returns Promise resolving to decrypted data as ArrayBuffer\n     */\n    decrypt(\n      algorithm: AlgorithmIdentifier,\n      key: CryptoKey,\n      data: BufferSource\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Import a key from external data.\n     *\n     * @param format - Key format (\"raw\", \"pkcs8\", \"spki\", \"jwk\")\n     * @param keyData - Key data\n     * @param algorithm - Key algorithm\n     * @param extractable - Whether the key can be exported\n     * @param keyUsages - Allowed key usages\n     * @returns Promise resolving to a CryptoKey\n     */\n    importKey(\n      format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\",\n      keyData: BufferSource | JsonWebKey,\n      algorithm: AlgorithmIdentifier,\n      extractable: boolean,\n      keyUsages: KeyUsage[]\n    ): Promise<CryptoKey>;\n\n    /**\n     * Export a key.\n     *\n     * @param format - Export format (\"raw\", \"pkcs8\", \"spki\", \"jwk\")\n     * @param key - Key to export\n     * @returns Promise resolving to ArrayBuffer or JsonWebKey\n     */\n    exportKey(\n      format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\",\n      key: CryptoKey\n    ): Promise<ArrayBuffer | JsonWebKey>;\n\n    /**\n     * Derive bits from a key.\n     *\n     * @param algorithm - Derivation algorithm\n     * @param baseKey - Base key for derivation\n     * @param length - Number of bits to derive\n     * @returns Promise resolving to derived bits as ArrayBuffer\n     */\n    deriveBits(\n      algorithm: AlgorithmIdentifier,\n      baseKey: CryptoKey,\n      length: number\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Derive a new key from a base key.\n     *\n     * @param algorithm - Derivation algorithm\n     * @param baseKey - Base key for derivation\n     * @param derivedKeyType - Type of key to derive\n     * @param extractable - Whether the derived key can be exported\n     * @param keyUsages - Allowed usages for derived key\n     * @returns Promise resolving to a CryptoKey\n     */\n    deriveKey(\n      algorithm: AlgorithmIdentifier,\n      baseKey: CryptoKey,\n      derivedKeyType: AlgorithmIdentifier,\n      extractable: boolean,\n      keyUsages: KeyUsage[]\n    ): Promise<CryptoKey>;\n\n    /**\n     * Wrap a key for secure export.\n     *\n     * @param format - Key format\n     * @param key - Key to wrap\n     * @param wrappingKey - Key to wrap with\n     * @param wrapAlgorithm - Wrapping algorithm\n     * @returns Promise resolving to wrapped key as ArrayBuffer\n     */\n    wrapKey(\n      format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\",\n      key: CryptoKey,\n      wrappingKey: CryptoKey,\n      wrapAlgorithm: AlgorithmIdentifier\n    ): Promise<ArrayBuffer>;\n\n    /**\n     * Unwrap a wrapped key.\n     *\n     * @param format - Key format\n     * @param wrappedKey - Wrapped key data\n     * @param unwrappingKey - Key to unwrap with\n     * @param unwrapAlgorithm - Unwrapping algorithm\n     * @param unwrappedKeyAlgorithm - Algorithm for the unwrapped key\n     * @param extractable - Whether the unwrapped key can be exported\n     * @param keyUsages - Allowed usages for unwrapped key\n     * @returns Promise resolving to a CryptoKey\n     */\n    unwrapKey(\n      format: \"raw\" | \"pkcs8\" | \"spki\" | \"jwk\",\n      wrappedKey: BufferSource,\n      unwrappingKey: CryptoKey,\n      unwrapAlgorithm: AlgorithmIdentifier,\n      unwrappedKeyAlgorithm: AlgorithmIdentifier,\n      extractable: boolean,\n      keyUsages: KeyUsage[]\n    ): Promise<CryptoKey>;\n  }\n\n  /**\n   * Crypto interface providing cryptographic functionality.\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto\n   */\n  interface Crypto {\n    /**\n     * SubtleCrypto interface for cryptographic operations.\n     */\n    readonly subtle: SubtleCrypto;\n\n    /**\n     * Fill a TypedArray with cryptographically random values.\n     *\n     * @param array - TypedArray to fill (max 65536 bytes)\n     * @returns The same array, filled with random values\n     *\n     * @example\n     * const arr = new Uint8Array(16);\n     * crypto.getRandomValues(arr);\n     */\n    getRandomValues<T extends ArrayBufferView | null>(array: T): T;\n\n    /**\n     * Generate a random UUID v4.\n     *\n     * @returns A random UUID string\n     *\n     * @example\n     * const uuid = crypto.randomUUID();\n     * // \"550e8400-e29b-41d4-a716-446655440000\"\n     */\n    randomUUID(): string;\n  }\n\n  /**\n   * Crypto object providing cryptographic functionality.\n   */\n  const crypto: Crypto;\n}\n";
     readonly encoding: "/**\n * Global Type Definitions for ../encoding/index.ts\n *\n * These types define the globals injected by setupEncoding() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n */\n\nexport {};\n\ndeclare global {\n  /**\n   * Decodes a Base64-encoded string.\n   *\n   * @param encodedData - The Base64 string to decode\n   * @returns The decoded string\n   * @throws DOMException if the input is not valid Base64\n   *\n   * @example\n   * atob(\"SGVsbG8=\"); // \"Hello\"\n   */\n  function atob(encodedData: string): string;\n\n  /**\n   * Encodes a string to Base64.\n   *\n   * @param stringToEncode - The string to encode (must contain only Latin1 characters)\n   * @returns The Base64 encoded string\n   * @throws DOMException if the string contains characters outside Latin1 range (0-255)\n   *\n   * @example\n   * btoa(\"Hello\"); // \"SGVsbG8=\"\n   */\n  function btoa(stringToEncode: string): string;\n\n  // ============================================\n  // Buffer\n  // ============================================\n\n  /**\n   * Buffer encoding types supported by the isolate Buffer implementation.\n   */\n  type BufferEncoding = \"utf8\" | \"utf-8\" | \"base64\" | \"hex\";\n\n  /**\n   * Buffer class for working with binary data.\n   * Extends Uint8Array for compatibility.\n   * @see https://nodejs.org/api/buffer.html\n   */\n  interface Buffer extends Uint8Array {\n    /**\n     * Convert the buffer to a string.\n     *\n     * @param encoding - The encoding to use (default: \"utf8\")\n     * @returns The string representation\n     *\n     * @example\n     * const buf = Buffer.from(\"hello\");\n     * buf.toString(); // \"hello\"\n     * buf.toString(\"hex\"); // \"68656c6c6f\"\n     * buf.toString(\"base64\"); // \"aGVsbG8=\"\n     */\n    toString(encoding?: BufferEncoding): string;\n\n    /**\n     * Returns a new Buffer that references the same memory as the original,\n     * but offset and cropped by the start and end indices.\n     *\n     * @param start - Start index (default: 0)\n     * @param end - End index (default: buffer.length)\n     * @returns A new Buffer instance\n     *\n     * @example\n     * const buf = Buffer.from(\"hello\");\n     * buf.slice(1, 4).toString(); // \"ell\"\n     */\n    slice(start?: number, end?: number): Buffer;\n\n    /**\n     * Returns a new Buffer that references the same memory as the original,\n     * but offset and cropped by the start and end indices.\n     *\n     * @param start - Start index (default: 0)\n     * @param end - End index (default: buffer.length)\n     * @returns A new Buffer instance\n     */\n    subarray(start?: number, end?: number): Buffer;\n  }\n\n  /**\n   * Buffer constructor interface.\n   */\n  interface BufferConstructor {\n    /**\n     * Creates a new Buffer from a string, array, ArrayBuffer, or another Buffer.\n     *\n     * @param value - The value to create a buffer from\n     * @param encodingOrOffset - Encoding for strings, or byte offset for ArrayBuffer\n     * @param length - Length for ArrayBuffer (when offset is provided)\n     * @returns A new Buffer instance\n     *\n     * @example\n     * Buffer.from(\"hello\"); // UTF-8 encoded\n     * Buffer.from(\"aGVsbG8=\", \"base64\"); // base64 decoded\n     * Buffer.from(\"68656c6c6f\", \"hex\"); // hex decoded\n     * Buffer.from([104, 101, 108, 108, 111]); // from array\n     */\n    from(value: string, encoding?: BufferEncoding): Buffer;\n    from(value: ArrayBuffer, byteOffset?: number, length?: number): Buffer;\n    from(value: Uint8Array | ReadonlyArray<number>): Buffer;\n    from(value: Iterable<number>): Buffer;\n\n    /**\n     * Allocates a new Buffer of the specified size, filled with zeros or the specified fill value.\n     *\n     * @param size - The size of the buffer in bytes\n     * @param fill - Value to fill the buffer with (default: 0)\n     * @param encoding - Encoding for string fill values\n     * @returns A new Buffer instance\n     *\n     * @example\n     * Buffer.alloc(5); // <Buffer 00 00 00 00 00>\n     * Buffer.alloc(5, 1); // <Buffer 01 01 01 01 01>\n     * Buffer.alloc(5, \"ab\"); // <Buffer 61 62 61 62 61>\n     */\n    alloc(size: number, fill?: number | string | Buffer, encoding?: BufferEncoding): Buffer;\n\n    /**\n     * Allocates a new Buffer of the specified size without initializing the memory.\n     * The contents are unknown and may contain sensitive data.\n     *\n     * @param size - The size of the buffer in bytes\n     * @returns A new Buffer instance\n     */\n    allocUnsafe(size: number): Buffer;\n\n    /**\n     * Concatenates a list of Buffers.\n     *\n     * @param list - Array of Buffer instances to concatenate\n     * @param totalLength - Total length of the buffers (optional)\n     * @returns A new Buffer instance\n     *\n     * @example\n     * const buf1 = Buffer.from(\"hel\");\n     * const buf2 = Buffer.from(\"lo\");\n     * Buffer.concat([buf1, buf2]).toString(); // \"hello\"\n     */\n    concat(list: ReadonlyArray<Uint8Array>, totalLength?: number): Buffer;\n\n    /**\n     * Returns true if the given object is a Buffer.\n     *\n     * @param obj - Object to test\n     * @returns true if obj is a Buffer\n     *\n     * @example\n     * Buffer.isBuffer(Buffer.from(\"test\")); // true\n     * Buffer.isBuffer(new Uint8Array(5)); // false\n     */\n    isBuffer(obj: unknown): obj is Buffer;\n\n    /**\n     * Returns the byte length of a string when encoded.\n     *\n     * @param string - The string to measure\n     * @param encoding - The encoding (default: \"utf8\")\n     * @returns The byte length\n     *\n     * @example\n     * Buffer.byteLength(\"hello\"); // 5\n     * Buffer.byteLength(\"aGVsbG8=\", \"base64\"); // 5 (decoded length)\n     */\n    byteLength(string: string, encoding?: BufferEncoding): number;\n    byteLength(buffer: ArrayBufferView | ArrayBuffer): number;\n\n    /**\n     * Returns true if the encoding is a valid buffer encoding.\n     *\n     * @param encoding - The encoding to check\n     * @returns true if the encoding is supported\n     */\n    isEncoding(encoding: string): encoding is BufferEncoding;\n\n    readonly prototype: Buffer;\n  }\n\n  /**\n   * Buffer class for working with binary data.\n   * @see https://nodejs.org/api/buffer.html\n   */\n  const Buffer: BufferConstructor;\n}\n";
@@ -86,7 +88,7 @@ export declare const TYPE_DEFINITIONS: {
     readonly path: "/**\n * Global Type Definitions for ../path/index.ts\n *\n * These types define the globals injected by setupPath() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n *\n * @example\n * // Typecheck isolate code with path operations\n * const joined = path.join('/foo', 'bar', 'baz');\n * const resolved = path.resolve('relative/path');\n * const cwd = path.cwd();\n */\n\nexport {};\n\ndeclare global {\n  /**\n   * Parsed path object returned by path.parse().\n   */\n  interface ParsedPath {\n    /** The root of the path (e.g., \"/\" for absolute paths, \"\" for relative) */\n    root: string;\n    /** The directory portion of the path */\n    dir: string;\n    /** The file name including extension */\n    base: string;\n    /** The file extension (e.g., \".txt\") */\n    ext: string;\n    /** The file name without extension */\n    name: string;\n  }\n\n  /**\n   * Input object for path.format().\n   */\n  interface FormatInputPathObject {\n    root?: string;\n    dir?: string;\n    base?: string;\n    ext?: string;\n    name?: string;\n  }\n\n  /**\n   * Path utilities for POSIX paths.\n   * @see https://nodejs.org/api/path.html\n   */\n  namespace path {\n    /**\n     * Join path segments with the platform-specific separator.\n     *\n     * @param paths - Path segments to join\n     * @returns The joined path, normalized\n     *\n     * @example\n     * path.join('/foo', 'bar', 'baz'); // \"/foo/bar/baz\"\n     * path.join('foo', 'bar', '..', 'baz'); // \"foo/baz\"\n     */\n    function join(...paths: string[]): string;\n\n    /**\n     * Normalize a path, resolving '..' and '.' segments.\n     *\n     * @param p - The path to normalize\n     * @returns The normalized path\n     *\n     * @example\n     * path.normalize('/foo/bar/../baz'); // \"/foo/baz\"\n     * path.normalize('/foo//bar'); // \"/foo/bar\"\n     */\n    function normalize(p: string): string;\n\n    /**\n     * Get the last portion of a path (the file name).\n     *\n     * @param p - The path\n     * @param ext - Optional extension to remove from the result\n     * @returns The base name of the path\n     *\n     * @example\n     * path.basename('/foo/bar/baz.txt'); // \"baz.txt\"\n     * path.basename('/foo/bar/baz.txt', '.txt'); // \"baz\"\n     */\n    function basename(p: string, ext?: string): string;\n\n    /**\n     * Get the directory name of a path.\n     *\n     * @param p - The path\n     * @returns The directory portion of the path\n     *\n     * @example\n     * path.dirname('/foo/bar/baz.txt'); // \"/foo/bar\"\n     * path.dirname('/foo'); // \"/\"\n     */\n    function dirname(p: string): string;\n\n    /**\n     * Get the extension of a path.\n     *\n     * @param p - The path\n     * @returns The extension including the dot, or empty string\n     *\n     * @example\n     * path.extname('file.txt'); // \".txt\"\n     * path.extname('file.tar.gz'); // \".gz\"\n     * path.extname('.bashrc'); // \"\"\n     */\n    function extname(p: string): string;\n\n    /**\n     * Check if a path is absolute.\n     *\n     * @param p - The path to check\n     * @returns True if the path is absolute\n     *\n     * @example\n     * path.isAbsolute('/foo/bar'); // true\n     * path.isAbsolute('foo/bar'); // false\n     */\n    function isAbsolute(p: string): boolean;\n\n    /**\n     * Parse a path into its components.\n     *\n     * @param p - The path to parse\n     * @returns An object with root, dir, base, ext, and name properties\n     *\n     * @example\n     * path.parse('/foo/bar/baz.txt');\n     * // { root: \"/\", dir: \"/foo/bar\", base: \"baz.txt\", ext: \".txt\", name: \"baz\" }\n     */\n    function parse(p: string): ParsedPath;\n\n    /**\n     * Build a path from an object.\n     *\n     * @param pathObject - Object with path components\n     * @returns The formatted path string\n     *\n     * @example\n     * path.format({ dir: '/foo/bar', base: 'baz.txt' }); // \"/foo/bar/baz.txt\"\n     * path.format({ root: '/', name: 'file', ext: '.txt' }); // \"/file.txt\"\n     */\n    function format(pathObject: FormatInputPathObject): string;\n\n    /**\n     * Resolve a sequence of paths to an absolute path.\n     * Processes paths from right to left, prepending each until an absolute path is formed.\n     * Uses the configured working directory for relative paths.\n     *\n     * @param paths - Path segments to resolve\n     * @returns The resolved absolute path\n     *\n     * @example\n     * // With cwd set to \"/home/user\"\n     * path.resolve('foo/bar'); // \"/home/user/foo/bar\"\n     * path.resolve('/foo', 'bar'); // \"/foo/bar\"\n     * path.resolve('/foo', '/bar', 'baz'); // \"/bar/baz\"\n     */\n    function resolve(...paths: string[]): string;\n\n    /**\n     * Compute the relative path from one path to another.\n     *\n     * @param from - The source path\n     * @param to - The destination path\n     * @returns The relative path from 'from' to 'to'\n     *\n     * @example\n     * path.relative('/foo/bar', '/foo/baz'); // \"../baz\"\n     * path.relative('/foo', '/foo/bar/baz'); // \"bar/baz\"\n     */\n    function relative(from: string, to: string): string;\n\n    /**\n     * Get the configured working directory.\n     *\n     * @returns The current working directory\n     *\n     * @example\n     * path.cwd(); // \"/home/user\" (or whatever was configured)\n     */\n    function cwd(): string;\n\n    /**\n     * The platform-specific path segment separator.\n     * Always \"/\" for POSIX paths.\n     */\n    const sep: string;\n\n    /**\n     * The platform-specific path delimiter.\n     * Always \":\" for POSIX paths.\n     */\n    const delimiter: string;\n  }\n}\n";
     readonly testEnvironment: "/**\n * Global Type Definitions for ../test-environment/index.ts\n *\n * These types define the globals injected by setupTestEnvironment() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n *\n * @example\n * describe(\"Math operations\", () => {\n *   it(\"should add numbers\", () => {\n *     expect(1 + 1).toBe(2);\n *   });\n * });\n */\n\nexport {};\n\ndeclare global {\n  // ============================================\n  // Test Structure\n  // ============================================\n\n  /**\n   * Define a test suite.\n   *\n   * @param name - The name of the test suite\n   * @param fn - Function containing tests and nested suites\n   *\n   * @example\n   * describe(\"Calculator\", () => {\n   *   it(\"adds numbers\", () => {\n   *     expect(1 + 1).toBe(2);\n   *   });\n   * });\n   */\n  function describe(name: string, fn: () => void): void;\n\n  namespace describe {\n    /**\n     * Skip this suite and all its tests.\n     */\n    function skip(name: string, fn: () => void): void;\n\n    /**\n     * Only run this suite (and other .only suites).\n     */\n    function only(name: string, fn: () => void): void;\n\n    /**\n     * Mark suite as todo (skipped with different status).\n     */\n    function todo(name: string, fn?: () => void): void;\n  }\n\n  /**\n   * Define a test case.\n   *\n   * @param name - The name of the test\n   * @param fn - The test function (can be async)\n   *\n   * @example\n   * it(\"should work\", () => {\n   *   expect(true).toBe(true);\n   * });\n   *\n   * it(\"should work async\", async () => {\n   *   const result = await Promise.resolve(42);\n   *   expect(result).toBe(42);\n   * });\n   */\n  function it(name: string, fn: () => void | Promise<void>): void;\n\n  namespace it {\n    /**\n     * Skip this test.\n     */\n    function skip(name: string, fn?: () => void | Promise<void>): void;\n\n    /**\n     * Only run this test (and other .only tests).\n     */\n    function only(name: string, fn: () => void | Promise<void>): void;\n\n    /**\n     * Mark test as todo.\n     */\n    function todo(name: string, fn?: () => void | Promise<void>): void;\n  }\n\n  /**\n   * Alias for it().\n   */\n  function test(name: string, fn: () => void | Promise<void>): void;\n\n  namespace test {\n    /**\n     * Skip this test.\n     */\n    function skip(name: string, fn?: () => void | Promise<void>): void;\n\n    /**\n     * Only run this test (and other .only tests).\n     */\n    function only(name: string, fn: () => void | Promise<void>): void;\n\n    /**\n     * Mark test as todo.\n     */\n    function todo(name: string, fn?: () => void | Promise<void>): void;\n  }\n\n  // ============================================\n  // Lifecycle Hooks\n  // ============================================\n\n  /**\n   * Run once before all tests in the current suite.\n   *\n   * @param fn - Setup function (can be async)\n   */\n  function beforeAll(fn: () => void | Promise<void>): void;\n\n  /**\n   * Run once after all tests in the current suite.\n   *\n   * @param fn - Teardown function (can be async)\n   */\n  function afterAll(fn: () => void | Promise<void>): void;\n\n  /**\n   * Run before each test in the current suite (and nested suites).\n   *\n   * @param fn - Setup function (can be async)\n   */\n  function beforeEach(fn: () => void | Promise<void>): void;\n\n  /**\n   * Run after each test in the current suite (and nested suites).\n   *\n   * @param fn - Teardown function (can be async)\n   */\n  function afterEach(fn: () => void | Promise<void>): void;\n\n  // ============================================\n  // Assertions\n  // ============================================\n\n  /**\n   * Matchers for assertions.\n   */\n  interface Matchers<T> {\n    /**\n     * Strict equality (===).\n     */\n    toBe(expected: T): void;\n\n    /**\n     * Deep equality.\n     */\n    toEqual(expected: unknown): void;\n\n    /**\n     * Deep equality with type checking.\n     */\n    toStrictEqual(expected: unknown): void;\n\n    /**\n     * Check if value is truthy.\n     */\n    toBeTruthy(): void;\n\n    /**\n     * Check if value is falsy.\n     */\n    toBeFalsy(): void;\n\n    /**\n     * Check if value is null.\n     */\n    toBeNull(): void;\n\n    /**\n     * Check if value is undefined.\n     */\n    toBeUndefined(): void;\n\n    /**\n     * Check if value is defined (not undefined).\n     */\n    toBeDefined(): void;\n\n    /**\n     * Check if value is NaN.\n     */\n    toBeNaN(): void;\n\n    /**\n     * Check if number is greater than expected.\n     */\n    toBeGreaterThan(n: number): void;\n\n    /**\n     * Check if number is greater than or equal to expected.\n     */\n    toBeGreaterThanOrEqual(n: number): void;\n\n    /**\n     * Check if number is less than expected.\n     */\n    toBeLessThan(n: number): void;\n\n    /**\n     * Check if number is less than or equal to expected.\n     */\n    toBeLessThanOrEqual(n: number): void;\n\n    /**\n     * Check if array/string contains item/substring.\n     */\n    toContain(item: unknown): void;\n\n    /**\n     * Check length of array/string.\n     */\n    toHaveLength(length: number): void;\n\n    /**\n     * Check if object has property (optionally with value).\n     */\n    toHaveProperty(key: string, value?: unknown): void;\n\n    /**\n     * Check if function throws.\n     */\n    toThrow(expected?: string | RegExp | Error): void;\n\n    /**\n     * Check if string matches pattern.\n     */\n    toMatch(pattern: string | RegExp): void;\n\n    /**\n     * Check if object matches subset of properties.\n     */\n    toMatchObject(object: object): void;\n\n    /**\n     * Check if value is instance of class.\n     */\n    toBeInstanceOf(constructor: Function): void;\n\n    /**\n     * Negate the matcher.\n     */\n    not: Matchers<T>;\n\n    /**\n     * Await promise and check resolved value.\n     */\n    resolves: Matchers<Awaited<T>>;\n\n    /**\n     * Await promise and check rejection.\n     */\n    rejects: Matchers<unknown>;\n  }\n\n  /**\n   * Create an expectation for a value.\n   *\n   * @param actual - The value to test\n   * @returns Matchers for the value\n   *\n   * @example\n   * expect(1 + 1).toBe(2);\n   * expect({ a: 1 }).toEqual({ a: 1 });\n   * expect(() => { throw new Error(); }).toThrow();\n   * expect(promise).resolves.toBe(42);\n   */\n  function expect<T>(actual: T): Matchers<T>;\n}\n";
     readonly timers: "/**\n * Global Type Definitions for ../timers/index.ts\n *\n * These types define the globals injected by setupTimers() into an isolated-vm context.\n * Use these types to typecheck user code that will run inside the V8 isolate.\n *\n * @example\n * const timeoutId = setTimeout(() => {\n *   console.log(\"fired!\");\n * }, 1000);\n *\n * clearTimeout(timeoutId);\n *\n * const intervalId = setInterval(() => {\n *   console.log(\"tick\");\n * }, 100);\n *\n * clearInterval(intervalId);\n */\n\nexport {};\n\ndeclare global {\n  /**\n   * Schedule a callback to execute after a delay.\n   *\n   * @param callback - The function to call after the delay\n   * @param ms - The delay in milliseconds (default: 0)\n   * @param args - Additional arguments to pass to the callback\n   * @returns A timer ID that can be passed to clearTimeout\n   *\n   * @example\n   * const id = setTimeout(() => console.log(\"done\"), 1000);\n   * setTimeout((a, b) => console.log(a, b), 100, \"hello\", \"world\");\n   */\n  function setTimeout(\n    callback: (...args: unknown[]) => void,\n    ms?: number,\n    ...args: unknown[]\n  ): number;\n\n  /**\n   * Schedule a callback to execute repeatedly at a fixed interval.\n   *\n   * @param callback - The function to call at each interval\n   * @param ms - The interval in milliseconds (minimum: 4ms)\n   * @param args - Additional arguments to pass to the callback\n   * @returns A timer ID that can be passed to clearInterval\n   *\n   * @example\n   * const id = setInterval(() => console.log(\"tick\"), 1000);\n   */\n  function setInterval(\n    callback: (...args: unknown[]) => void,\n    ms?: number,\n    ...args: unknown[]\n  ): number;\n\n  /**\n   * Cancel a timeout previously scheduled with setTimeout.\n   *\n   * @param id - The timer ID returned by setTimeout\n   *\n   * @example\n   * const id = setTimeout(() => {}, 1000);\n   * clearTimeout(id);\n   */\n  function clearTimeout(id: number | undefined): void;\n\n  /**\n   * Cancel an interval previously scheduled with setInterval.\n   *\n   * @param id - The timer ID returned by setInterval\n   *\n   * @example\n   * const id = setInterval(() => {}, 1000);\n   * clearInterval(id);\n   */\n  function clearInterval(id: number | undefined): void;\n}\n";
-    readonly playwright: "\n/**\n * Locator represents an element or group of elements in the page.\n */\ndeclare class Locator {\n  /** Click the element */\n  click(): Promise<void>;\n  /** Double-click the element */\n  dblclick(): Promise<void>;\n  /** Fill an input element with text */\n  fill(text: string): Promise<void>;\n  /** Type text into an element (key by key) */\n  type(text: string): Promise<void>;\n  /** Check a checkbox or radio */\n  check(): Promise<void>;\n  /** Uncheck a checkbox */\n  uncheck(): Promise<void>;\n  /** Select an option in a dropdown */\n  selectOption(value: string | string[]): Promise<void>;\n  /** Clear an input element */\n  clear(): Promise<void>;\n  /** Press a key */\n  press(key: string): Promise<void>;\n  /** Hover over the element */\n  hover(): Promise<void>;\n  /** Focus the element */\n  focus(): Promise<void>;\n  /** Get text content of the element */\n  textContent(): Promise<string | null>;\n  /** Get the value of an input element */\n  inputValue(): Promise<string>;\n  /** Check if the element is visible */\n  isVisible(): Promise<boolean>;\n  /** Check if the element is enabled */\n  isEnabled(): Promise<boolean>;\n  /** Check if the element is checked */\n  isChecked(): Promise<boolean>;\n  /** Check if the element is disabled */\n  isDisabled(): Promise<boolean>;\n  /** Check if the element is hidden */\n  isHidden(): Promise<boolean>;\n  /** Get the count of matching elements */\n  count(): Promise<number>;\n  /** Get an attribute value */\n  getAttribute(name: string): Promise<string | null>;\n  /** Get innerHTML */\n  innerHTML(): Promise<string>;\n  /** Get innerText */\n  innerText(): Promise<string>;\n  /** Get all text contents */\n  allTextContents(): Promise<string[]>;\n  /** Get all inner texts */\n  allInnerTexts(): Promise<string[]>;\n  /** Wait for the element to match a state */\n  waitFor(options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Get bounding box */\n  boundingBox(): Promise<{ x: number; y: number; width: number; height: number } | null>;\n  /** Set input files for a file input */\n  setInputFiles(files: string | string[] | { name: string; mimeType: string; buffer: ArrayBuffer | Uint8Array | string }[]): Promise<void>;\n  /** Take a screenshot of the element */\n  screenshot(options?: { path?: string; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<string>;\n  /** Drag to another element */\n  dragTo(target: Locator): Promise<void>;\n  /** Scroll element into view */\n  scrollIntoViewIfNeeded(): Promise<void>;\n  /** Highlight the element for debugging */\n  highlight(): Promise<void>;\n  /** Evaluate a function in the context of the element */\n  evaluate<R>(fn: (el: Element, arg?: unknown) => R, arg?: unknown): Promise<R>;\n  /** Evaluate a function for all matching elements */\n  evaluateAll<R>(fn: (els: Element[], arg?: unknown) => R, arg?: unknown): Promise<R>;\n\n  // Chaining methods\n  /** Chain with another CSS selector */\n  locator(selector: string): Locator;\n  /** Chain with getByRole */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Chain with getByText */\n  getByText(text: string | RegExp): Locator;\n  /** Chain with getByLabel */\n  getByLabel(label: string | RegExp): Locator;\n  /** Chain with getByPlaceholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Chain with getByTestId */\n  getByTestId(testId: string): Locator;\n  /** Chain with getByAltText */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Chain with getByTitle */\n  getByTitle(title: string | RegExp): Locator;\n\n  // Subset selection\n  /** Get all matching locators as an array */\n  all(): Promise<Locator[]>;\n  /** Get the nth matching element */\n  nth(index: number): Locator;\n  /** Get the first matching element */\n  first(): Locator;\n  /** Get the last matching element */\n  last(): Locator;\n\n  // Filtering\n  /** Filter locators by additional criteria */\n  filter(options: { hasText?: string | RegExp; hasNotText?: string | RegExp; has?: Locator; hasNot?: Locator }): Locator;\n  /** Create a locator matching either this or the other locator */\n  or(other: Locator): Locator;\n  /** Create a locator matching both this and the other locator */\n  and(other: Locator): Locator;\n}\n\n/**\n * FrameLocator for interacting with elements inside iframes.\n */\ninterface FrameLocator {\n  locator(selector: string): Locator;\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  getByText(text: string | RegExp): Locator;\n  getByLabel(label: string | RegExp): Locator;\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  getByTestId(testId: string): Locator;\n  getByAltText(alt: string | RegExp): Locator;\n  getByTitle(title: string | RegExp): Locator;\n}\n\n/**\n * Keyboard API for simulating keyboard input.\n */\ninterface Keyboard {\n  type(text: string, options?: { delay?: number }): Promise<void>;\n  press(key: string, options?: { delay?: number }): Promise<void>;\n  down(key: string): Promise<void>;\n  up(key: string): Promise<void>;\n  insertText(text: string): Promise<void>;\n}\n\n/**\n * Mouse API for simulating mouse input.\n */\ninterface Mouse {\n  move(x: number, y: number, options?: { steps?: number }): Promise<void>;\n  click(x: number, y: number, options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number; delay?: number }): Promise<void>;\n  down(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  up(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  wheel(deltaX: number, deltaY: number): Promise<void>;\n}\n\n/**\n * API Response from page.request methods.\n */\ninterface APIResponse {\n  status(): number;\n  ok(): boolean;\n  headers(): Record<string, string>;\n  json(): Promise<unknown>;\n  text(): Promise<string>;\n  body(): Promise<ArrayBuffer>;\n}\n\n/**\n * Request API for making HTTP requests with page cookies.\n */\ninterface APIRequestContext {\n  fetch(url: string, options?: { method?: string; data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  get(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n  post(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  put(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  delete(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n}\n\n/**\n * Frame information.\n */\ninterface FrameInfo {\n  name: string;\n  url: string;\n}\n\n/**\n * Cookie data.\n */\ninterface Cookie {\n  name: string;\n  value: string;\n  domain?: string;\n  path?: string;\n  expires?: number;\n  httpOnly?: boolean;\n  secure?: boolean;\n  sameSite?: \"Strict\" | \"Lax\" | \"None\";\n}\n\n/**\n * IsolatePage - represents a browser page in the isolate.\n */\ndeclare class IsolatePage {\n  /** Navigate to a URL */\n  goto(url: string, options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Reload the page */\n  reload(): Promise<void>;\n  /** Get the current URL */\n  url(): Promise<string>;\n  /** Get the page title */\n  title(): Promise<string>;\n  /** Get the page HTML content */\n  content(): Promise<string>;\n  /** Wait for a selector to appear */\n  waitForSelector(selector: string, options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Wait for a specified time */\n  waitForTimeout(ms: number): Promise<void>;\n  /** Wait for a load state */\n  waitForLoadState(state?: \"load\" | \"domcontentloaded\" | \"networkidle\"): Promise<void>;\n  /** Wait for the URL to match */\n  waitForURL(url: string | RegExp, options?: { timeout?: number; waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Evaluate JavaScript in the browser context */\n  evaluate<R>(script: string | (() => R) | ((arg: unknown) => R), arg?: unknown): Promise<R>;\n  /** Create a locator by CSS selector */\n  locator(selector: string): Locator;\n  /** Create a locator by ARIA role */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Create a locator by text content */\n  getByText(text: string | RegExp): Locator;\n  /** Create a locator by label */\n  getByLabel(label: string | RegExp): Locator;\n  /** Create a locator by placeholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Create a locator by test ID */\n  getByTestId(testId: string): Locator;\n  /** Create a locator by alt text */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Create a locator by title */\n  getByTitle(title: string | RegExp): Locator;\n  /** Create a frame locator */\n  frameLocator(selector: string): FrameLocator;\n  /** Navigate back */\n  goBack(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Navigate forward */\n  goForward(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Click an element (shorthand) */\n  click(selector: string): Promise<void>;\n  /** Fill an input (shorthand) */\n  fill(selector: string, value: string): Promise<void>;\n  /** Take a screenshot */\n  screenshot(options?: { path?: string; fullPage?: boolean; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<string>;\n  /** Generate a PDF (Chromium only) */\n  pdf(options?: { path?: string; format?: string; landscape?: boolean; margin?: { top?: string; bottom?: string; left?: string; right?: string } }): Promise<string>;\n  /** Set the viewport size */\n  setViewportSize(size: { width: number; height: number }): Promise<void>;\n  /** Get the viewport size */\n  viewportSize(): Promise<{ width: number; height: number } | null>;\n  /** Emulate media type or color scheme */\n  emulateMedia(options: { media?: \"screen\" | \"print\" | null; colorScheme?: \"light\" | \"dark\" | \"no-preference\" | null }): Promise<void>;\n  /** Set extra HTTP headers */\n  setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;\n  /** Bring the page to front */\n  bringToFront(): Promise<void>;\n  /** Close the page */\n  close(): Promise<void>;\n  /** Check if the page is closed */\n  isClosed(): Promise<boolean>;\n  /** Pause execution (for debugging) */\n  pause(): Promise<void>;\n  /** Get all frames */\n  frames(): Promise<FrameInfo[]>;\n  /** Get the main frame */\n  mainFrame(): Promise<FrameInfo>;\n  /** Get the browser context for this page */\n  context(): IsolateContext;\n  /** Keyboard API */\n  readonly keyboard: Keyboard;\n  /** Mouse API */\n  readonly mouse: Mouse;\n  /** Request API for making HTTP requests */\n  readonly request: APIRequestContext;\n}\n\n/**\n * IsolateContext - represents a browser context in the isolate.\n */\ndeclare class IsolateContext {\n  /** Create a new page in this context (requires createPage callback) */\n  newPage(): Promise<IsolatePage>;\n  /** Close this context and all its pages */\n  close(): Promise<void>;\n  /** Clear all cookies */\n  clearCookies(): Promise<void>;\n  /** Add cookies */\n  addCookies(cookies: Cookie[]): Promise<void>;\n  /** Get cookies */\n  cookies(urls?: string | string[]): Promise<Cookie[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ninterface IsolateBrowser {\n  /** Create a new browser context (requires createContext callback) */\n  newContext(options?: {\n    viewport?: { width: number; height: number } | null;\n    userAgent?: string;\n    locale?: string;\n    timezoneId?: string;\n    geolocation?: { latitude: number; longitude: number; accuracy?: number };\n    permissions?: string[];\n    colorScheme?: \"light\" | \"dark\" | \"no-preference\";\n  }): Promise<IsolateContext>;\n}\n\n/**\n * The default page object.\n */\ndeclare const page: IsolatePage;\n\n/**\n * The default browser context.\n */\ndeclare const context: IsolateContext;\n\n/**\n * Browser object for creating new contexts.\n */\ndeclare const browser: IsolateBrowser;\n\n// ============================================================================\n// Playwright Expect Matchers (extends test-environment expect)\n// ============================================================================\n\n/**\n * Options for locator assertion timeouts.\n */\ninterface LocatorAssertionOptions {\n  timeout?: number;\n}\n\n/**\n * Locator-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(locator).\n */\ninterface PlaywrightLocatorMatchers {\n  /** Assert element is visible */\n  toBeVisible(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is hidden */\n  toBeHidden(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is enabled */\n  toBeEnabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is disabled */\n  toBeDisabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is checked */\n  toBeChecked(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is focused */\n  toBeFocused(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is empty */\n  toBeEmpty(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is attached to DOM */\n  toBeAttached(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is editable */\n  toBeEditable(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is in viewport */\n  toBeInViewport(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains text */\n  toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has exact text */\n  toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has value (for inputs) */\n  toHaveValue(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has attribute */\n  toHaveAttribute(name: string, value?: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element count */\n  toHaveCount(count: number, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has class */\n  toHaveClass(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains class */\n  toContainClass(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has id */\n  toHaveId(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has CSS property */\n  toHaveCSS(name: string, value: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has JavaScript property */\n  toHaveJSProperty(name: string, value: unknown, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible name */\n  toHaveAccessibleName(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible description */\n  toHaveAccessibleDescription(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has ARIA role */\n  toHaveRole(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightLocatorMatchers;\n}\n\n/**\n * Page-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(page).\n */\ninterface PlaywrightPageMatchers {\n  /** Assert page has URL */\n  toHaveURL(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert page has title */\n  toHaveTitle(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightPageMatchers;\n}\n";
+    readonly playwright: "\n/**\n * Locator represents an element or group of elements in the page.\n */\ndeclare class Locator {\n  /** Click the element */\n  click(): Promise<void>;\n  /** Double-click the element */\n  dblclick(): Promise<void>;\n  /** Fill an input element with text */\n  fill(text: string): Promise<void>;\n  /** Type text into an element (key by key) */\n  type(text: string): Promise<void>;\n  /** Check a checkbox or radio */\n  check(): Promise<void>;\n  /** Uncheck a checkbox */\n  uncheck(): Promise<void>;\n  /** Select an option in a dropdown */\n  selectOption(value: string | string[]): Promise<void>;\n  /** Clear an input element */\n  clear(): Promise<void>;\n  /** Press a key */\n  press(key: string): Promise<void>;\n  /** Hover over the element */\n  hover(): Promise<void>;\n  /** Focus the element */\n  focus(): Promise<void>;\n  /** Get text content of the element */\n  textContent(): Promise<string | null>;\n  /** Get the value of an input element */\n  inputValue(): Promise<string>;\n  /** Check if the element is visible */\n  isVisible(): Promise<boolean>;\n  /** Check if the element is enabled */\n  isEnabled(): Promise<boolean>;\n  /** Check if the element is checked */\n  isChecked(): Promise<boolean>;\n  /** Check if the element is disabled */\n  isDisabled(): Promise<boolean>;\n  /** Check if the element is hidden */\n  isHidden(): Promise<boolean>;\n  /** Get the count of matching elements */\n  count(): Promise<number>;\n  /** Get an attribute value */\n  getAttribute(name: string): Promise<string | null>;\n  /** Get innerHTML */\n  innerHTML(): Promise<string>;\n  /** Get innerText */\n  innerText(): Promise<string>;\n  /** Get all text contents */\n  allTextContents(): Promise<string[]>;\n  /** Get all inner texts */\n  allInnerTexts(): Promise<string[]>;\n  /** Wait for the element to match a state */\n  waitFor(options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Get bounding box */\n  boundingBox(): Promise<{ x: number; y: number; width: number; height: number } | null>;\n  /** Set input files for a file input */\n  setInputFiles(files: string | string[] | { name: string; mimeType: string; buffer: ArrayBuffer | Uint8Array | string }[]): Promise<void>;\n  /** Take a screenshot of the element */\n  screenshot(options?: { path?: string; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<void>;\n  /** Drag to another element */\n  dragTo(target: Locator): Promise<void>;\n  /** Scroll element into view */\n  scrollIntoViewIfNeeded(): Promise<void>;\n  /** Highlight the element for debugging */\n  highlight(): Promise<void>;\n  /** Evaluate a function in the context of the element */\n  evaluate<R>(fn: (el: Element, arg?: unknown) => R, arg?: unknown): Promise<R>;\n  /** Evaluate a function for all matching elements */\n  evaluateAll<R>(fn: (els: Element[], arg?: unknown) => R, arg?: unknown): Promise<R>;\n\n  // Chaining methods\n  /** Chain with another CSS selector */\n  locator(selector: string): Locator;\n  /** Chain with getByRole */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Chain with getByText */\n  getByText(text: string | RegExp): Locator;\n  /** Chain with getByLabel */\n  getByLabel(label: string | RegExp): Locator;\n  /** Chain with getByPlaceholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Chain with getByTestId */\n  getByTestId(testId: string): Locator;\n  /** Chain with getByAltText */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Chain with getByTitle */\n  getByTitle(title: string | RegExp): Locator;\n\n  // Subset selection\n  /** Get all matching locators as an array */\n  all(): Promise<Locator[]>;\n  /** Get the nth matching element */\n  nth(index: number): Locator;\n  /** Get the first matching element */\n  first(): Locator;\n  /** Get the last matching element */\n  last(): Locator;\n\n  // Filtering\n  /** Filter locators by additional criteria */\n  filter(options: { hasText?: string | RegExp; hasNotText?: string | RegExp; has?: Locator; hasNot?: Locator }): Locator;\n  /** Create a locator matching either this or the other locator */\n  or(other: Locator): Locator;\n  /** Create a locator matching both this and the other locator */\n  and(other: Locator): Locator;\n}\n\n/**\n * FrameLocator for interacting with elements inside iframes.\n */\ninterface FrameLocator {\n  locator(selector: string): Locator;\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  getByText(text: string | RegExp): Locator;\n  getByLabel(label: string | RegExp): Locator;\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  getByTestId(testId: string): Locator;\n  getByAltText(alt: string | RegExp): Locator;\n  getByTitle(title: string | RegExp): Locator;\n}\n\n/**\n * Keyboard API for simulating keyboard input.\n */\ninterface Keyboard {\n  type(text: string, options?: { delay?: number }): Promise<void>;\n  press(key: string, options?: { delay?: number }): Promise<void>;\n  down(key: string): Promise<void>;\n  up(key: string): Promise<void>;\n  insertText(text: string): Promise<void>;\n}\n\n/**\n * Mouse API for simulating mouse input.\n */\ninterface Mouse {\n  move(x: number, y: number, options?: { steps?: number }): Promise<void>;\n  click(x: number, y: number, options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number; delay?: number }): Promise<void>;\n  down(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  up(options?: { button?: \"left\" | \"right\" | \"middle\"; clickCount?: number }): Promise<void>;\n  wheel(deltaX: number, deltaY: number): Promise<void>;\n}\n\n/**\n * API Response from page.request methods.\n */\ninterface APIResponse {\n  status(): number;\n  ok(): boolean;\n  headers(): Record<string, string>;\n  json(): Promise<unknown>;\n  text(): Promise<string>;\n  body(): Promise<ArrayBuffer>;\n}\n\n/**\n * Request API for making HTTP requests with page cookies.\n */\ninterface APIRequestContext {\n  fetch(url: string, options?: { method?: string; data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  get(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n  post(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  put(url: string, options?: { data?: unknown; headers?: Record<string, string> }): Promise<APIResponse>;\n  delete(url: string, options?: { headers?: Record<string, string> }): Promise<APIResponse>;\n}\n\n/**\n * Frame information.\n */\ninterface FrameInfo {\n  name: string;\n  url: string;\n}\n\n/**\n * Cookie data.\n */\ninterface Cookie {\n  name: string;\n  value: string;\n  domain?: string;\n  path?: string;\n  expires?: number;\n  httpOnly?: boolean;\n  secure?: boolean;\n  sameSite?: \"Strict\" | \"Lax\" | \"None\";\n}\n\n/**\n * IsolatePage - represents a browser page in the isolate.\n */\ndeclare class IsolatePage {\n  /** Navigate to a URL */\n  goto(url: string, options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Reload the page */\n  reload(): Promise<void>;\n  /** Get the current URL */\n  url(): Promise<string>;\n  /** Get the page title */\n  title(): Promise<string>;\n  /** Get the page HTML content */\n  content(): Promise<string>;\n  /** Wait for a selector to appear */\n  waitForSelector(selector: string, options?: { state?: \"attached\" | \"detached\" | \"visible\" | \"hidden\"; timeout?: number }): Promise<void>;\n  /** Wait for a specified time */\n  waitForTimeout(ms: number): Promise<void>;\n  /** Wait for a load state */\n  waitForLoadState(state?: \"load\" | \"domcontentloaded\" | \"networkidle\"): Promise<void>;\n  /** Wait for the URL to match */\n  waitForURL(url: string | RegExp, options?: { timeout?: number; waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Evaluate JavaScript in the browser context */\n  evaluate<R>(script: string | (() => R) | ((arg: unknown) => R), arg?: unknown): Promise<R>;\n  /** Create a locator by CSS selector */\n  locator(selector: string): Locator;\n  /** Create a locator by ARIA role */\n  getByRole(role: string, options?: { name?: string | RegExp; exact?: boolean }): Locator;\n  /** Create a locator by text content */\n  getByText(text: string | RegExp): Locator;\n  /** Create a locator by label */\n  getByLabel(label: string | RegExp): Locator;\n  /** Create a locator by placeholder */\n  getByPlaceholder(placeholder: string | RegExp): Locator;\n  /** Create a locator by test ID */\n  getByTestId(testId: string): Locator;\n  /** Create a locator by alt text */\n  getByAltText(alt: string | RegExp): Locator;\n  /** Create a locator by title */\n  getByTitle(title: string | RegExp): Locator;\n  /** Create a frame locator */\n  frameLocator(selector: string): FrameLocator;\n  /** Navigate back */\n  goBack(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Navigate forward */\n  goForward(options?: { waitUntil?: \"load\" | \"domcontentloaded\" | \"networkidle\" }): Promise<void>;\n  /** Click an element (shorthand) */\n  click(selector: string): Promise<void>;\n  /** Fill an input (shorthand) */\n  fill(selector: string, value: string): Promise<void>;\n  /** Take a screenshot */\n  screenshot(options?: { path?: string; fullPage?: boolean; type?: \"png\" | \"jpeg\"; quality?: number }): Promise<void>;\n  /** Generate a PDF (Chromium only) */\n  pdf(options?: { path?: string; format?: string; landscape?: boolean; margin?: { top?: string; bottom?: string; left?: string; right?: string } }): Promise<string>;\n  /** Set the viewport size */\n  setViewportSize(size: { width: number; height: number }): Promise<void>;\n  /** Get the viewport size */\n  viewportSize(): Promise<{ width: number; height: number } | null>;\n  /** Emulate media type or color scheme */\n  emulateMedia(options: { media?: \"screen\" | \"print\" | null; colorScheme?: \"light\" | \"dark\" | \"no-preference\" | null }): Promise<void>;\n  /** Set extra HTTP headers */\n  setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;\n  /** Bring the page to front */\n  bringToFront(): Promise<void>;\n  /** Close the page */\n  close(): Promise<void>;\n  /** Check if the page is closed */\n  isClosed(): Promise<boolean>;\n  /** Pause execution (for debugging) */\n  pause(): Promise<void>;\n  /** Get all frames */\n  frames(): Promise<FrameInfo[]>;\n  /** Get the main frame */\n  mainFrame(): Promise<FrameInfo>;\n  /** Get the browser context for this page */\n  context(): IsolateContext;\n  /** Keyboard API */\n  readonly keyboard: Keyboard;\n  /** Mouse API */\n  readonly mouse: Mouse;\n  /** Request API for making HTTP requests */\n  readonly request: APIRequestContext;\n}\n\n/**\n * IsolateContext - represents a browser context in the isolate.\n */\ndeclare class IsolateContext {\n  /** Create a new page in this context (requires createPage callback) */\n  newPage(): Promise<IsolatePage>;\n  /** Get tracked pages for this context */\n  pages(): Promise<IsolatePage[]>;\n  /** Close this context and all its pages */\n  close(): Promise<void>;\n  /** Clear all cookies */\n  clearCookies(): Promise<void>;\n  /** Add cookies */\n  addCookies(cookies: Cookie[]): Promise<void>;\n  /** Get cookies */\n  cookies(urls?: string | string[]): Promise<Cookie[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ninterface IsolateBrowser {\n  /** Create a new browser context (requires createContext callback) */\n  newContext(options?: {\n    viewport?: { width: number; height: number } | null;\n    userAgent?: string;\n    locale?: string;\n    timezoneId?: string;\n    geolocation?: { latitude: number; longitude: number; accuracy?: number };\n    permissions?: string[];\n    colorScheme?: \"light\" | \"dark\" | \"no-preference\";\n  }): Promise<IsolateContext>;\n  /** Get tracked browser contexts */\n  contexts(): Promise<IsolateContext[]>;\n}\n\n/**\n * Browser object for creating new contexts.\n */\ndeclare const browser: IsolateBrowser;\n\n// ============================================================================\n// Playwright Expect Matchers (extends test-environment expect)\n// ============================================================================\n\n/**\n * Options for locator assertion timeouts.\n */\ninterface LocatorAssertionOptions {\n  timeout?: number;\n}\n\n/**\n * Locator-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(locator).\n */\ninterface PlaywrightLocatorMatchers {\n  /** Assert element is visible */\n  toBeVisible(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is hidden */\n  toBeHidden(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is enabled */\n  toBeEnabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is disabled */\n  toBeDisabled(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is checked */\n  toBeChecked(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is focused */\n  toBeFocused(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is empty */\n  toBeEmpty(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is attached to DOM */\n  toBeAttached(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is editable */\n  toBeEditable(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element is in viewport */\n  toBeInViewport(options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains text */\n  toContainText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has exact text */\n  toHaveText(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has value (for inputs) */\n  toHaveValue(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has attribute */\n  toHaveAttribute(name: string, value?: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element count */\n  toHaveCount(count: number, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has class */\n  toHaveClass(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element contains class */\n  toContainClass(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has id */\n  toHaveId(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has CSS property */\n  toHaveCSS(name: string, value: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has JavaScript property */\n  toHaveJSProperty(name: string, value: unknown, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible name */\n  toHaveAccessibleName(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has accessible description */\n  toHaveAccessibleDescription(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert element has ARIA role */\n  toHaveRole(expected: string, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightLocatorMatchers;\n}\n\n/**\n * Page-specific assertion matchers (added to expect when using Playwright).\n * These are available when calling expect(page).\n */\ninterface PlaywrightPageMatchers {\n  /** Assert page has URL */\n  toHaveURL(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Assert page has title */\n  toHaveTitle(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;\n  /** Negated matchers */\n  not: PlaywrightPageMatchers;\n}\n";
 };
 /**
  * Type for the keys of TYPE_DEFINITIONS.

package/dist/types/internal/typecheck/typecheck.d.ts

@@ -77,7 +77,7 @@ export interface TypecheckOptions {
      * Which isolate global types to include.
      * @default ["core", "fetch", "fs"]
      */
-    include?: Array<"core" | "fetch" | "fs" | "console" | "encoding" | "timers" | "testEnvironment" | "playwright">;
+    include?: Array<"core" | "sandboxIsolate" | "fetch" | "fs" | "console" | "encoding" | "timers" | "testEnvironment" | "playwright">;
     /**
      * Library type definitions to inject for import resolution.
      * These are added to the virtual node_modules/ for module resolution.

package/dist/types/runtime/script-runtime.d.ts

@@ -1,6 +1,7 @@
-import type { MutableRuntimeDiagnostics } from "../bridge/diagnostics.ts";
+import { type MutableRuntimeDiagnostics } from "../bridge/diagnostics.ts";
 import { type RemoteRuntime } from "../internal/client/index.ts";
 import type { ScriptRuntime } from "../types.ts";
 export declare function createScriptRuntimeAdapter(runtime: RemoteRuntime, diagnostics: MutableRuntimeDiagnostics, options?: {
+    hasBrowser?: boolean;
     onBeforeDispose?: (reason?: string) => void;
 }): ScriptRuntime;

package/dist/types/runtime/test-runtime.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeBindingsAdapterOptions } from "../bridge/runtime-bindings.ts";
+import type { RemoteRuntime, RuntimeOptions } from "../internal/client/index.ts";
+import type { CreateTestRuntimeOptions, TestRuntime } from "../types.ts";
+export declare function createTestRuntimeAdapter(createRuntime: (options: RuntimeOptions) => Promise<RemoteRuntime>, options: CreateTestRuntimeOptions, adapterOptions?: RuntimeBindingsAdapterOptions): Promise<TestRuntime>;

package/dist/types/server/app-server.d.ts

@@ -1,3 +1,4 @@
 import type { DaemonConnection } from "../internal/client/index.ts";
+import { type RuntimeBindingsAdapterOptions } from "../bridge/runtime-bindings.ts";
 import type { AppServer, CreateAppServerOptions } from "../types.ts";
-export declare function createAppServerAdapter(getConnection: () => Promise<DaemonConnection>, options: CreateAppServerOptions): Promise<AppServer>;
+export declare function createAppServerAdapter(getConnection: () => Promise<DaemonConnection>, options: CreateAppServerOptions, adapterOptions?: RuntimeBindingsAdapterOptions): Promise<AppServer>;