import { createRuntime } from "@ricsam/isolate-runtime";
import { defaultModuleLoader } from "@ricsam/isolate-module-loader";

const loader = defaultModuleLoader(
  // Map your source directory into the isolate
  { from: "/path/to/project/src/**/*", to: "/app" },
  // Enable npm package imports (bundled automatically via Rollup)
  { from: "/path/to/project/node_modules", to: "/node_modules" },
  // Module alias: bundle a host file and import it as a bare specifier
  { from: "/path/to/project/lib/entry.ts", to: "@/my-lib" },
);

const runtime = await createRuntime({
  moduleLoader: loader,
  console: {
    onEntry: (entry) => {
      if (entry.type === "output") console.log(entry.stdout);
    },
  },
  fetch: async (url, init) => fetch(url, init),
});

// Import your source files, npm packages, and module aliases directly
await runtime.eval(
  `
  import { handler } from "./handler";  // reads from /path/to/project/src/handler.ts
  import ms from "ms";                  // bundled from node_modules
  import { util } from "@/my-lib";      // bundled from /path/to/project/lib/entry.ts

  console.log("Timeout:", ms("1 day"));
  `,
  "/app/entry.ts",
);

await runtime.dispose();

import { createRuntime } from "@ricsam/isolate-runtime";

const runtime = await createRuntime({
  memoryLimitMB: 128,
  console: {
    onEntry: (entry) => {
      if (entry.type === "output") {
        console.log(`[sandbox:${entry.level}]`, entry.stdout);
      }
    },
  },
  fetch: async (url, init) => fetch(url, init),
});

// Run code as ES module (supports top-level await)
await runtime.eval(`
  const response = await fetch("https://api.example.com/data");
  const data = await response.json();
  console.log("Got data:", data);
`);

// Set up HTTP server handler
await runtime.eval(`
  serve({
    fetch(request) {
      const url = new URL(request.url);
      return Response.json({ path: url.pathname });
    }
  });
`);

// Dispatch requests to the handler
const response = await runtime.fetch.dispatchRequest(
  new Request("http://localhost/api/users")
);
console.log(await response.json()); // { path: "/api/users" }

// Timers fire automatically with real time
// Clear all pending timers if needed
runtime.timers.clearAll();

// Cleanup
await runtime.dispose();

const runtime = await createRuntime({
  moduleLoader: async (moduleName, importer) => {
    // importer.path = resolved path of importing module
    // importer.resolveDir = directory for relative resolution
    if (moduleName === "@/db") {
      return {
        code: `
          export async function getUser(id) {
            const response = await fetch("/api/users/" + id);
            return response.json();
          }
        `,
        resolveDir: "/modules",
      };
    }
    if (moduleName === "@/config") {
      return {
        code: `export const API_KEY = "https://api.example.com";`,
        resolveDir: "/modules",
      };
    }
    throw new Error(`Unknown module: ${moduleName}`);
  },
  console: {
    onEntry: (entry) => {
      if (entry.type === "output") console.log(entry.stdout);
    },
  },
  fetch: async (url, init) => fetch(url, init),
});

await runtime.eval(`
  import { getUser } from "@/db";
  import { API_KEY } from "@/config";

  const user = await getUser("123");
  console.log("User:", user, "from", API_KEY);
`);

import bcrypt from "bcrypt";
import z from 'zod';

const runtime = await createRuntime({
  customFunctions: {
    // Async function
    hashPassword: {
      fn: async (password: unknown) => {
        return bcrypt.hash(z.string().parse(password), 10);
      },
      type: 'async',
    },
    // Sync function
    getConfig: {
      fn: () => ({ environment: "production" }),
      type: 'sync',
    },
    // Async iterator (generator)
    streamData: {
      fn: async function* (count: number) {
        for (let i = 0; i < count; i++) {
          yield { chunk: i, timestamp: Date.now() };
        }
      },
      type: 'asyncIterator',
    },
  },
});

await runtime.eval(`
  const hash = await hashPassword("secret123");
  const config = getConfig();
  console.log(hash, config.environment);

  // Consume async iterator
  for await (const data of streamData(5)) {
    console.log(data.chunk);  // 0, 1, 2, 3, 4
  }
`);

const runtime = await createRuntime({
  customFunctions: {
    // Return a function - callable from isolate
    getMultiplier: {
      fn: (factor: number) => (x: number) => x * factor,
      type: 'sync',
    },
    // Return nested promises - awaitable from isolate
    fetchBoth: {
      fn: () => ({
        users: fetch('/api/users').then(r => r.json()),
        posts: fetch('/api/posts').then(r => r.json()),
      }),
      type: 'sync',
    },
    // Return nested async iterators
    getStreams: {
      fn: () => ({
        numbers: (async function* () { yield 1; yield 2; })(),
        letters: (async function* () { yield 'a'; yield 'b'; })(),
      }),
      type: 'sync',
    },
  },
});

await runtime.eval(`
  const double = getMultiplier(2);
  console.log(double(5)); // 10

  const { users, posts } = fetchBoth();
  console.log(await users, await posts);

  const streams = getStreams();
  for await (const n of streams.numbers) console.log(n);
`);

// Works in Bun, Deno, or Node.js
import { connect } from "@ricsam/isolate-client";

const client = await connect({ socket: "/tmp/isolate.sock" });

const runtime = await client.createRuntime({
  memoryLimitMB: 128,
  console: {
    onEntry: (entry) => {
      if (entry.type === "output") {
        console.log("[isolate]", entry.stdout);
      }
    },
  },
  fetch: async (url, init) => fetch(url, init),
  fs: {
    readFile: async (path) => Bun.file(path).arrayBuffer(),
    writeFile: async (path, data) => Bun.write(path, data),
  },
});

// Same unified API as local runtime
await runtime.eval(`
  console.log("Hello from isolate!");
  const response = await fetch("https://api.example.com");
  console.log(await response.json());
`);

// HTTP server
await runtime.eval(`
  serve({
    fetch(request) {
      return Response.json({ message: "Hello!" });
    }
  });
`);

const response = await runtime.fetch.dispatchRequest(
  new Request("http://localhost/api")
);

// Timers fire automatically with real time
await runtime.timers.clearAll();

await runtime.dispose();
await client.close();

const runtime = await client.createRuntime({
  moduleLoader: async (moduleName, importer) => {
    if (moduleName === "@/auth") {
      return {
        code: `
          export async function login(email, password) {
            const hash = await hashPassword(password);
            return { email, hash };
          }
        `,
        resolveDir: importer.resolveDir,
      };
    }
    throw new Error(`Unknown module: ${moduleName}`);
  },
  customFunctions: {
    hashPassword: {
      fn: async (pw) => Bun.password.hash(pw),
      type: 'async',
    },
    queryDatabase: {
      fn: async (sql) => db.query(sql),
      type: 'async',
    },
  },
});

await runtime.eval(`
  import { login } from "@/auth";
  const result = await login("[email protected]", "password");
  console.log(result);
`);

const client = await connect({ socket: "/tmp/isolate.sock" });

// Create a namespace for a tenant/user/session
const namespace = client.createNamespace("tenant-123");

// Create a runtime in this namespace
const runtime = await namespace.createRuntime({
  memoryLimitMB: 128,
  moduleLoader: async (name, importer) => {
    const code = loadModule(name);
    return { code, resolveDir: importer.resolveDir };
  },
});

console.log(runtime.reused); // false - first time

// Import heavy modules (gets compiled and cached)
await runtime.eval(`
  import { heavyLibrary } from "@/heavy-module";
  console.log("Module loaded!");
`);

// Dispose returns runtime to pool (soft-delete)
await runtime.dispose();

// Later: reuse the same namespace (same or different connection!)
const client2 = await connect({ socket: "/tmp/isolate.sock" });
const namespace2 = client2.createNamespace("tenant-123");
const runtime2 = await namespace2.createRuntime({ /* same options */ });

console.log(runtime2.reused); // true - reused from pool!
// Module cache preserved - no recompilation needed
await runtime2.eval(`
  import { heavyLibrary } from "@/heavy-module";  // instant!
`);

import { connect } from "@ricsam/isolate-client";
import { IsolateServer } from "@ricsam/isolate-server";

const connection = await connect({ socket: "/tmp/isolate.sock" });

const server = new IsolateServer({
  namespaceId: "project-123/main",
  getConnection: async () => connection,
});

await server.start({
  entry: "server.js", // resolved by runtimeOptions.moduleLoader
  runtimeOptions: {
    moduleLoader: async (specifier) => {
      if (specifier === "server.js") {
        return {
          code: `serve({ fetch: () => new Response("ok") });`,
          resolveDir: "/backend",
        };
      }
      throw new Error(`Unknown module: ${specifier}`);
    },
  },
  onWebSocketCommand: (cmd) => {
    // Forward isolate websocket commands to your host connection registry.
    console.log(cmd.type, cmd.connectionId);
  },
});

const response = await server.fetch.dispatchRequest(new Request("http://localhost/"));
console.log(await response.text()); // "ok"

await server.reload(); // restarts with last start options
await server.close();  // idempotent
await connection.close();

interface Runtime {
  readonly id: string;

  /** True if runtime was reused from namespace pool (remote only) */
  readonly reused?: boolean;

  // Execute code as ES module (supports top-level await)
  eval(code: string, filename?: string): Promise<void>;

  // Release all resources (soft-delete if namespaced, hard delete otherwise)
  dispose(): Promise<void>;

  // Module handles
  readonly fetch: FetchHandle;
  readonly timers: TimersHandle;
  readonly console: ConsoleHandle;
  readonly testEnvironment: TestEnvironmentHandle;
  readonly playwright: PlaywrightHandle;
}

interface FetchHandle {
  /** Dispatch HTTP request to serve() handler */
  dispatchRequest(request: Request, options?: { signal?: AbortSignal }): Promise<Response>;
  /** Check if serve() has been called */
  hasServeHandler(): boolean;
  /** Check if there are active WebSocket connections */
  hasActiveConnections(): boolean;

  // WebSocket methods
  /** Check if isolate requested WebSocket upgrade */
  getUpgradeRequest(): UpgradeRequest | null;
  /** Dispatch WebSocket open event to isolate */
  dispatchWebSocketOpen(connectionId: string): void;
  /** Dispatch WebSocket message event to isolate */
  dispatchWebSocketMessage(connectionId: string, message: string | ArrayBuffer): void;
  /** Dispatch WebSocket close event to isolate */
  dispatchWebSocketClose(connectionId: string, code: number, reason: string): void;
  /** Dispatch WebSocket error event to isolate */
  dispatchWebSocketError(connectionId: string, error: Error): void;
  /** Register callback for WebSocket commands from isolate */
  onWebSocketCommand(callback: (cmd: WebSocketCommand) => void): () => void;
}

interface TimersHandle {
  clearAll(): void;
}

interface ConsoleHandle {
  reset(): void;
  getTimers(): Map<string, number>;
  getCounters(): Map<string, number>;
  getGroupDepth(): number;
}

interface TestEnvironmentHandle {
  /** Run all registered tests */
  runTests(timeout?: number): Promise<RunResults>;
  /** Check if any tests have been registered */
  hasTests(): boolean;
  /** Get the number of registered tests */
  getTestCount(): number;
  /** Reset test environment state */
  reset(): void;
}

interface PlaywrightHandle {
  /** Get collected browser console logs and network data */
  getCollectedData(): CollectedData;
  /** Clear collected data */
  clearCollectedData(): void;
}

interface CollectedData {
  /** Browser console logs (from the page, not sandbox) */
  browserConsoleLogs: Array<{ level: string; stdout: string; timestamp: number }>;
  networkRequests: Array<{ url: string; method: string; headers: Record<string, string>; timestamp: number }>;
  networkResponses: Array<{ url: string; status: number; headers: Record<string, string>; timestamp: number }>;
}

interface RuntimeOptions {
  /** Memory limit in megabytes for the V8 isolate heap */
  memoryLimitMB?: number;

  /** Console callback handlers - receive console.* calls from the isolate */
  console?: ConsoleCallbacks;

  /** Fetch callback - handles all fetch() calls from the isolate */
  fetch?: FetchCallback;

  /** WebSocket callback - controls outbound WebSocket connections */
  webSocket?: WebSocketCallback;

  /** File system callbacks - handles OPFS-style file operations */
  fs?: FileSystemCallbacks;

  /** Module loader - resolves dynamic imports to source code */
  moduleLoader?: ModuleLoaderCallback;

  /** Custom functions - expose host functions to the isolate */
  customFunctions?: CustomFunctions;

  /** Current working directory for path.resolve(). Defaults to "/" */
  cwd?: string;

  /** Enable test environment (describe, it, expect, etc.) */
  testEnvironment?: boolean | TestEnvironmentOptions;

  /** Playwright options - handler-first public API */
  playwright?: PlaywrightOptions;
}

interface PlaywrightOptions {
  /** Playwright operation handler (required when playwright is enabled) */
  handler: (op: PlaywrightOperation) => Promise<PlaywrightResult>;
  /** Default timeout for operations in ms */
  timeout?: number;
  /** Route browser console logs through console handler (or print to stdout if no handler) */
  console?: boolean;
  /** Unified event callback for all playwright events */
  onEvent?: (event: PlaywrightEvent) => void;
}

type PlaywrightEvent =
  | { type: "browserConsoleLog"; level: string; stdout: string; timestamp: number }
  | { type: "networkRequest"; url: string; method: string; headers: Record<string, string>; postData?: string; resourceType?: string; timestamp: number }
  | { type: "networkResponse"; url: string; status: number; statusText?: string; headers: Record<string, string>; timestamp: number };

interface ConsoleCallbacks {
  onEntry?: (entry: ConsoleEntry) => void;
}

type ConsoleEntry =
  | { type: "output"; level: "log" | "warn" | "error" | "info" | "debug"; stdout: string; groupDepth: number }
  | { type: "browserOutput"; level: string; stdout: string; timestamp: number } // Browser console (from Playwright page)
  | { type: "dir"; stdout: string; groupDepth: number }
  | { type: "table"; stdout: string; groupDepth: number }
  | { type: "time"; label: string; duration: number; groupDepth: number }
  | { type: "timeLog"; label: string; duration: number; stdout: string; groupDepth: number }
  | { type: "count"; label: string; count: number; groupDepth: number }
  | { type: "countReset"; label: string; groupDepth: number }
  | { type: "assert"; stdout: string; groupDepth: number }
  | { type: "group"; label: string; collapsed: boolean; groupDepth: number }
  | { type: "groupEnd"; groupDepth: number }
  | { type: "clear" }
  | { type: "trace"; stdout: string; stack: string; groupDepth: number };

import { simpleConsoleHandler } from "@ricsam/isolate-runtime";

const runtime = await createRuntime({
  console: simpleConsoleHandler({
    log: (msg) => console.log("[sandbox]", msg),
    error: (msg) => console.error("[sandbox]", msg),
  }),
});

interface FetchRequestInit {
  method: string;
  headers: [string, string][];
  /** Raw body bytes - use this if you need direct access to the body data */
  rawBody: Uint8Array | null;
  /** Body ready for use with fetch() - same data as rawBody but typed as BodyInit */
  body: BodyInit | null;
  signal: AbortSignal;
}

type FetchCallback = (url: string, init: FetchRequestInit) => Response | Promise<Response>;

type WebSocketCallback = (
  url: string,
  protocols: string[]
) => WebSocket | Promise<WebSocket | null> | null;

const runtime = await createRuntime({
  webSocket: async (url, protocols) => {
    // Block certain hosts
    if (url.includes("blocked.com")) {
      return null;
    }
    // Proxy to different server
    if (url.includes("internal")) {
      return new WebSocket("wss://proxy.example.com" + new URL(url).pathname);
    }
    // Allow normally
    return new WebSocket(url, protocols.length > 0 ? protocols : undefined);
  },
});

interface FileSystemCallbacks {
  readFile?: (path: string) => Promise<ArrayBuffer>;
  writeFile?: (path: string, data: ArrayBuffer) => Promise<void>;
  unlink?: (path: string) => Promise<void>;
  readdir?: (path: string) => Promise<string[]>;
  mkdir?: (path: string, options?: { recursive?: boolean }) => Promise<void>;
  rmdir?: (path: string) => Promise<void>;
  stat?: (path: string) => Promise<{ isFile: boolean; isDirectory: boolean; size: number }>;
  rename?: (from: string, to: string) => Promise<void>;
}

type ModuleLoaderCallback = (
  moduleName: string,
  importer: { path: string; resolveDir: string }
) => { code: string; resolveDir: string } | Promise<{ code: string; resolveDir: string }>;

type CustomFunctions = Record<string, CustomFunctionDefinition>;

type CustomFunction = (...args: unknown[]) => unknown | Promise<unknown>;
type CustomAsyncGeneratorFunction = (...args: unknown[]) => AsyncGenerator<unknown, unknown, unknown>;
type CustomFunctionType = 'sync' | 'async' | 'asyncIterator';

interface CustomFunctionDefinition {
  /** The function implementation */
  fn: CustomFunction | CustomAsyncGeneratorFunction;
  /** The function type (required) */
  type: CustomFunctionType;
}

const runtime = await createRuntime({
  customFunctions: {
    // Async function (returns Promise)
    hashPassword: {
      fn: async (password) => bcrypt.hash(password, 10),
      type: 'async',
    },
    // Sync function (returns value directly)
    getConfig: {
      fn: () => ({ env: "production" }),
      type: 'sync',
    },
    // Async iterator (yields values)
    streamData: {
      fn: async function* (count: number) {
        for (let i = 0; i < count; i++) yield i;
      },
      type: 'asyncIterator',
    },
  },
});

await runtime.eval(`
  interface User {
    id: number;
    name: string;
  }

  const user: User = { id: 1, name: "Alice" };
  console.log(user.name);
`);

const runtime = await createRuntime({
  moduleLoader: async (moduleName, importer) => {
    if (moduleName === "@/types") {
      return {
        code: `
          export interface Config {
            apiUrl: string;
            timeout: number;
          }

          export function createConfig(url: string): Config {
            return { apiUrl: url, timeout: 5000 };
          }
        `,
        resolveDir: "/modules",
      };
    }
    throw new Error(`Unknown module: ${moduleName}`);
  },
});

await runtime.eval(`
  import { createConfig, type Config } from "@/types";

  const config: Config = createConfig("https://api.example.com");
  console.log(config.apiUrl);
`);

await runtime.eval(`
  interface Data {
    value: number;
  }

  function process(data: Data): void {
    throw new Error("Something went wrong");
  }

  process({ value: 42 });
`);
// Error stack will reference correct line numbers in your TypeScript code

import { typecheckIsolateCode } from "@ricsam/isolate-types";

const code = `
  const x: string = 123; // Type error!
`;

// Check types first
const result = typecheckIsolateCode(code);
if (!result.success) {
  console.error("Type errors:", result.errors);
} else {
  // Safe to run
  await runtime.eval(code);
}

import { typecheckIsolateCode, formatTypecheckErrors } from "@ricsam/isolate-types";

const userCode = `
  serve({
    fetch(request, server) {
      return new Response("Hello!");
    }
  });
`;

const result = typecheckIsolateCode(userCode, {
  include: ["core", "fetch"],
});

if (!result.success) {
  console.error(formatTypecheckErrors(result));
  // usercode.ts:3:12 (TS2345): Argument of type '...' is not assignable...
}

interface TypecheckOptions {
  /**
   * Which isolate global types to include.
   * @default ["core", "fetch", "fs"]
   */
  include?: Array<
    | "core"        // ReadableStream, Blob, File, URL, etc.
    | "fetch"       // fetch(), Request, Response, Headers, serve()
    | "fs"          // getDirectory(), FileSystemDirectoryHandle, etc.
    | "console"     // console.log, console.error, etc.
    | "encoding"    // atob(), btoa()
    | "timers"      // setTimeout, setInterval, etc.
    | "testEnvironment" // describe(), it(), expect()
    | "playwright"      // page, context, browser, Locator matchers
  >;

  /**
   * Library type definitions to inject for import resolution.
   * Allows typechecking code that imports external modules.
   */
  libraryTypes?: Record<string, LibraryTypes>;

  /**
   * Additional TypeScript compiler options.
   */
  compilerOptions?: Partial<ts.CompilerOptions>;
}

interface TypecheckResult {
  /** Whether the code passed type checking */
  success: boolean;
  /** Array of type errors found */
  errors: TypecheckError[];
}

interface TypecheckError {
  /** The error message from TypeScript */
  message: string;
  /** Line number (1-indexed) */
  line?: number;
  /** Column number (1-indexed) */
  column?: number;
  /** TypeScript error code */
  code?: number;
}

import { TYPE_DEFINITIONS } from "@ricsam/isolate-types";

// Available type definition keys:
// - TYPE_DEFINITIONS.core
// - TYPE_DEFINITIONS.console
// - TYPE_DEFINITIONS.crypto
// - TYPE_DEFINITIONS.encoding
// - TYPE_DEFINITIONS.fetch
// - TYPE_DEFINITIONS.fs
// - TYPE_DEFINITIONS.path
// - TYPE_DEFINITIONS.testEnvironment
// - TYPE_DEFINITIONS.playwright
// - TYPE_DEFINITIONS.timers

// Use with ts-morph
import { Project } from "ts-morph";

const project = new Project({ useInMemoryFileSystem: true });
project.createSourceFile("isolate-fetch.d.ts", TYPE_DEFINITIONS.fetch);
project.createSourceFile("isolate-core.d.ts", TYPE_DEFINITIONS.core);
project.createSourceFile("usercode.ts", userCode);

const diagnostics = project.getPreEmitDiagnostics();

const runtime = await createRuntime({
  testEnvironment: {
    onEvent: (event) => {
      // Receive lifecycle events during test execution
      if (event.type === "testEnd") {
        const icon = event.test.status === "pass" ? "✓" : "✗";
        console.log(`${icon} ${event.test.fullName}`);
      }
    },
  },
});

await runtime.eval(`
  describe("math", () => {
    it("adds numbers", () => {
      expect(1 + 1).toBe(2);
    });

    it("handles async", async () => {
      const result = await Promise.resolve(42);
      expect(result).toBe(42);
    });

    it.todo("subtract numbers");
  });
`);

// Check if tests exist before running
if (runtime.testEnvironment.hasTests()) {
  console.log(`Found ${runtime.testEnvironment.getTestCount()} tests`);
}

const results = await runtime.testEnvironment.runTests();
console.log(`${results.passed}/${results.total} passed, ${results.todo} todo`);

// Reset test environment for new tests
runtime.testEnvironment.reset();

interface TestEnvironmentOptions {
  onEvent?: (event: TestEvent) => void;
  testTimeout?: number;
}

type TestEvent =
  | { type: "runStart"; testCount: number; suiteCount: number }
  | { type: "suiteStart"; suite: SuiteInfo }
  | { type: "suiteEnd"; suite: SuiteResult }
  | { type: "testStart"; test: TestInfo }
  | { type: "testEnd"; test: TestResult }
  | { type: "runEnd"; results: RunResults };

interface RunResults {
  passed: number;
  failed: number;
  skipped: number;
  todo: number;
  total: number;
  duration: number;
  success: boolean;
  suites: SuiteResult[];
  tests: TestResult[];
}

import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";

playwright: { handler: defaultPlaywrightHandler(page) }

import { chromium } from "playwright";
import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";

const browser = await chromium.launch({ headless: true });
const page = await browser.newPage();

const runtime = await createRuntime({
  playwright: {
    handler: defaultPlaywrightHandler(page),
    onEvent: (event) => {
      // Unified event handler for all playwright events
      switch (event.type) {
        case "browserConsoleLog":
          console.log(`[browser:${event.level}]`, event.stdout);
          break;
        case "networkRequest":
          console.log(`[request] ${event.method} ${event.url}`);
          break;
        case "networkResponse":
          console.log(`[response] ${event.status} ${event.url}`);
          break;
      }
    },
  },
});

// Run automation script - no test framework needed
await runtime.eval(`
  await page.goto("/");
  const title = await page.title();
  console.log("Page title:", title);
`);

// Get collected network data
const data = runtime.playwright.getCollectedData();
console.log("Network requests:", data.networkRequests);

await runtime.dispose();
await browser.close();

import { chromium } from "playwright";
import { defaultPlaywrightHandler } from "@ricsam/isolate-playwright/client";

const browser = await chromium.launch({ headless: true });
const page = await browser.newPage();

const runtime = await createRuntime({
  // Unified console handler for both sandbox and browser logs
  console: {
    onEntry: (entry) => {
      if (entry.type === "output") {
        console.log(`[sandbox:${entry.level}]`, entry.stdout);
      } else if (entry.type === "browserOutput") {
        console.log(`[browser:${entry.level}]`, entry.stdout);
      }
    },
  },
  testEnvironment: true, // Provides describe, it, expect
  playwright: {
    handler: defaultPlaywrightHandler(page),
    console: true, // Routes browser logs through the console handler above
  },
});

await runtime.eval(`
  describe("homepage", () => {
    it("loads correctly", async () => {
      await page.goto("/");
      await expect(page.getByText("Example Domain")).toBeVisible(); // Locator matcher
      expect(await page.title()).toBe("Example Domain"); // Primitive matcher
    });
  });
`);

// Run tests via test-environment
const results = await runtime.testEnvironment.runTests();
console.log(`${results.passed}/${results.total} passed`);

// Get collected browser data
const data = runtime.playwright.getCollectedData();
console.log("Browser logs:", data.browserConsoleLogs);
console.log("Network requests:", data.networkRequests);

// Cleanup
await runtime.dispose();
await browser.close();