@vulcn/engine 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,422 +1,5 @@
-import { Page, Dialog, ConsoleMessage, Request, Response, Browser } from 'playwright';
 import { z } from 'zod';
 
-declare const StepSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"navigate">;
-    url: z.ZodString;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "navigate";
-    id: string;
-    url: string;
-    timestamp: number;
-}, {
-    type: "navigate";
-    id: string;
-    url: string;
-    timestamp: number;
-}>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"click">;
-    selector: z.ZodString;
-    position: z.ZodOptional<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        x: number;
-        y: number;
-    }, {
-        x: number;
-        y: number;
-    }>>;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "click";
-    id: string;
-    timestamp: number;
-    selector: string;
-    position?: {
-        x: number;
-        y: number;
-    } | undefined;
-}, {
-    type: "click";
-    id: string;
-    timestamp: number;
-    selector: string;
-    position?: {
-        x: number;
-        y: number;
-    } | undefined;
-}>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"input">;
-    selector: z.ZodString;
-    value: z.ZodString;
-    injectable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "input";
-    value: string;
-    id: string;
-    timestamp: number;
-    selector: string;
-    injectable: boolean;
-}, {
-    type: "input";
-    value: string;
-    id: string;
-    timestamp: number;
-    selector: string;
-    injectable?: boolean | undefined;
-}>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"keypress">;
-    key: z.ZodString;
-    modifiers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "keypress";
-    id: string;
-    timestamp: number;
-    key: string;
-    modifiers?: string[] | undefined;
-}, {
-    type: "keypress";
-    id: string;
-    timestamp: number;
-    key: string;
-    modifiers?: string[] | undefined;
-}>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"scroll">;
-    selector: z.ZodOptional<z.ZodString>;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        x: number;
-        y: number;
-    }, {
-        x: number;
-        y: number;
-    }>;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "scroll";
-    id: string;
-    timestamp: number;
-    position: {
-        x: number;
-        y: number;
-    };
-    selector?: string | undefined;
-}, {
-    type: "scroll";
-    id: string;
-    timestamp: number;
-    position: {
-        x: number;
-        y: number;
-    };
-    selector?: string | undefined;
-}>, z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodLiteral<"wait">;
-    duration: z.ZodNumber;
-    timestamp: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    type: "wait";
-    id: string;
-    timestamp: number;
-    duration: number;
-}, {
-    type: "wait";
-    id: string;
-    timestamp: number;
-    duration: number;
-}>]>;
-type Step = z.infer<typeof StepSchema>;
-declare const SessionSchema: z.ZodObject<{
-    version: z.ZodDefault<z.ZodString>;
-    name: z.ZodString;
-    recordedAt: z.ZodString;
-    browser: z.ZodDefault<z.ZodEnum<["chromium", "firefox", "webkit"]>>;
-    viewport: z.ZodObject<{
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        width: number;
-        height: number;
-    }, {
-        width: number;
-        height: number;
-    }>;
-    startUrl: z.ZodString;
-    steps: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"navigate">;
-        url: z.ZodString;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "navigate";
-        id: string;
-        url: string;
-        timestamp: number;
-    }, {
-        type: "navigate";
-        id: string;
-        url: string;
-        timestamp: number;
-    }>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"click">;
-        selector: z.ZodString;
-        position: z.ZodOptional<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            x: number;
-            y: number;
-        }, {
-            x: number;
-            y: number;
-        }>>;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "click";
-        id: string;
-        timestamp: number;
-        selector: string;
-        position?: {
-            x: number;
-            y: number;
-        } | undefined;
-    }, {
-        type: "click";
-        id: string;
-        timestamp: number;
-        selector: string;
-        position?: {
-            x: number;
-            y: number;
-        } | undefined;
-    }>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"input">;
-        selector: z.ZodString;
-        value: z.ZodString;
-        injectable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "input";
-        value: string;
-        id: string;
-        timestamp: number;
-        selector: string;
-        injectable: boolean;
-    }, {
-        type: "input";
-        value: string;
-        id: string;
-        timestamp: number;
-        selector: string;
-        injectable?: boolean | undefined;
-    }>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"keypress">;
-        key: z.ZodString;
-        modifiers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "keypress";
-        id: string;
-        timestamp: number;
-        key: string;
-        modifiers?: string[] | undefined;
-    }, {
-        type: "keypress";
-        id: string;
-        timestamp: number;
-        key: string;
-        modifiers?: string[] | undefined;
-    }>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"scroll">;
-        selector: z.ZodOptional<z.ZodString>;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            x: number;
-            y: number;
-        }, {
-            x: number;
-            y: number;
-        }>;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "scroll";
-        id: string;
-        timestamp: number;
-        position: {
-            x: number;
-            y: number;
-        };
-        selector?: string | undefined;
-    }, {
-        type: "scroll";
-        id: string;
-        timestamp: number;
-        position: {
-            x: number;
-            y: number;
-        };
-        selector?: string | undefined;
-    }>, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodLiteral<"wait">;
-        duration: z.ZodNumber;
-        timestamp: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        type: "wait";
-        id: string;
-        timestamp: number;
-        duration: number;
-    }, {
-        type: "wait";
-        id: string;
-        timestamp: number;
-        duration: number;
-    }>]>, "many">;
-}, "strip", z.ZodTypeAny, {
-    version: string;
-    name: string;
-    recordedAt: string;
-    browser: "chromium" | "firefox" | "webkit";
-    viewport: {
-        width: number;
-        height: number;
-    };
-    startUrl: string;
-    steps: ({
-        type: "navigate";
-        id: string;
-        url: string;
-        timestamp: number;
-    } | {
-        type: "click";
-        id: string;
-        timestamp: number;
-        selector: string;
-        position?: {
-            x: number;
-            y: number;
-        } | undefined;
-    } | {
-        type: "input";
-        value: string;
-        id: string;
-        timestamp: number;
-        selector: string;
-        injectable: boolean;
-    } | {
-        type: "keypress";
-        id: string;
-        timestamp: number;
-        key: string;
-        modifiers?: string[] | undefined;
-    } | {
-        type: "scroll";
-        id: string;
-        timestamp: number;
-        position: {
-            x: number;
-            y: number;
-        };
-        selector?: string | undefined;
-    } | {
-        type: "wait";
-        id: string;
-        timestamp: number;
-        duration: number;
-    })[];
-}, {
-    name: string;
-    recordedAt: string;
-    viewport: {
-        width: number;
-        height: number;
-    };
-    startUrl: string;
-    steps: ({
-        type: "navigate";
-        id: string;
-        url: string;
-        timestamp: number;
-    } | {
-        type: "click";
-        id: string;
-        timestamp: number;
-        selector: string;
-        position?: {
-            x: number;
-            y: number;
-        } | undefined;
-    } | {
-        type: "input";
-        value: string;
-        id: string;
-        timestamp: number;
-        selector: string;
-        injectable?: boolean | undefined;
-    } | {
-        type: "keypress";
-        id: string;
-        timestamp: number;
-        key: string;
-        modifiers?: string[] | undefined;
-    } | {
-        type: "scroll";
-        id: string;
-        timestamp: number;
-        position: {
-            x: number;
-            y: number;
-        };
-        selector?: string | undefined;
-    } | {
-        type: "wait";
-        id: string;
-        timestamp: number;
-        duration: number;
-    })[];
-    version?: string | undefined;
-    browser?: "chromium" | "firefox" | "webkit" | undefined;
-}>;
-type Session = z.infer<typeof SessionSchema>;
-/**
- * Create a new session object
- */
-declare function createSession(options: {
-    name: string;
-    startUrl: string;
-    browser?: "chromium" | "firefox" | "webkit";
-    viewport?: {
-        width: number;
-        height: number;
-    };
-}): Session;
-/**
- * Parse a session from YAML string
- */
-declare function parseSession(yaml: string): Session;
-/**
- * Serialize a session to YAML string
- */
-declare function serializeSession(session: Session): string;
-
 /**
  * Payload Types for Vulcn
  * Core types used by the engine and plugins
@@ -464,20 +47,6 @@ interface CustomPayloadFile {
     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";
@@ -490,17 +59,14 @@ interface Finding {
     /** Plugin-specific metadata */
     metadata?: Record<string, unknown>;
 }
-interface RunResult {
-    findings: Finding[];
-    stepsExecuted: number;
-    payloadsTested: number;
-    duration: number;
-    errors: string[];
-}
 
 /**
  * Vulcn Plugin System Types
  * @module @vulcn/engine/plugin
+ *
+ * The plugin system is driver-agnostic. Detection plugins receive
+ * a generic page interface rather than Playwright types directly.
+ * This allows the same plugin to work across different driver types.
  */
 
 /**
@@ -537,6 +103,10 @@ interface VulcnPlugin {
 }
 /**
  * Plugin lifecycle hooks
+ *
+ * Detection hooks (onDialog, onConsoleMessage, etc.) receive
+ * Playwright types from the driver. Plugins that use these
+ * should declare playwright as a peer/dev dependency.
  */
 interface PluginHooks {
     /**
@@ -555,23 +125,23 @@ interface PluginHooks {
     /** Called when recording ends, can transform session */
     onRecordEnd?: (session: Session, ctx: RecordContext) => Promise<Session>;
     /** Called when run starts */
-    onRunStart?: (ctx: RunContext) => Promise<void>;
+    onRunStart?: (ctx: RunContext$1) => Promise<void>;
     /** Called before each payload is injected, can transform payload */
-    onBeforePayload?: (payload: string, step: Step, ctx: RunContext) => Promise<string>;
+    onBeforePayload?: (payload: string, step: Step, 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, ctx: RunContext) => Promise<RunResult>;
-    /** Called on page load/navigation */
-    onPageLoad?: (page: Page, ctx: DetectContext) => Promise<Finding[]>;
+    onRunEnd?: (result: RunResult, ctx: RunContext$1) => Promise<RunResult>;
     /** Called when JavaScript alert/confirm/prompt appears */
-    onDialog?: (dialog: Dialog, ctx: DetectContext) => Promise<Finding | null>;
+    onDialog?: (dialog: unknown, ctx: DetectContext) => Promise<Finding | null>;
     /** Called on console.log/warn/error */
-    onConsoleMessage?: (msg: ConsoleMessage, ctx: DetectContext) => Promise<Finding | null>;
+    onConsoleMessage?: (msg: unknown, ctx: DetectContext) => Promise<Finding | null>;
+    /** Called on page load/navigation */
+    onPageLoad?: (page: unknown, ctx: DetectContext) => Promise<Finding[]>;
     /** Called on network request */
-    onNetworkRequest?: (request: Request, ctx: DetectContext) => Promise<Finding | null>;
+    onNetworkRequest?: (request: unknown, ctx: DetectContext) => Promise<Finding | null>;
     /** Called on network response */
-    onNetworkResponse?: (response: Response, ctx: DetectContext) => Promise<Finding | null>;
+    onNetworkResponse?: (response: unknown, ctx: DetectContext) => Promise<Finding | null>;
 }
 /**
  * Logger interface for plugins
@@ -610,30 +180,24 @@ interface PluginContext {
  * Context for recording phase hooks
  */
 interface RecordContext extends PluginContext {
-    /** Starting URL */
-    startUrl: string;
-    /** Browser type being used */
-    browser: BrowserType;
-    /** Playwright page instance */
-    page: Page;
+    /** Page interface (driver-specific, e.g. Playwright Page) */
+    page: unknown;
 }
 /**
  * Context for running phase hooks
  */
-interface RunContext extends PluginContext {
+interface RunContext$1 extends PluginContext {
     /** Session being executed */
     session: Session;
-    /** Playwright page instance */
-    page: Page;
-    /** Browser type being used */
-    browser: BrowserType;
+    /** Page interface (driver-specific, e.g. Playwright Page) */
+    page: unknown;
     /** Whether running headless */
     headless: boolean;
 }
 /**
  * Context for detection hooks
  */
-interface DetectContext extends RunContext {
+interface DetectContext extends RunContext$1 {
     /** Current step being tested */
     step: Step;
     /** Current payload set being tested */
@@ -664,7 +228,6 @@ interface VulcnConfig {
     plugins?: PluginConfig[];
     /** Global settings */
     settings?: {
-        browser?: BrowserType;
         headless?: boolean;
         timeout?: number;
     };
@@ -783,126 +346,257 @@ declare class PluginManager {
 declare const pluginManager: PluginManager;
 
 /**
- * Recorder - captures browser interactions as a replayable session
- * v0.2.0: Plugin hooks for recording customization
+ * 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.
  */
 
 /**
- * Configuration for the recorder
+ * 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;
+}
+/**
+ * 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 RecorderConfig {
-    /** Plugin manager to use (defaults to shared instance) */
-    pluginManager?: PluginManager;
+interface RecorderDriver {
+    /** Start recording and return control handle */
+    start(config: Record<string, unknown>, options: RecordOptions): Promise<RecordingHandle>;
 }
 /**
- * Active recording session handle
+ * Handle returned by RecorderDriver.start()
  */
-interface RecordingSession {
+interface RecordingHandle {
     /** Stop recording and return the session */
     stop(): Promise<Session>;
-    /** Get current recorded steps */
+    /** Abort recording without saving */
+    abort(): Promise<void>;
+    /** Get current steps (during recording) */
     getSteps(): Step[];
-    /** Get the Playwright page (for advanced use) */
-    getPage(): Page;
+    /** Manually add a step */
+    addStep(step: Omit<Step, "id" | "timestamp">): void;
 }
 /**
- * Recorder - captures browser interactions as a replayable session
+ * Runner Driver Interface
  *
- * Uses plugin hooks for:
- * - onRecordStart: Called when recording starts
- * - onRecordStep: Called for each step, can transform
- * - onRecordEnd: Called when recording ends, can transform session
+ * Implement this to add running/replay support for a target type.
  */
-declare class Recorder {
-    /**
-     * Start a new recording session
-     * Opens a browser window for the user to interact with
-     */
-    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;
+interface RunnerDriver {
+    /** Execute a session with payloads */
+    execute(session: Session, ctx: RunContext): Promise<RunResult>;
 }
-
 /**
- * Runner - replays sessions with security payloads
- * v0.2.0: Plugin-based architecture for extensibility
+ * Complete driver definition
  */
-
-interface RunnerConfig {
-    /** Plugin manager to use (defaults to shared instance) */
-    pluginManager?: PluginManager;
+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;
 }
+
 /**
- * Runner - replays sessions with security payloads
+ * Vulcn Driver Manager
  *
- * Uses plugin hooks for:
- * - Payload loading (onInit)
- * - Payload transformation (onBeforePayload)
- * - Vulnerability detection (onAfterPayload, onDialog, onConsoleMessage, etc.)
- * - Results processing (onRunEnd)
+ * 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 Runner {
+declare class DriverManager {
+    private drivers;
+    private defaultDriver;
     /**
-     * Execute a session with security payloads from plugins
+     * 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;
+    /**
+     * Parse a YAML session string into a Session object.
      *
-     * @param session - The recorded session to replay
-     * @param options - Runner configuration
-     * @param config - Plugin manager configuration
+     * Handles both new driver-format sessions and legacy v1 sessions.
+     * Legacy sessions (those with non-namespaced step types like "click",
+     * "input", "navigate") are automatically converted to the driver format
+     * (e.g., "browser.click", "browser.input", "browser.navigate").
+     *
+     * @param yaml - Raw YAML string
+     * @param defaultDriver - Driver to assign for legacy sessions (default: "browser")
      */
-    static execute(session: Session, options?: RunnerOptions, config?: RunnerConfig): Promise<RunResult>;
+    parseSession(yaml: string, defaultDriver?: string): Session;
     /**
-     * Execute with explicit payloads (legacy API, for backwards compatibility)
+     * Start recording with a driver
      */
-    static executeWithPayloads(session: Session, payloads: RuntimePayload[], options?: RunnerOptions): Promise<RunResult>;
+    startRecording(driverName: string, config: Record<string, unknown>, options?: RecordOptions): Promise<RecordingHandle>;
     /**
-     * Replay session steps with payload injected at target step
+     * Execute a session
+     * Invokes plugin hooks (onRunStart, onRunEnd) around the driver runner.
      */
-    private static replayWithPayload;
+    execute(session: Session, pluginManager: PluginManager, options?: RunOptions): Promise<RunResult>;
     /**
-     * Basic reflection check - fallback when no detection plugin is loaded
+     * Validate driver structure
      */
-    private static checkReflection;
+    private validateDriver;
     /**
-     * Determine severity based on vulnerability category
+     * Create a scoped logger for a driver
      */
-    private static getSeverity;
-}
-
-interface LaunchOptions {
-    browser?: BrowserType;
-    headless?: boolean;
-}
-interface BrowserLaunchResult {
-    browser: Browser;
-    channel?: string;
-}
-declare class BrowserNotFoundError extends Error {
-    constructor(message: string);
+    private createLogger;
 }
 /**
- * Launch a browser with smart fallback:
- * 1. Try system Chrome/Edge first (zero-install experience)
- * 2. Fall back to Playwright's bundled browsers
- */
-declare function launchBrowser(options?: LaunchOptions): Promise<BrowserLaunchResult>;
-/**
- * Install Playwright browsers
- */
-declare function installBrowsers(browsers?: BrowserType[]): Promise<void>;
-/**
- * Check which browsers are available
+ * Default driver manager instance
  */
-declare function checkBrowsers(): Promise<{
-    systemChrome: boolean;
-    systemEdge: boolean;
-    playwrightChromium: boolean;
-    playwrightFirefox: boolean;
-    playwrightWebkit: boolean;
-}>;
+declare const driverManager: DriverManager;
 
-export { type BrowserLaunchResult, BrowserNotFoundError, type BrowserType, type CustomPayload, type CustomPayloadFile, type DetectContext, type EngineInfo, type Finding, type LaunchOptions, type LoadedPlugin, PLUGIN_API_VERSION, type PayloadCategory, type PayloadSource, type PluginConfig, type PluginContext, type PluginHooks, type PluginLogger, PluginManager, type PluginSource, type RecordContext, Recorder, type RecorderOptions, type RecordingSession, type RunContext, type RunResult, Runner, type RunnerOptions, type RuntimePayload, type Session, SessionSchema, type Step, StepSchema, type VulcnConfig, type VulcnPlugin, checkBrowsers, createSession, installBrowsers, launchBrowser, parseSession, pluginManager, serializeSession };
+export { type CustomPayload, type CustomPayloadFile, DRIVER_API_VERSION, type DetectContext, type DriverLogger, DriverManager, type DriverSource, type EngineInfo, type Finding, type LoadedDriver, type LoadedPlugin as LoadedPluginInfo, PLUGIN_API_VERSION, type PayloadCategory, type PayloadSource, type PluginConfig, type PluginContext, type PluginHooks, type PluginLogger, PluginManager, type RunContext$1 as PluginRunContext, type PluginSource, type RecordContext, type RecordOptions, type RecorderDriver, type RecordingHandle, type RunContext, type RunOptions, type RunResult, type RunnerDriver, type RuntimePayload, type Session, type Step, type VulcnConfig, type VulcnDriver, type VulcnPlugin, driverManager, pluginManager };