@vulcn/engine 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -27,241 +27,278 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
+// src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  BrowserNotFoundError: () => BrowserNotFoundError,
+  DRIVER_API_VERSION: () => DRIVER_API_VERSION,
+  DriverManager: () => DriverManager,
   PLUGIN_API_VERSION: () => PLUGIN_API_VERSION,
   PluginManager: () => PluginManager,
-  Recorder: () => Recorder,
-  Runner: () => Runner,
-  SessionSchema: () => SessionSchema,
-  StepSchema: () => StepSchema,
-  checkBrowsers: () => checkBrowsers,
-  createSession: () => createSession,
-  installBrowsers: () => installBrowsers,
-  launchBrowser: () => launchBrowser,
-  parseSession: () => parseSession,
-  pluginManager: () => pluginManager,
-  serializeSession: () => serializeSession
+  driverManager: () => driverManager,
+  pluginManager: () => pluginManager
 });
 module.exports = __toCommonJS(index_exports);
 
-// session.ts
-var import_zod = require("zod");
+// src/driver-manager.ts
+var import_node_path = require("path");
 var import_yaml = require("yaml");
-var StepSchema = import_zod.z.discriminatedUnion("type", [
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("navigate"),
-    url: import_zod.z.string(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("click"),
-    selector: import_zod.z.string(),
-    position: import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }).optional(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("input"),
-    selector: import_zod.z.string(),
-    value: import_zod.z.string(),
-    injectable: import_zod.z.boolean().optional().default(true),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("keypress"),
-    key: import_zod.z.string(),
-    modifiers: import_zod.z.array(import_zod.z.string()).optional(),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("scroll"),
-    selector: import_zod.z.string().optional(),
-    position: import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }),
-    timestamp: import_zod.z.number()
-  }),
-  import_zod.z.object({
-    id: import_zod.z.string(),
-    type: import_zod.z.literal("wait"),
-    duration: import_zod.z.number(),
-    timestamp: import_zod.z.number()
-  })
-]);
-var SessionSchema = import_zod.z.object({
-  version: import_zod.z.string().default("1"),
-  name: import_zod.z.string(),
-  recordedAt: import_zod.z.string(),
-  browser: import_zod.z.enum(["chromium", "firefox", "webkit"]).default("chromium"),
-  viewport: import_zod.z.object({
-    width: import_zod.z.number(),
-    height: import_zod.z.number()
-  }),
-  startUrl: import_zod.z.string(),
-  steps: import_zod.z.array(StepSchema)
-});
-function createSession(options) {
-  return {
-    version: "1",
-    name: options.name,
-    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    browser: options.browser ?? "chromium",
-    viewport: options.viewport ?? { width: 1280, height: 720 },
-    startUrl: options.startUrl,
-    steps: []
-  };
-}
-function parseSession(yaml) {
-  const data = (0, import_yaml.parse)(yaml);
-  return SessionSchema.parse(data);
-}
-function serializeSession(session) {
-  return (0, import_yaml.stringify)(session, { lineWidth: 0 });
-}
-
-// browser.ts
-var import_playwright = require("playwright");
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-var BrowserNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserNotFoundError";
-  }
-};
-async function launchBrowser(options = {}) {
-  const browserType = options.browser ?? "chromium";
-  const headless = options.headless ?? false;
-  if (browserType === "chromium") {
-    try {
-      const browser = await import_playwright.chromium.launch({
-        channel: "chrome",
-        headless
-      });
-      return { browser, channel: "chrome" };
-    } catch {
-    }
-    try {
-      const browser = await import_playwright.chromium.launch({
-        channel: "msedge",
-        headless
-      });
-      return { browser, channel: "msedge" };
-    } catch {
+var DriverManager = class {
+  drivers = /* @__PURE__ */ new Map();
+  defaultDriver = null;
+  /**
+   * Register a driver
+   */
+  register(driver, source = "builtin") {
+    this.validateDriver(driver);
+    this.drivers.set(driver.name, { driver, source });
+    if (this.drivers.size === 1) {
+      this.defaultDriver = driver.name;
     }
-    try {
-      const browser = await import_playwright.chromium.launch({ headless });
-      return { browser, channel: "chromium" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "No Chromium browser found. Install Chrome or run: vulcn install chromium"
-      );
+  }
+  /**
+   * Load a driver from npm or local path
+   */
+  async load(nameOrPath) {
+    let driver;
+    let source;
+    if (nameOrPath.startsWith("./") || nameOrPath.startsWith("../") || (0, import_node_path.isAbsolute)(nameOrPath)) {
+      const resolved = (0, import_node_path.isAbsolute)(nameOrPath) ? nameOrPath : (0, import_node_path.resolve)(process.cwd(), nameOrPath);
+      const module2 = await import(resolved);
+      driver = module2.default || module2;
+      source = "local";
+    } else {
+      const module2 = await import(nameOrPath);
+      driver = module2.default || module2;
+      source = "npm";
     }
+    this.register(driver, source);
   }
-  if (browserType === "firefox") {
-    try {
-      const browser = await import_playwright.firefox.launch({ headless });
-      return { browser, channel: "firefox" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "Firefox not found. Run: vulcn install firefox"
-      );
+  /**
+   * Get a loaded driver by name
+   */
+  get(name) {
+    return this.drivers.get(name)?.driver;
+  }
+  /**
+   * Get the default driver
+   */
+  getDefault() {
+    if (!this.defaultDriver) return void 0;
+    return this.get(this.defaultDriver);
+  }
+  /**
+   * Set the default driver
+   */
+  setDefault(name) {
+    if (!this.drivers.has(name)) {
+      throw new Error(`Driver "${name}" is not registered`);
     }
+    this.defaultDriver = name;
   }
-  if (browserType === "webkit") {
-    try {
-      const browser = await import_playwright.webkit.launch({ headless });
-      return { browser, channel: "webkit" };
-    } catch {
-      throw new BrowserNotFoundError(
-        "WebKit not found. Run: vulcn install webkit"
+  /**
+   * Check if a driver is registered
+   */
+  has(name) {
+    return this.drivers.has(name);
+  }
+  /**
+   * Get all registered drivers
+   */
+  list() {
+    return Array.from(this.drivers.values());
+  }
+  /**
+   * Get driver for a session
+   */
+  getForSession(session) {
+    const driverName = session.driver;
+    const driver = this.get(driverName);
+    if (!driver) {
+      throw new Error(
+        `Driver "${driverName}" not found. Install @vulcn/driver-${driverName} or load it manually.`
       );
     }
+    return driver;
   }
-  throw new BrowserNotFoundError(`Unknown browser type: ${browserType}`);
-}
-async function installBrowsers(browsers = ["chromium"]) {
-  const browserArg = browsers.join(" ");
-  await execAsync(`npx playwright install ${browserArg}`);
-}
-async function checkBrowsers() {
-  const results = {
-    systemChrome: false,
-    systemEdge: false,
-    playwrightChromium: false,
-    playwrightFirefox: false,
-    playwrightWebkit: false
-  };
-  try {
-    const browser = await import_playwright.chromium.launch({
-      channel: "chrome",
-      headless: true
+  /**
+   * Parse a YAML session string into a Session object.
+   *
+   * 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")
+   */
+  parseSession(yaml, defaultDriver = "browser") {
+    const data = (0, import_yaml.parse)(yaml);
+    if (data.driver && typeof data.driver === "string") {
+      return data;
+    }
+    const steps = data.steps ?? [];
+    const convertedSteps = steps.map((step) => {
+      const type = step.type;
+      if (type.includes(".")) {
+        return step;
+      }
+      return {
+        ...step,
+        type: `${defaultDriver}.${type}`
+      };
     });
-    await browser.close();
-    results.systemChrome = true;
-  } catch {
+    return {
+      name: data.name ?? "Untitled Session",
+      driver: defaultDriver,
+      driverConfig: {
+        browser: data.browser ?? "chromium",
+        viewport: data.viewport ?? { width: 1280, height: 720 },
+        startUrl: data.startUrl
+      },
+      steps: convertedSteps,
+      metadata: {
+        recordedAt: data.recordedAt,
+        version: data.version ?? "1"
+      }
+    };
   }
-  try {
-    const browser = await import_playwright.chromium.launch({
-      channel: "msedge",
-      headless: true
-    });
-    await browser.close();
-    results.systemEdge = true;
-  } catch {
+  /**
+   * Start recording with a driver
+   */
+  async startRecording(driverName, config, options = {}) {
+    const driver = this.get(driverName);
+    if (!driver) {
+      throw new Error(`Driver "${driverName}" not found`);
+    }
+    return driver.recorder.start(config, options);
   }
-  try {
-    const browser = await import_playwright.chromium.launch({ headless: true });
-    await browser.close();
-    results.playwrightChromium = true;
-  } catch {
+  /**
+   * Execute a session
+   * Invokes plugin hooks (onRunStart, onRunEnd) around the driver runner.
+   */
+  async execute(session, pluginManager2, options = {}) {
+    const driver = this.getForSession(session);
+    const findings = [];
+    const logger = this.createLogger(driver.name);
+    const ctx = {
+      session,
+      pluginManager: pluginManager2,
+      payloads: pluginManager2.getPayloads(),
+      findings,
+      addFinding: (finding) => {
+        findings.push(finding);
+        pluginManager2.addFinding(finding);
+        options.onFinding?.(finding);
+      },
+      logger,
+      options
+    };
+    const pluginCtx = {
+      session,
+      page: null,
+      headless: !!options.headless,
+      config: {},
+      engine: { version: "0.3.0", pluginApiVersion: 1 },
+      payloads: pluginManager2.getPayloads(),
+      findings,
+      logger,
+      fetch: globalThis.fetch
+    };
+    for (const loaded of pluginManager2.getPlugins()) {
+      if (loaded.enabled && loaded.plugin.hooks?.onRunStart) {
+        try {
+          await loaded.plugin.hooks.onRunStart({
+            ...pluginCtx,
+            config: loaded.config
+          });
+        } catch (err) {
+          logger.warn(`Plugin ${loaded.plugin.name} onRunStart failed: ${err}`);
+        }
+      }
+    }
+    let result = await driver.runner.execute(session, ctx);
+    for (const loaded of pluginManager2.getPlugins()) {
+      if (loaded.enabled && loaded.plugin.hooks?.onRunEnd) {
+        try {
+          result = await loaded.plugin.hooks.onRunEnd(result, {
+            ...pluginCtx,
+            config: loaded.config,
+            findings: result.findings
+          });
+        } catch (err) {
+          logger.warn(`Plugin ${loaded.plugin.name} onRunEnd failed: ${err}`);
+        }
+      }
+    }
+    return result;
   }
-  try {
-    const browser = await import_playwright.firefox.launch({ headless: true });
-    await browser.close();
-    results.playwrightFirefox = true;
-  } catch {
+  /**
+   * Validate driver structure
+   */
+  validateDriver(driver) {
+    if (!driver || typeof driver !== "object") {
+      throw new Error("Driver must be an object");
+    }
+    const d = driver;
+    if (typeof d.name !== "string" || !d.name) {
+      throw new Error("Driver must have a name");
+    }
+    if (typeof d.version !== "string" || !d.version) {
+      throw new Error("Driver must have a version");
+    }
+    if (!Array.isArray(d.stepTypes) || d.stepTypes.length === 0) {
+      throw new Error("Driver must define stepTypes");
+    }
+    if (!d.recorder || typeof d.recorder !== "object") {
+      throw new Error("Driver must have a recorder");
+    }
+    if (!d.runner || typeof d.runner !== "object") {
+      throw new Error("Driver must have a runner");
+    }
   }
-  try {
-    const browser = await import_playwright.webkit.launch({ headless: true });
-    await browser.close();
-    results.playwrightWebkit = true;
-  } catch {
+  /**
+   * Create a scoped logger for a driver
+   */
+  createLogger(name) {
+    const prefix = `[driver:${name}]`;
+    return {
+      debug: (msg, ...args) => console.debug(prefix, msg, ...args),
+      info: (msg, ...args) => console.info(prefix, msg, ...args),
+      warn: (msg, ...args) => console.warn(prefix, msg, ...args),
+      error: (msg, ...args) => console.error(prefix, msg, ...args)
+    };
   }
-  return results;
-}
+};
+var driverManager = new DriverManager();
 
-// plugin-manager.ts
+// src/driver-types.ts
+var DRIVER_API_VERSION = 1;
+
+// src/plugin-manager.ts
 var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 var import_yaml2 = __toESM(require("yaml"), 1);
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 
-// plugin-types.ts
+// src/plugin-types.ts
 var PLUGIN_API_VERSION = 1;
 
-// plugin-manager.ts
+// src/plugin-manager.ts
 var ENGINE_VERSION = "0.2.0";
-var VulcnConfigSchema = import_zod2.z.object({
-  version: import_zod2.z.string().default("1"),
-  plugins: import_zod2.z.array(
-    import_zod2.z.object({
-      name: import_zod2.z.string(),
-      config: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      enabled: import_zod2.z.boolean().default(true)
+var VulcnConfigSchema = import_zod.z.object({
+  version: import_zod.z.string().default("1"),
+  plugins: import_zod.z.array(
+    import_zod.z.object({
+      name: import_zod.z.string(),
+      config: import_zod.z.record(import_zod.z.unknown()).optional(),
+      enabled: import_zod.z.boolean().default(true)
     })
   ).optional(),
-  settings: import_zod2.z.object({
-    browser: import_zod2.z.enum(["chromium", "firefox", "webkit"]).optional(),
-    headless: import_zod2.z.boolean().optional(),
-    timeout: import_zod2.z.number().optional()
+  settings: import_zod.z.object({
+    browser: import_zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
+    headless: import_zod.z.boolean().optional(),
+    timeout: import_zod.z.number().optional()
   }).optional()
 });
 var PluginManager = class {
@@ -286,7 +323,7 @@ var PluginManager = class {
       ".vulcnrc.json"
     ];
     for (const path of paths) {
-      const resolved = (0, import_node_path.isAbsolute)(path) ? path : (0, import_node_path.resolve)(process.cwd(), path);
+      const resolved = (0, import_node_path2.isAbsolute)(path) ? path : (0, import_node_path2.resolve)(process.cwd(), path);
       if ((0, import_node_fs.existsSync)(resolved)) {
         const content = await (0, import_promises.readFile)(resolved, "utf-8");
         const parsed = path.endsWith(".json") ? JSON.parse(content) : import_yaml2.default.parse(content);
@@ -325,8 +362,8 @@ var PluginManager = class {
     const { name, config: pluginConfig = {} } = config;
     let plugin;
     let source;
-    if (name.startsWith("./") || name.startsWith("../") || (0, import_node_path.isAbsolute)(name)) {
-      const resolved = (0, import_node_path.isAbsolute)(name) ? name : (0, import_node_path.resolve)(process.cwd(), name);
+    if (name.startsWith("./") || name.startsWith("../") || (0, import_node_path2.isAbsolute)(name)) {
+      const resolved = (0, import_node_path2.isAbsolute)(name) ? name : (0, import_node_path2.resolve)(process.cwd(), name);
       const module2 = await import(resolved);
       plugin = module2.default || module2;
       source = "local";
@@ -565,601 +602,13 @@ var PluginManager = class {
   }
 };
 var pluginManager = new PluginManager();
-
-// recorder.ts
-var Recorder = class _Recorder {
-  /**
-   * Start a new recording session
-   * Opens a browser window for the user to interact with
-   */
-  static async start(startUrl, options = {}, config = {}) {
-    const manager = config.pluginManager ?? pluginManager;
-    const browserType = options.browser ?? "chromium";
-    const viewport = options.viewport ?? { width: 1280, height: 720 };
-    const headless = options.headless ?? false;
-    await manager.initialize();
-    const { browser } = await launchBrowser({
-      browser: browserType,
-      headless
-    });
-    const context = await browser.newContext({ viewport });
-    const page = await context.newPage();
-    await page.goto(startUrl);
-    const session = createSession({
-      name: `Recording ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      startUrl,
-      browser: browserType,
-      viewport
-    });
-    const startTime = Date.now();
-    const steps = [];
-    let stepCounter = 0;
-    const generateStepId = () => {
-      stepCounter++;
-      return `step_${String(stepCounter).padStart(3, "0")}`;
-    };
-    const baseRecordContext = {
-      startUrl,
-      browser: browserType,
-      page,
-      engine: { version: "0.2.0", pluginApiVersion: 1 },
-      payloads: manager.getPayloads(),
-      findings: manager.getFindings(),
-      logger: {
-        debug: console.debug.bind(console),
-        info: console.info.bind(console),
-        warn: console.warn.bind(console),
-        error: console.error.bind(console)
-      },
-      fetch: globalThis.fetch
-    };
-    await manager.callHook("onRecordStart", async (hook, ctx) => {
-      const recordCtx = { ...baseRecordContext, ...ctx };
-      await hook(recordCtx);
-    });
-    const initialStep = {
-      id: generateStepId(),
-      type: "navigate",
-      url: startUrl,
-      timestamp: 0
-    };
-    const transformedInitialStep = await _Recorder.transformStep(
-      initialStep,
-      manager,
-      baseRecordContext
-    );
-    if (transformedInitialStep) {
-      steps.push(transformedInitialStep);
-    }
-    _Recorder.attachListeners(
-      page,
-      steps,
-      startTime,
-      generateStepId,
-      manager,
-      baseRecordContext
-    );
-    return {
-      async stop() {
-        session.steps = steps;
-        let finalSession = session;
-        for (const loaded of manager.getPlugins()) {
-          const hook = loaded.plugin.hooks?.onRecordEnd;
-          if (hook) {
-            const ctx = manager.createContext(loaded.config);
-            const recordCtx = { ...baseRecordContext, ...ctx };
-            finalSession = await hook(finalSession, recordCtx);
-          }
-        }
-        await browser.close();
-        return finalSession;
-      },
-      getSteps() {
-        return [...steps];
-      },
-      getPage() {
-        return page;
-      }
-    };
-  }
-  /**
-   * Transform a step through plugin hooks
-   * Returns null if the step should be filtered out
-   */
-  static async transformStep(step, manager, baseContext) {
-    let transformedStep = step;
-    for (const loaded of manager.getPlugins()) {
-      const hook = loaded.plugin.hooks?.onRecordStep;
-      if (hook) {
-        const ctx = manager.createContext(loaded.config);
-        const recordCtx = { ...baseContext, ...ctx };
-        transformedStep = await hook(transformedStep, recordCtx);
-      }
-    }
-    return transformedStep;
-  }
-  static attachListeners(page, steps, startTime, generateStepId, manager, baseContext) {
-    const getTimestamp = () => Date.now() - startTime;
-    const addStep = async (step) => {
-      const transformed = await _Recorder.transformStep(
-        step,
-        manager,
-        baseContext
-      );
-      if (transformed) {
-        steps.push(transformed);
-      }
-    };
-    page.on("framenavigated", (frame) => {
-      if (frame === page.mainFrame()) {
-        const url = frame.url();
-        const lastStep = steps[steps.length - 1];
-        if (steps.length > 0 && lastStep.type === "navigate" && lastStep.url === url) {
-          return;
-        }
-        addStep({
-          id: generateStepId(),
-          type: "navigate",
-          url,
-          timestamp: getTimestamp()
-        });
-      }
-    });
-    page.exposeFunction(
-      "__vulcn_record",
-      async (event) => {
-        const timestamp = getTimestamp();
-        switch (event.type) {
-          case "click": {
-            const data = event.data;
-            await addStep({
-              id: generateStepId(),
-              type: "click",
-              selector: data.selector,
-              position: { x: data.x, y: data.y },
-              timestamp
-            });
-            break;
-          }
-          case "input": {
-            const data = event.data;
-            await addStep({
-              id: generateStepId(),
-              type: "input",
-              selector: data.selector,
-              value: data.value,
-              injectable: data.injectable,
-              timestamp
-            });
-            break;
-          }
-          case "keypress": {
-            const data = event.data;
-            await addStep({
-              id: generateStepId(),
-              type: "keypress",
-              key: data.key,
-              modifiers: data.modifiers,
-              timestamp
-            });
-            break;
-          }
-        }
-      }
-    );
-    page.on("load", async () => {
-      await _Recorder.injectRecordingScript(page);
-    });
-    _Recorder.injectRecordingScript(page);
-  }
-  static async injectRecordingScript(page) {
-    await page.evaluate(`
-      (function() {
-        if (window.__vulcn_injected) return;
-        window.__vulcn_injected = true;
-
-        var textInputTypes = ['text', 'password', 'email', 'search', 'url', 'tel', 'number'];
-
-        function getSelector(el) {
-          if (el.id) {
-            return '#' + CSS.escape(el.id);
-          }
-          if (el.name) {
-            var tag = el.tagName.toLowerCase();
-            var nameSelector = tag + '[name="' + el.name + '"]';
-            if (document.querySelectorAll(nameSelector).length === 1) {
-              return nameSelector;
-            }
-          }
-          if (el.dataset && el.dataset.testid) {
-            return '[data-testid="' + el.dataset.testid + '"]';
-          }
-          if (el.tagName === 'INPUT' && el.type && el.name) {
-            var inputSelector = 'input[type="' + el.type + '"][name="' + el.name + '"]';
-            if (document.querySelectorAll(inputSelector).length === 1) {
-              return inputSelector;
-            }
-          }
-          if (el.className && typeof el.className === 'string') {
-            var classes = el.className.trim().split(/\\s+/).filter(function(c) { return c.length > 0; });
-            if (classes.length > 0) {
-              var classSelector = el.tagName.toLowerCase() + '.' + classes.map(function(c) { return CSS.escape(c); }).join('.');
-              if (document.querySelectorAll(classSelector).length === 1) {
-                return classSelector;
-              }
-            }
-          }
-          var path = [];
-          var current = el;
-          while (current && current !== document.body) {
-            var tag = current.tagName.toLowerCase();
-            var parent = current.parentElement;
-            if (parent) {
-              var siblings = Array.from(parent.children).filter(function(c) { return c.tagName === current.tagName; });
-              if (siblings.length > 1) {
-                var index = siblings.indexOf(current) + 1;
-                tag = tag + ':nth-of-type(' + index + ')';
-              }
-            }
-            path.unshift(tag);
-            current = parent;
-          }
-          return path.join(' > ');
-        }
-
-        function getInputType(el) {
-          if (el.tagName === 'INPUT') return el.type || 'text';
-          if (el.tagName === 'TEXTAREA') return 'textarea';
-          if (el.tagName === 'SELECT') return 'select';
-          return null;
-        }
-
-        function isTextInjectable(el) {
-          var inputType = getInputType(el);
-          if (!inputType) return false;
-          if (inputType === 'textarea') return true;
-          if (inputType === 'select') return false;
-          return textInputTypes.indexOf(inputType) !== -1;
-        }
-
-        document.addEventListener('click', function(e) {
-          var target = e.target;
-          window.__vulcn_record({
-            type: 'click',
-            data: {
-              selector: getSelector(target),
-              x: e.clientX,
-              y: e.clientY
-            }
-          });
-        }, true);
-
-        document.addEventListener('change', function(e) {
-          var target = e.target;
-          if ('value' in target) {
-            var inputType = getInputType(target);
-            window.__vulcn_record({
-              type: 'input',
-              data: {
-                selector: getSelector(target),
-                value: target.value,
-                inputType: inputType,
-                injectable: isTextInjectable(target)
-              }
-            });
-          }
-        }, true);
-
-        document.addEventListener('keydown', function(e) {
-          if (e.ctrlKey || e.metaKey || e.altKey) {
-            var modifiers = [];
-            if (e.ctrlKey) modifiers.push('ctrl');
-            if (e.metaKey) modifiers.push('meta');
-            if (e.altKey) modifiers.push('alt');
-            if (e.shiftKey) modifiers.push('shift');
-
-            window.__vulcn_record({
-              type: 'keypress',
-              data: {
-                key: e.key,
-                modifiers: modifiers
-              }
-            });
-          }
-        }, true);
-      })();
-    `);
-  }
-};
-
-// runner.ts
-var Runner = class _Runner {
-  /**
-   * 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 async execute(session, options = {}, config = {}) {
-    const manager = config.pluginManager ?? pluginManager;
-    const browserType = options.browser ?? session.browser ?? "chromium";
-    const headless = options.headless ?? true;
-    const startTime = Date.now();
-    const errors = [];
-    let payloadsTested = 0;
-    await manager.initialize();
-    manager.clearFindings();
-    const payloads = manager.getPayloads();
-    if (payloads.length === 0) {
-      return {
-        findings: [],
-        stepsExecuted: session.steps.length,
-        payloadsTested: 0,
-        duration: Date.now() - startTime,
-        errors: [
-          "No payloads loaded. Add a payload plugin or configure payloads."
-        ]
-      };
-    }
-    const { browser } = await launchBrowser({
-      browser: browserType,
-      headless
-    });
-    const context = await browser.newContext({ viewport: session.viewport });
-    const page = await context.newPage();
-    const baseRunContext = {
-      session,
-      page,
-      browser: browserType,
-      headless,
-      engine: { version: "0.2.0", pluginApiVersion: 1 },
-      payloads: manager.getPayloads(),
-      findings: manager.getFindings(),
-      logger: {
-        debug: console.debug.bind(console),
-        info: console.info.bind(console),
-        warn: console.warn.bind(console),
-        error: console.error.bind(console)
-      },
-      fetch: globalThis.fetch
-    };
-    await manager.callHook("onRunStart", async (hook, ctx) => {
-      const runCtx = { ...baseRunContext, ...ctx };
-      await hook(runCtx);
-    });
-    const eventFindings = [];
-    let currentDetectContext = null;
-    const dialogHandler = async (dialog) => {
-      if (currentDetectContext) {
-        const findings = await manager.callHookCollect(
-          "onDialog",
-          async (hook, ctx) => {
-            const detectCtx = {
-              ...currentDetectContext,
-              ...ctx
-            };
-            return hook(dialog, detectCtx);
-          }
-        );
-        eventFindings.push(...findings);
-      }
-      try {
-        await dialog.dismiss();
-      } catch {
-      }
-    };
-    const consoleHandler = async (msg) => {
-      if (currentDetectContext) {
-        const findings = await manager.callHookCollect("onConsoleMessage", async (hook, ctx) => {
-          const detectCtx = { ...currentDetectContext, ...ctx };
-          return hook(msg, detectCtx);
-        });
-        eventFindings.push(...findings);
-      }
-    };
-    page.on("dialog", dialogHandler);
-    page.on("console", consoleHandler);
-    try {
-      const injectableSteps = session.steps.filter(
-        (step) => step.type === "input" && step.injectable !== false
-      );
-      const allPayloads = [];
-      for (const payloadSet of payloads) {
-        for (const value of payloadSet.payloads) {
-          allPayloads.push({ payloadSet, value });
-        }
-      }
-      for (const injectableStep of injectableSteps) {
-        for (const { payloadSet, value: originalValue } of allPayloads) {
-          try {
-            let transformedPayload = originalValue;
-            for (const loaded of manager.getPlugins()) {
-              const hook = loaded.plugin.hooks?.onBeforePayload;
-              if (hook) {
-                const ctx = manager.createContext(loaded.config);
-                const runCtx = { ...baseRunContext, ...ctx };
-                transformedPayload = await hook(
-                  transformedPayload,
-                  injectableStep,
-                  runCtx
-                );
-              }
-            }
-            currentDetectContext = {
-              ...baseRunContext,
-              config: {},
-              step: injectableStep,
-              payloadSet,
-              payloadValue: transformedPayload,
-              stepId: injectableStep.id
-            };
-            await _Runner.replayWithPayload(
-              page,
-              session,
-              injectableStep,
-              transformedPayload
-            );
-            const afterFindings = await manager.callHookCollect("onAfterPayload", async (hook, ctx) => {
-              const detectCtx = {
-                ...currentDetectContext,
-                ...ctx
-              };
-              return hook(detectCtx);
-            });
-            const reflectionFinding = await _Runner.checkReflection(
-              page,
-              injectableStep,
-              payloadSet,
-              transformedPayload
-            );
-            const allFindings = [...afterFindings, ...eventFindings];
-            if (reflectionFinding) {
-              allFindings.push(reflectionFinding);
-            }
-            for (const finding of allFindings) {
-              manager.addFinding(finding);
-              options.onFinding?.(finding);
-            }
-            eventFindings.length = 0;
-            payloadsTested++;
-          } catch (err) {
-            errors.push(`${injectableStep.id}: ${String(err)}`);
-          }
-        }
-      }
-    } finally {
-      page.off("dialog", dialogHandler);
-      page.off("console", consoleHandler);
-      currentDetectContext = null;
-      await browser.close();
-    }
-    let result = {
-      findings: manager.getFindings(),
-      stepsExecuted: session.steps.length,
-      payloadsTested,
-      duration: Date.now() - startTime,
-      errors
-    };
-    for (const loaded of manager.getPlugins()) {
-      const hook = loaded.plugin.hooks?.onRunEnd;
-      if (hook) {
-        const ctx = manager.createContext(loaded.config);
-        const runCtx = { ...baseRunContext, ...ctx };
-        result = await hook(result, runCtx);
-      }
-    }
-    return result;
-  }
-  /**
-   * Execute with explicit payloads (legacy API, for backwards compatibility)
-   */
-  static async executeWithPayloads(session, payloads, options = {}) {
-    const manager = new PluginManager();
-    manager.addPayloads(payloads);
-    return _Runner.execute(session, options, { pluginManager: manager });
-  }
-  /**
-   * Replay session steps with payload injected at target step
-   */
-  static async replayWithPayload(page, session, targetStep, payloadValue) {
-    await page.goto(session.startUrl, { waitUntil: "domcontentloaded" });
-    for (const step of session.steps) {
-      try {
-        if (step.type === "navigate") {
-          await page.goto(step.url, { waitUntil: "domcontentloaded" });
-        } else if (step.type === "click") {
-          await page.click(step.selector, { timeout: 5e3 });
-        } else if (step.type === "input") {
-          const value = step.id === targetStep.id ? payloadValue : step.value;
-          await page.fill(step.selector, value, { timeout: 5e3 });
-        } else if (step.type === "keypress") {
-          const modifiers = step.modifiers ?? [];
-          for (const mod of modifiers) {
-            await page.keyboard.down(
-              mod
-            );
-          }
-          await page.keyboard.press(step.key);
-          for (const mod of modifiers.reverse()) {
-            await page.keyboard.up(mod);
-          }
-        }
-      } catch {
-      }
-      if (step.id === targetStep.id) {
-        await page.waitForTimeout(100);
-        break;
-      }
-    }
-  }
-  /**
-   * Basic reflection check - fallback when no detection plugin is loaded
-   */
-  static async checkReflection(page, step, payloadSet, payloadValue) {
-    const content = await page.content();
-    for (const pattern of payloadSet.detectPatterns) {
-      if (pattern.test(content)) {
-        return {
-          type: payloadSet.category,
-          severity: _Runner.getSeverity(payloadSet.category),
-          title: `${payloadSet.category.toUpperCase()} vulnerability detected`,
-          description: `Payload pattern was reflected in page content`,
-          stepId: step.id,
-          payload: payloadValue,
-          url: page.url(),
-          evidence: content.match(pattern)?.[0]?.slice(0, 200)
-        };
-      }
-    }
-    if (content.includes(payloadValue)) {
-      return {
-        type: payloadSet.category,
-        severity: "medium",
-        title: `Potential ${payloadSet.category.toUpperCase()} - payload reflection`,
-        description: `Payload was reflected in page without encoding`,
-        stepId: step.id,
-        payload: payloadValue,
-        url: page.url()
-      };
-    }
-    return void 0;
-  }
-  /**
-   * Determine severity based on vulnerability category
-   */
-  static getSeverity(category) {
-    switch (category) {
-      case "sqli":
-      case "command-injection":
-      case "xxe":
-        return "critical";
-      case "xss":
-      case "ssrf":
-      case "path-traversal":
-        return "high";
-      case "open-redirect":
-        return "medium";
-      default:
-        return "medium";
-    }
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BrowserNotFoundError,
+  DRIVER_API_VERSION,
+  DriverManager,
   PLUGIN_API_VERSION,
   PluginManager,
-  Recorder,
-  Runner,
-  SessionSchema,
-  StepSchema,
-  checkBrowsers,
-  createSession,
-  installBrowsers,
-  launchBrowser,
-  parseSession,
-  pluginManager,
-  serializeSession
+  driverManager,
+  pluginManager
 });
 //# sourceMappingURL=index.cjs.map