@vulcn/engine 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,5 +1,86 @@
-import { Page, Browser } from 'playwright';
 import { z } from 'zod';
+import { Page, Dialog, ConsoleMessage, Request, Response, Browser } from 'playwright';
+
+/**
+ * Payload Types for Vulcn
+ * Core types used by the engine and plugins
+ */
+/**
+ * Valid payload categories
+ */
+type PayloadCategory = "xss" | "sqli" | "ssrf" | "xxe" | "command-injection" | "path-traversal" | "open-redirect" | "reflection" | "custom";
+/**
+ * Payload source types
+ */
+type PayloadSource = "builtin" | "custom" | "payloadbox" | "plugin";
+/**
+ * Runtime payload structure - used by plugins and the runner
+ */
+interface RuntimePayload {
+    /** Unique payload name */
+    name: string;
+    /** Vulnerability category */
+    category: PayloadCategory;
+    /** Human-readable description */
+    description: string;
+    /** Array of payload strings to inject */
+    payloads: string[];
+    /** Patterns to detect vulnerability (as RegExp) */
+    detectPatterns: RegExp[];
+    /** Where this payload came from */
+    source: PayloadSource;
+}
+/**
+ * Custom payload schema for YAML/JSON files (used by loader plugins)
+ */
+interface CustomPayload {
+    name: string;
+    category: PayloadCategory;
+    description?: string;
+    payloads: string[];
+    detectPatterns?: string[];
+}
+/**
+ * Custom payload file schema
+ */
+interface CustomPayloadFile {
+    version?: string;
+    payloads: CustomPayload[];
+}
+
+type BrowserType = "chromium" | "firefox" | "webkit";
+interface RecorderOptions {
+    browser?: BrowserType;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    headless?: boolean;
+}
+interface RunnerOptions {
+    browser?: BrowserType;
+    headless?: boolean;
+    onFinding?: (finding: Finding) => void;
+}
+interface Finding {
+    type: PayloadCategory;
+    severity: "critical" | "high" | "medium" | "low" | "info";
+    title: string;
+    description: string;
+    stepId: string;
+    payload: string;
+    url: string;
+    evidence?: string;
+    /** Plugin-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+interface RunResult$1 {
+    findings: Finding[];
+    stepsExecuted: number;
+    payloadsTested: number;
+    duration: number;
+    errors: string[];
+}
 
 declare const StepSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     id: z.ZodString;
@@ -137,7 +218,7 @@ declare const StepSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     timestamp: number;
     duration: number;
 }>]>;
-type Step = z.infer<typeof StepSchema>;
+type Step$1 = z.infer<typeof StepSchema>;
 declare const SessionSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodString>;
     name: z.ZodString;
@@ -395,7 +476,7 @@ declare const SessionSchema: z.ZodObject<{
     version?: string | undefined;
     browser?: "chromium" | "firefox" | "webkit" | undefined;
 }>;
-type Session = z.infer<typeof SessionSchema>;
+type Session$1 = z.infer<typeof SessionSchema>;
 /**
  * Create a new session object
  */
@@ -407,108 +488,630 @@ declare function createSession(options: {
         width: number;
         height: number;
     };
-}): Session;
+}): Session$1;
 /**
  * Parse a session from YAML string
  */
-declare function parseSession(yaml: string): Session;
+declare function parseSession(yaml: string): Session$1;
 /**
  * Serialize a session to YAML string
  */
-declare function serializeSession(session: Session): string;
+declare function serializeSession(session: Session$1): string;
 
-type BrowserType = "chromium" | "firefox" | "webkit";
-interface RecorderOptions {
-    browser?: BrowserType;
-    viewport?: {
-        width: number;
-        height: number;
+/**
+ * Vulcn Plugin System Types
+ * @module @vulcn/engine/plugin
+ */
+
+/**
+ * Plugin API version - plugins declare compatibility
+ */
+declare const PLUGIN_API_VERSION = 1;
+/**
+ * Plugin source types for identification
+ */
+type PluginSource = "builtin" | "npm" | "local" | "custom";
+/**
+ * Main plugin interface
+ */
+interface VulcnPlugin {
+    /** Unique plugin name (e.g., "@vulcn/plugin-payloads") */
+    name: string;
+    /** Plugin version (semver) */
+    version: string;
+    /** Plugin API version this plugin targets */
+    apiVersion?: number;
+    /** Human-readable description */
+    description?: string;
+    /** Lifecycle hooks */
+    hooks?: PluginHooks;
+    /**
+     * Payloads provided by this plugin (Loaders)
+     * Can be static array or async function for lazy loading
+     */
+    payloads?: RuntimePayload[] | (() => Promise<RuntimePayload[]>);
+    /**
+     * Zod schema for plugin configuration validation
+     */
+    configSchema?: z.ZodSchema;
+}
+/**
+ * Plugin lifecycle hooks
+ */
+interface PluginHooks {
+    /**
+     * Called when plugin is loaded, before any operation
+     * Use for setup, loading payloads, etc.
+     */
+    onInit?: (ctx: PluginContext) => Promise<void>;
+    /**
+     * Called when plugin is unloaded/cleanup
+     */
+    onDestroy?: (ctx: PluginContext) => Promise<void>;
+    /** Called when recording starts */
+    onRecordStart?: (ctx: RecordContext) => Promise<void>;
+    /** Called for each recorded step, can transform */
+    onRecordStep?: (step: Step$1, ctx: RecordContext) => Promise<Step$1>;
+    /** Called when recording ends, can transform session */
+    onRecordEnd?: (session: Session$1, ctx: RecordContext) => Promise<Session$1>;
+    /** Called when run starts */
+    onRunStart?: (ctx: RunContext$1) => Promise<void>;
+    /** Called before each payload is injected, can transform payload */
+    onBeforePayload?: (payload: string, step: Step$1, ctx: RunContext$1) => Promise<string>;
+    /** Called after payload injection, for detection */
+    onAfterPayload?: (ctx: DetectContext) => Promise<Finding[]>;
+    /** Called when run ends, can transform results */
+    onRunEnd?: (result: RunResult$1, ctx: RunContext$1) => Promise<RunResult$1>;
+    /** Called on page load/navigation */
+    onPageLoad?: (page: Page, ctx: DetectContext) => Promise<Finding[]>;
+    /** Called when JavaScript alert/confirm/prompt appears */
+    onDialog?: (dialog: Dialog, ctx: DetectContext) => Promise<Finding | null>;
+    /** Called on console.log/warn/error */
+    onConsoleMessage?: (msg: ConsoleMessage, ctx: DetectContext) => Promise<Finding | null>;
+    /** Called on network request */
+    onNetworkRequest?: (request: Request, ctx: DetectContext) => Promise<Finding | null>;
+    /** Called on network response */
+    onNetworkResponse?: (response: Response, ctx: DetectContext) => Promise<Finding | null>;
+}
+/**
+ * Logger interface for plugins
+ */
+interface PluginLogger {
+    debug: (msg: string, ...args: unknown[]) => void;
+    info: (msg: string, ...args: unknown[]) => void;
+    warn: (msg: string, ...args: unknown[]) => void;
+    error: (msg: string, ...args: unknown[]) => void;
+}
+/**
+ * Engine information exposed to plugins
+ */
+interface EngineInfo {
+    version: string;
+    pluginApiVersion: number;
+}
+/**
+ * Base context available to all plugin hooks
+ */
+interface PluginContext {
+    /** Plugin-specific config from vulcn.config.yml */
+    config: Record<string, unknown>;
+    /** Engine information */
+    engine: EngineInfo;
+    /** Shared payload registry - loaders add payloads here */
+    payloads: RuntimePayload[];
+    /** Shared findings collection - detectors add findings here */
+    findings: Finding[];
+    /** Scoped logger */
+    logger: PluginLogger;
+    /** Fetch API for network requests */
+    fetch: typeof fetch;
+}
+/**
+ * Context for recording phase hooks
+ */
+interface RecordContext extends PluginContext {
+    /** Starting URL */
+    startUrl: string;
+    /** Browser type being used */
+    browser: BrowserType;
+    /** Playwright page instance */
+    page: Page;
+}
+/**
+ * Context for running phase hooks
+ */
+interface RunContext$1 extends PluginContext {
+    /** Session being executed */
+    session: Session$1;
+    /** Playwright page instance */
+    page: Page;
+    /** Browser type being used */
+    browser: BrowserType;
+    /** Whether running headless */
+    headless: boolean;
+}
+/**
+ * Context for detection hooks
+ */
+interface DetectContext extends RunContext$1 {
+    /** Current step being tested */
+    step: Step$1;
+    /** Current payload set being tested */
+    payloadSet: RuntimePayload;
+    /** Actual payload value injected */
+    payloadValue: string;
+    /** Step ID for reporting */
+    stepId: string;
+}
+/**
+ * Plugin configuration in vulcn.config.yml
+ */
+interface PluginConfig {
+    /** Plugin name/path */
+    name: string;
+    /** Plugin-specific configuration */
+    config?: Record<string, unknown>;
+    /** Whether plugin is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Vulcn configuration file schema
+ */
+interface VulcnConfig {
+    /** Config version */
+    version: string;
+    /** Plugins to load */
+    plugins?: PluginConfig[];
+    /** Global settings */
+    settings?: {
+        browser?: BrowserType;
+        headless?: boolean;
+        timeout?: number;
     };
-    headless?: boolean;
 }
-interface RunnerOptions {
-    browser?: BrowserType;
+/**
+ * Loaded plugin instance with resolved config
+ */
+interface LoadedPlugin {
+    /** Plugin definition */
+    plugin: VulcnPlugin;
+    /** Resolved configuration */
+    config: Record<string, unknown>;
+    /** Source of the plugin */
+    source: PluginSource;
+    /** Whether plugin is enabled */
+    enabled: boolean;
+}
+
+/**
+ * Vulcn Plugin Manager
+ * Handles plugin loading, lifecycle, and hook execution
+ */
+
+/**
+ * Plugin Manager - loads, configures, and orchestrates plugins
+ */
+declare class PluginManager {
+    private plugins;
+    private config;
+    private initialized;
+    /**
+     * Shared context passed to all plugins
+     */
+    private sharedPayloads;
+    private sharedFindings;
+    /**
+     * Load configuration from vulcn.config.yml
+     */
+    loadConfig(configPath?: string): Promise<VulcnConfig>;
+    /**
+     * Load all plugins from config
+     */
+    loadPlugins(): Promise<void>;
+    /**
+     * Load a single plugin
+     */
+    private loadPlugin;
+    /**
+     * Validate plugin structure
+     */
+    private validatePlugin;
+    /**
+     * Add a plugin programmatically (for testing or dynamic loading)
+     */
+    addPlugin(plugin: VulcnPlugin, config?: Record<string, unknown>): void;
+    /**
+     * Initialize all plugins (call onInit hooks)
+     */
+    initialize(): Promise<void>;
+    /**
+     * Destroy all plugins (call onDestroy hooks)
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get all loaded payloads
+     */
+    getPayloads(): RuntimePayload[];
+    /**
+     * Get all collected findings
+     */
+    getFindings(): Finding[];
+    /**
+     * Add a finding (used by detectors)
+     */
+    addFinding(finding: Finding): void;
+    /**
+     * Add payloads (used by loaders)
+     */
+    addPayloads(payloads: RuntimePayload[]): void;
+    /**
+     * Clear findings (for new run)
+     */
+    clearFindings(): void;
+    /**
+     * Get loaded plugins
+     */
+    getPlugins(): LoadedPlugin[];
+    /**
+     * Check if a plugin is loaded by name
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Create base context for plugins
+     */
+    createContext(pluginConfig: Record<string, unknown>): PluginContext;
+    /**
+     * Create scoped logger for a plugin
+     */
+    private createLogger;
+    /**
+     * Call a hook on all plugins sequentially
+     */
+    callHook<K extends keyof PluginHooks>(hookName: K, executor: (hook: NonNullable<PluginHooks[K]>, ctx: PluginContext) => Promise<unknown>): Promise<void>;
+    /**
+     * Call a hook and collect results
+     */
+    callHookCollect<K extends keyof PluginHooks, R>(hookName: K, executor: (hook: NonNullable<PluginHooks[K]>, ctx: PluginContext) => Promise<R | R[] | null>): Promise<R[]>;
+    /**
+     * Call a hook that transforms a value through the pipeline
+     */
+    callHookPipe<T>(hookName: keyof PluginHooks, initial: T, executor: (hook: NonNullable<PluginHooks[typeof hookName]>, value: T, ctx: PluginContext) => Promise<T>): Promise<T>;
+}
+/**
+ * Default shared plugin manager instance
+ */
+declare const pluginManager: PluginManager;
+
+/**
+ * Vulcn Driver System
+ *
+ * Drivers handle recording and running sessions for different targets:
+ * - browser: Web applications (Playwright)
+ * - api: REST/HTTP APIs
+ * - cli: Command-line tools
+ *
+ * Each driver implements RecorderDriver and RunnerDriver interfaces.
+ */
+
+/**
+ * Current driver API version
+ */
+declare const DRIVER_API_VERSION = 1;
+/**
+ * Generic step - drivers define their own step types
+ */
+interface Step {
+    /** Unique step ID */
+    id: string;
+    /** Step type (namespaced, e.g., "browser.click", "api.request") */
+    type: string;
+    /** Timestamp when step was recorded */
+    timestamp: number;
+    /** Step-specific data */
+    [key: string]: unknown;
+}
+/**
+ * Generic session format
+ */
+interface Session {
+    /** Session name */
+    name: string;
+    /** Driver that recorded this session */
+    driver: string;
+    /** Driver-specific configuration */
+    driverConfig: Record<string, unknown>;
+    /** Recorded steps */
+    steps: Step[];
+    /** Session metadata */
+    metadata?: {
+        recordedAt?: string;
+        version?: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Running context passed to drivers
+ */
+interface RunContext {
+    /** Session being executed */
+    session: Session;
+    /** Plugin manager for calling hooks */
+    pluginManager: PluginManager;
+    /** Available payloads */
+    payloads: RuntimePayload[];
+    /** Collected findings */
+    findings: Finding[];
+    /** Add a finding */
+    addFinding(finding: Finding): void;
+    /** Logger */
+    logger: DriverLogger;
+    /** Running options */
+    options: RunOptions;
+}
+/**
+ * Options for recording
+ */
+interface RecordOptions {
+    /** Driver-specific options */
+    [key: string]: unknown;
+}
+/**
+ * Options for running
+ */
+interface RunOptions {
+    /** Run headless (for visual drivers) */
     headless?: boolean;
+    /** Callback for findings */
     onFinding?: (finding: Finding) => void;
+    /** Callback for step completion */
+    onStepComplete?: (stepId: string, payloadCount: number) => void;
+    /** Driver-specific options */
+    [key: string]: unknown;
 }
-interface Finding {
-    type: "xss" | "sqli" | "ssrf" | "path-traversal" | "custom";
-    severity: "critical" | "high" | "medium" | "low" | "info";
-    title: string;
-    description: string;
-    stepId: string;
-    payload: string;
-    url: string;
-    evidence?: string;
-}
+/**
+ * Run result
+ */
 interface RunResult {
+    /** All findings */
     findings: Finding[];
+    /** Steps executed */
     stepsExecuted: number;
+    /** Payloads tested */
     payloadsTested: number;
+    /** Duration in milliseconds */
     duration: number;
+    /** Errors encountered */
     errors: string[];
 }
+/**
+ * Driver logger
+ */
+interface DriverLogger {
+    debug(msg: string, ...args: unknown[]): void;
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+}
+/**
+ * Recorder Driver Interface
+ *
+ * Implement this to add recording support for a target type.
+ */
+interface RecorderDriver {
+    /** Start recording and return control handle */
+    start(config: Record<string, unknown>, options: RecordOptions): Promise<RecordingHandle>;
+}
+/**
+ * Handle returned by RecorderDriver.start()
+ */
+interface RecordingHandle {
+    /** Stop recording and return the session */
+    stop(): Promise<Session>;
+    /** Abort recording without saving */
+    abort(): Promise<void>;
+    /** Get current steps (during recording) */
+    getSteps(): Step[];
+    /** Manually add a step */
+    addStep(step: Omit<Step, "id" | "timestamp">): void;
+}
+/**
+ * Runner Driver Interface
+ *
+ * Implement this to add running/replay support for a target type.
+ */
+interface RunnerDriver {
+    /** Execute a session with payloads */
+    execute(session: Session, ctx: RunContext): Promise<RunResult>;
+}
+/**
+ * Complete driver definition
+ */
+interface VulcnDriver {
+    /** Unique driver name (e.g., "browser", "api", "cli") */
+    name: string;
+    /** Driver version */
+    version: string;
+    /** Driver API version */
+    apiVersion?: number;
+    /** Human-readable description */
+    description?: string;
+    /** Configuration schema (Zod) */
+    configSchema?: z.ZodSchema;
+    /** Step types this driver handles */
+    stepTypes: string[];
+    /** Recorder implementation */
+    recorder: RecorderDriver;
+    /** Runner implementation */
+    runner: RunnerDriver;
+}
+/**
+ * Driver source for loading
+ */
+type DriverSource = "npm" | "local" | "builtin";
+/**
+ * Loaded driver with metadata
+ */
+interface LoadedDriver {
+    driver: VulcnDriver;
+    source: DriverSource;
+}
 
+/**
+ * Vulcn Driver Manager
+ *
+ * Handles driver loading, registration, and lifecycle.
+ * Drivers are loaded from npm packages or local files.
+ */
+
+/**
+ * Driver Manager - loads and manages recording/running drivers
+ */
+declare class DriverManager {
+    private drivers;
+    private defaultDriver;
+    /**
+     * Register a driver
+     */
+    register(driver: VulcnDriver, source?: DriverSource): void;
+    /**
+     * Load a driver from npm or local path
+     */
+    load(nameOrPath: string): Promise<void>;
+    /**
+     * Get a loaded driver by name
+     */
+    get(name: string): VulcnDriver | undefined;
+    /**
+     * Get the default driver
+     */
+    getDefault(): VulcnDriver | undefined;
+    /**
+     * Set the default driver
+     */
+    setDefault(name: string): void;
+    /**
+     * Check if a driver is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered drivers
+     */
+    list(): LoadedDriver[];
+    /**
+     * Get driver for a session
+     */
+    getForSession(session: Session): VulcnDriver;
+    /**
+     * Start recording with a driver
+     */
+    startRecording(driverName: string, config: Record<string, unknown>, options?: RecordOptions): Promise<RecordingHandle>;
+    /**
+     * Execute a session
+     */
+    execute(session: Session, pluginManager: PluginManager, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Validate driver structure
+     */
+    private validateDriver;
+    /**
+     * Create a scoped logger for a driver
+     */
+    private createLogger;
+}
+/**
+ * Default driver manager instance
+ */
+declare const driverManager: DriverManager;
+
+/**
+ * Recorder - captures browser interactions as a replayable session
+ * v0.2.0: Plugin hooks for recording customization
+ */
+
+/**
+ * Configuration for the recorder
+ */
+interface RecorderConfig {
+    /** Plugin manager to use (defaults to shared instance) */
+    pluginManager?: PluginManager;
+}
 /**
  * Active recording session handle
  */
 interface RecordingSession {
     /** Stop recording and return the session */
-    stop(): Promise<Session>;
+    stop(): Promise<Session$1>;
     /** Get current recorded steps */
-    getSteps(): Step[];
+    getSteps(): Step$1[];
     /** Get the Playwright page (for advanced use) */
     getPage(): Page;
 }
 /**
  * Recorder - captures browser interactions as a replayable session
+ *
+ * Uses plugin hooks for:
+ * - onRecordStart: Called when recording starts
+ * - onRecordStep: Called for each step, can transform
+ * - onRecordEnd: Called when recording ends, can transform session
  */
 declare class Recorder {
     /**
      * Start a new recording session
      * Opens a browser window for the user to interact with
      */
-    static start(startUrl: string, options?: RecorderOptions): Promise<RecordingSession>;
+    static start(startUrl: string, options?: RecorderOptions, config?: RecorderConfig): Promise<RecordingSession>;
+    /**
+     * Transform a step through plugin hooks
+     * Returns null if the step should be filtered out
+     */
+    private static transformStep;
     private static attachListeners;
     private static injectRecordingScript;
 }
 
 /**
- * Built-in security payloads
- */
-type PayloadCategory = "xss" | "sqli" | "ssrf" | "path-traversal";
-type PayloadName = "xss-basic" | "xss-event" | "xss-svg" | "sqli-basic" | "sqli-error" | "sqli-blind";
-interface Payload {
-    name: PayloadName;
-    category: PayloadCategory;
-    payloads: string[];
-    detectPatterns: RegExp[];
-    description: string;
-}
-declare const BUILTIN_PAYLOADS: Record<PayloadName, Payload>;
-/**
- * Get payloads by name
- */
-declare function getPayload(name: PayloadName): Payload | undefined;
-/**
- * Get all payload names
- */
-declare function getPayloadNames(): PayloadName[];
-/**
- * Get payloads by category
+ * Runner - replays sessions with security payloads
+ * v0.2.0: Plugin-based architecture for extensibility
  */
-declare function getPayloadsByCategory(category: PayloadCategory): Payload[];
 
+interface RunnerConfig {
+    /** Plugin manager to use (defaults to shared instance) */
+    pluginManager?: PluginManager;
+}
 /**
  * Runner - replays sessions with security payloads
+ *
+ * Uses plugin hooks for:
+ * - Payload loading (onInit)
+ * - Payload transformation (onBeforePayload)
+ * - Vulnerability detection (onAfterPayload, onDialog, onConsoleMessage, etc.)
+ * - Results processing (onRunEnd)
  */
 declare class Runner {
     /**
-     * Execute a session with security payloads
+     * Execute a session with security payloads from plugins
+     *
+     * @param session - The recorded session to replay
+     * @param options - Runner configuration
+     * @param config - Plugin manager configuration
+     */
+    static execute(session: Session$1, options?: RunnerOptions, config?: RunnerConfig): Promise<RunResult$1>;
+    /**
+     * Execute with explicit payloads (legacy API, for backwards compatibility)
+     */
+    static executeWithPayloads(session: Session$1, payloads: RuntimePayload[], options?: RunnerOptions): Promise<RunResult$1>;
+    /**
+     * Replay session steps with payload injected at target step
      */
-    static execute(session: Session, payloadNames: PayloadName[], options?: RunnerOptions): Promise<RunResult>;
     private static replayWithPayload;
-    private static checkForVulnerability;
+    /**
+     * Basic reflection check - fallback when no detection plugin is loaded
+     */
+    private static checkReflection;
+    /**
+     * Determine severity based on vulnerability category
+     */
+    private static getSeverity;
 }
 
 interface LaunchOptions {
@@ -543,4 +1146,4 @@ declare function checkBrowsers(): Promise<{
     playwrightWebkit: boolean;
 }>;
 
-export { BUILTIN_PAYLOADS, type BrowserLaunchResult, BrowserNotFoundError, type BrowserType, type Finding, type LaunchOptions, type Payload, type PayloadCategory, type PayloadName, Recorder, type RecorderOptions, type RecordingSession, type RunResult, Runner, type RunnerOptions, type Session, SessionSchema, type Step, StepSchema, checkBrowsers, createSession, getPayload, getPayloadNames, getPayloadsByCategory, installBrowsers, launchBrowser, parseSession, serializeSession };
+export { type BrowserLaunchResult, BrowserNotFoundError, type BrowserType, type CustomPayload, type CustomPayloadFile, DRIVER_API_VERSION, type DetectContext, type DriverLogger, DriverManager, type DriverSource, type EngineInfo, type Finding, type LaunchOptions, type Session$1 as LegacySession, type Step$1 as LegacyStep, type LoadedDriver, type LoadedPlugin as LoadedPluginInfo, PLUGIN_API_VERSION, type PayloadCategory, type PayloadSource, type PluginConfig, type PluginContext, type PluginHooks, type PluginLogger, PluginManager, type PluginSource, type RecordContext, type RecordOptions, Recorder, type RecorderDriver, type RecorderOptions, type RecordingHandle, type RecordingSession, type RunContext, type RunOptions, type RunResult, Runner, type RunnerDriver, type RunnerOptions, type RuntimePayload, type Session, SessionSchema, type Step, StepSchema, type VulcnConfig, type VulcnDriver, type VulcnPlugin, checkBrowsers, createSession, driverManager, installBrowsers, launchBrowser, parseSession, pluginManager, serializeSession };