@browserless.io/browserless 2.0.0-beta-5 → 2.0.0-beta-7

package/build/routes/management/http/metrics-get.js

@@ -1,24 +1,19 @@
-import { APITags, HTTPManagementRoutes, Methods, ServerError, contentTypes, writeResponse, } from '@browserless.io/browserless';
-const route = {
-    accepts: [contentTypes.any],
-    auth: true,
-    browser: null,
-    concurrency: false,
-    contentTypes: [contentTypes.json],
-    description: `Gets total metric details from the time the server started.`,
-    handler: async (_req, res) => {
-        const { getFileSystem: _fileSystem, getConfig: _config } = route;
-        if (!_fileSystem || !_config) {
-            throw new ServerError(`Couldn't locate the file-system or config module`);
-        }
-        const fileSystem = _fileSystem();
-        const config = _config();
+import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, contentTypes, writeResponse, } from '@browserless.io/browserless';
+export default class MetricsGetRoute extends HTTPRoute {
+    accepts = [contentTypes.any];
+    auth = true;
+    browser = null;
+    concurrency = false;
+    contentTypes = [contentTypes.json];
+    description = `Gets total metric details from the time the server started.`;
+    method = Methods.get;
+    path = HTTPManagementRoutes.metrics;
+    tags = [APITags.management];
+    handler = async (_req, res) => {
+        const fileSystem = this.fileSystem();
+        const config = this.config();
         const stats = await fileSystem.read(config.getMetricsJSONPath());
         const response = `[${stats.join(',')}]`;
         return writeResponse(res, 200, response, contentTypes.json);
-    },
-    method: Methods.get,
-    path: HTTPManagementRoutes.metrics,
-    tags: [APITags.management],
-};
-export default route;
+    };
+}

package/build/routes/management/http/metrics-total-get.d.ts

@@ -1,4 +1,16 @@
-import { HTTPRoute, IBrowserlessMetricTotals } from '@browserless.io/browserless';
+/// <reference types="node" />
+import { APITags, HTTPManagementRoutes, HTTPRoute, IBrowserlessMetricTotals, Methods, Request, contentTypes } from '@browserless.io/browserless';
+import { ServerResponse } from 'http';
 export type ResponseSchema = IBrowserlessMetricTotals;
-declare const route: HTTPRoute;
-export default route;
+export default class MetricsTotalGetRoute extends HTTPRoute {
+    accepts: contentTypes[];
+    auth: boolean;
+    browser: null;
+    concurrency: boolean;
+    contentTypes: contentTypes[];
+    description: string;
+    method: Methods;
+    path: HTTPManagementRoutes;
+    tags: APITags[];
+    handler: (_req: Request, res: ServerResponse) => Promise<void>;
+}

package/build/routes/management/http/metrics-total-get.js

@@ -1,19 +1,18 @@
-import { APITags, HTTPManagementRoutes, Methods, ServerError, contentTypes, writeResponse, } from '@browserless.io/browserless';
+import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, contentTypes, writeResponse, } from '@browserless.io/browserless';
 const fiveMinuteIntervalsInAMonth = 8640;
-const route = {
-    accepts: [contentTypes.any],
-    auth: true,
-    browser: null,
-    concurrency: false,
-    contentTypes: [contentTypes.json],
-    description: `Gets total metric details summed from the time the server started.`,
-    handler: async (_req, res) => {
-        const { getFileSystem: _fileSystem, getConfig: _config } = route;
-        if (!_fileSystem || !_config) {
-            throw new ServerError(`Couldn't locate the file-system or config module`);
-        }
-        const fileSystem = _fileSystem();
-        const config = _config();
+export default class MetricsTotalGetRoute extends HTTPRoute {
+    accepts = [contentTypes.any];
+    auth = true;
+    browser = null;
+    concurrency = false;
+    contentTypes = [contentTypes.json];
+    description = `Gets total metric details summed from the time the server started.`;
+    method = Methods.get;
+    path = HTTPManagementRoutes.metricsTotal;
+    tags = [APITags.management];
+    handler = async (_req, res) => {
+        const fileSystem = this.fileSystem();
+        const config = this.config();
         const metrics = (await fileSystem.read(config.getMetricsJSONPath())).map((m) => JSON.parse(m));
         const availableMetrics = metrics.length;
         const totals = metrics.reduce((accum, metric) => ({
@@ -52,9 +51,5 @@ const route = {
         totals.meanTime = totals.meanTime / metrics.length;
         totals.estimatedMonthlyUnits = Math.round(totals.units / (availableMetrics / fiveMinuteIntervalsInAMonth));
         return writeResponse(res, 200, JSON.stringify(totals), contentTypes.json);
-    },
-    method: Methods.get,
-    path: HTTPManagementRoutes.metricsTotal,
-    tags: [APITags.management],
-};
-export default route;
+    };
+}

package/build/routes/management/http/sessions-get.d.ts

@@ -1,4 +1,16 @@
-import { BrowserlessSessionJSON, HTTPRoute } from '@browserless.io/browserless';
+/// <reference types="node" />
+import { APITags, BrowserlessSessionJSON, HTTPManagementRoutes, HTTPRoute, Methods, Request, contentTypes } from '@browserless.io/browserless';
+import { ServerResponse } from 'http';
 export type ResponseSchema = BrowserlessSessionJSON[];
-declare const route: HTTPRoute;
-export default route;
+export default class SessionsGetRoute extends HTTPRoute {
+    accepts: contentTypes[];
+    auth: boolean;
+    browser: null;
+    concurrency: boolean;
+    contentTypes: contentTypes[];
+    description: string;
+    method: Methods;
+    path: HTTPManagementRoutes;
+    tags: APITags[];
+    handler: (_req: Request, res: ServerResponse) => Promise<void>;
+}

package/build/routes/management/http/sessions-get.js

@@ -1,21 +1,17 @@
-import { APITags, BadRequest, HTTPManagementRoutes, Methods, contentTypes, jsonResponse, } from '@browserless.io/browserless';
-const route = {
-    accepts: [contentTypes.any],
-    auth: true,
-    browser: null,
-    concurrency: false,
-    contentTypes: [contentTypes.json],
-    description: `Lists all currently running sessions and relevant meta-data excluding potentially open pages.`,
-    handler: async (_req, res) => {
-        const { getBrowserManager: browserManager } = route;
-        if (!browserManager) {
-            throw new BadRequest(`Couldn't load browsers running`);
-        }
-        const response = await browserManager().getAllSessions();
+import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, contentTypes, jsonResponse, } from '@browserless.io/browserless';
+export default class SessionsGetRoute extends HTTPRoute {
+    accepts = [contentTypes.any];
+    auth = true;
+    browser = null;
+    concurrency = false;
+    contentTypes = [contentTypes.json];
+    description = `Lists all currently running sessions and relevant meta-data excluding potentially open pages.`;
+    method = Methods.get;
+    path = HTTPManagementRoutes.sessions;
+    tags = [APITags.management];
+    handler = async (_req, res) => {
+        const browserManager = this.browserManager();
+        const response = await browserManager.getAllSessions();
         return jsonResponse(res, 200, response);
-    },
-    method: Methods.get,
-    path: HTTPManagementRoutes.sessions,
-    tags: [APITags.management],
-};
-export default route;
+    };
+}

package/build/routes/management/http/static-get.d.ts

@@ -1,3 +1,15 @@
-import { HTTPRoute } from '@browserless.io/browserless';
-declare const route: HTTPRoute;
-export default route;
+/// <reference types="node" />
+import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, Request, contentTypes } from '@browserless.io/browserless';
+import { ServerResponse } from 'http';
+export default class StaticGetRoute extends HTTPRoute {
+    accepts: contentTypes[];
+    auth: boolean;
+    browser: null;
+    concurrency: boolean;
+    contentTypes: contentTypes[];
+    description: string;
+    method: Methods;
+    path: HTTPManagementRoutes;
+    tags: APITags[];
+    handler: (req: Request, res: ServerResponse) => Promise<unknown>;
+}

package/build/routes/management/http/static-get.js

@@ -1,4 +1,4 @@
-import { APITags, HTTPManagementRoutes, Methods, NotFound, ServerError, contentTypes, createLogger, fileExists, mimeTypes, } from '@browserless.io/browserless';
+import { APITags, HTTPManagementRoutes, HTTPRoute, Methods, NotFound, contentTypes, createLogger, fileExists, mimeTypes, } from '@browserless.io/browserless';
 import { createReadStream } from 'fs';
 import path from 'path';
 const debug = createLogger('http:static');
@@ -20,24 +20,23 @@ const streamFile = (res, file, contentType) => new Promise((resolve, reject) =>
         .on('end', resolve)
         .pipe(res);
 });
-const route = {
-    accepts: [contentTypes.any],
-    auth: false,
-    browser: null,
-    concurrency: false,
-    contentTypes: [contentTypes.any],
-    description: `Serves static files inside of this "static" directory. Content-types will vary depending on the type of file being returned.`,
-    handler: async (req, res) => {
-        const { getConfig: getConfig } = route;
+export default class StaticGetRoute extends HTTPRoute {
+    accepts = [contentTypes.any];
+    auth = false;
+    browser = null;
+    concurrency = false;
+    contentTypes = [contentTypes.any];
+    description = `Serves static files inside of this "static" directory. Content-types will vary depending on the type =of file being returned.`;
+    method = Methods.get;
+    path = HTTPManagementRoutes.static;
+    tags = [APITags.management];
+    handler = async (req, res) => {
         const { pathname } = req.parsed;
         const fileCache = pathMap.get(pathname);
         if (fileCache) {
             return streamFile(res, fileCache.path, fileCache.contentType);
         }
-        if (!getConfig) {
-            throw new ServerError(`Couldn't load configuration for request`);
-        }
-        const config = getConfig();
+        const config = this.config();
         const file = path.join(config.getStatic(), pathname);
         const indexFile = path.join(file, 'index.html');
         const filePath = (await Promise.all([
@@ -59,9 +58,5 @@ const route = {
             path: filePath,
         });
         return streamFile(res, filePath, contentType);
-    },
-    method: Methods.get,
-    path: HTTPManagementRoutes.static,
-    tags: [APITags.management],
-};
-export default route;
+    };
+}

package/build/routes/webkit/ws/playwright-webkit.d.ts

@@ -1,6 +1,16 @@
-import { BrowserServerOptions, BrowserWebsocketRoute, SystemQueryParameters } from '@browserless.io/browserless';
+/// <reference types="node" />
+/// <reference types="node" />
+import { APITags, BrowserServerOptions, BrowserWebsocketRoute, PlaywrightWebkit, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
+import { Duplex } from 'stream';
 export interface QuerySchema extends SystemQueryParameters {
     launch?: BrowserServerOptions | string;
 }
-declare const route: BrowserWebsocketRoute;
-export default route;
+export default class PlaywrightWebkitRoute extends BrowserWebsocketRoute {
+    auth: boolean;
+    browser: typeof PlaywrightWebkit;
+    concurrency: boolean;
+    description: string;
+    path: WebsocketRoutes;
+    tags: APITags[];
+    handler: (req: Request, socket: Duplex, head: Buffer, browser: PlaywrightWebkit) => Promise<void>;
+}

package/build/routes/webkit/ws/playwright-webkit.js

@@ -1,10 +1,12 @@
-import { APITags, BadRequest, PlaywrightWebkit, WebsocketRoutes, } from '@browserless.io/browserless';
-const route = {
-    auth: true,
-    browser: PlaywrightWebkit,
-    concurrency: true,
-    description: `Connect to Webkit with any playwright-compliant library.`,
-    handler: async (req, socket, head, browser) => {
+import { APITags, BadRequest, BrowserWebsocketRoute, PlaywrightWebkit, WebsocketRoutes, } from '@browserless.io/browserless';
+export default class PlaywrightWebkitRoute extends BrowserWebsocketRoute {
+    auth = true;
+    browser = PlaywrightWebkit;
+    concurrency = true;
+    description = `Connect to Webkit with any playwright-compliant library.`;
+    path = WebsocketRoutes.playwrightWebkit;
+    tags = [APITags.browserWS];
+    handler = async (req, socket, head, browser) => {
         const isPlaywright = req.headers['user-agent']
             ?.toLowerCase()
             .includes('playwright');
@@ -12,8 +14,5 @@ const route = {
             throw new BadRequest(`Only playwright is allowed to work with this route`);
         }
         return browser.proxyWebSocket(req, socket, head);
-    },
-    path: WebsocketRoutes.playwrightWebkit,
-    tags: [APITags.browserWS],
-};
-export default route;
+    };
+}

package/build/server.js

@@ -172,7 +172,6 @@ export class HTTPServer {
             if (e instanceof Timeout) {
                 return writeResponse(res, 408, e.message);
             }
-            this.log(`Error handling request at "${route.path}": ${e}`);
             return writeResponse(res, 500, e.toString());
         });
     };

package/build/types.d.ts

@@ -47,7 +47,14 @@ export interface BrowserJSON {
  * the request object, that produces the launch options.
  */
 type defaultLaunchOptions = CDPLaunchOptions | BrowserlessLaunch | ((req: Request) => CDPLaunchOptions | BrowserlessLaunch);
-interface Route {
+declare abstract class Route {
+    protected _browserManager: Browserless['browserManager'];
+    protected _config: Browserless['config'];
+    protected _fileSystem: Browserless['fileSystem'];
+    protected _debug: Browserless['debug'];
+    protected _metrics: Browserless['metrics'];
+    protected _monitoring: Browserless['monitoring'];
+    constructor(_browserManager: Browserless['browserManager'], _config: Browserless['config'], _fileSystem: Browserless['fileSystem'], _debug: Browserless['debug'], _metrics: Browserless['metrics'], _monitoring: Browserless['monitoring']);
     /**
      * A boolean, or a function that returns a boolean, on
      * whether the route requires an API token to access.
@@ -59,6 +66,18 @@ interface Route {
      * automatically if your route defines a BodySchema type.
      */
     bodySchema?: unknown;
+    /**
+     * The query parameters accepted by the route, defined in
+     * an object format. This is auto-generated for you if your
+     * route defines and exports a QuerySchema type.
+     */
+    querySchema?: unknown;
+    /**
+     * The structure of the routes response when successful. This
+     * is auto-generated for you if your route defines a ResponseSchema
+     * type and exports it in your route.
+     */
+    responseSchema?: unknown;
     /**
      * Whether the route should be bound by the global
      * concurrency limit defined in your configuration.
@@ -68,142 +87,133 @@ interface Route {
      * Description of the route and what it does. This description
      * is then used in the embedded documentation site.
      */
-    description: string;
+    description?: string;
     /**
      * Helper function to load the browser-manager instance. Defined
      * and injected by browserless after initialization.
      * @returns BrowserManager
      */
-    getBrowserManager?: () => Browserless['browserManager'];
+    browserManager: () => import("@browserless.io/browserless").BrowserManager;
     /**
      * Helper function that loads the config module. Defined and injected by
      * browserless after initialization.
      * @returns Config
      */
-    getConfig?: () => Browserless['config'];
+    config: () => Config;
     /**
      * Helper function that loads the debug module, useful
      * for logging messages scoped to the routes path. Defined
      * and injected by browserless after initialization.
      * @returns Debug
      */
-    getDebug?: () => debug.Debugger;
+    debug: () => import("debug").Debugger;
     /**
      * Helper function that loads the file-system module
      * for interacting with file-systems. Defined and injected by
      * browserless after initialization.
      * @returns FileSystem
      */
-    getFileSystem?: () => Browserless['fileSystem'];
+    fileSystem: () => import("@browserless.io/browserless").FileSystem;
     /**
      * Helper function that loads the metrics module for
      * collecting and aggregating statistics. Defined and injected by
      * browserless after initialization.
      * @returns Metrics
      */
-    getMetrics?: () => Browserless['metrics'];
+    metrics: () => Metrics;
     /**
      * Helper function that loads the monitoring module useful
      * for monitoring system health. Defined and injected by
      * browserless after initialization.
      * @returns Monitor
      */
-    getMonitoring?: () => Browserless['monitoring'];
+    monitoring: () => import("@browserless.io/browserless").Monitoring;
     /**
      * The HTTP path that this route handles, eg '/my-route'
      */
-    path: HTTPRoutes | WebsocketRoutes | HTTPManagementRoutes | string;
-    /**
-     * The query parameters accepted by the route, defined in
-     * an object format. This is auto-generated for you if your
-     * route defines and exports a QuerySchema type.
-     */
-    querySchema?: unknown;
-    /**
-     * The structure of the routes response when successful. This
-     * is auto-generated for you if your route defines a ResponseSchema
-     * type and exports it in your route.
-     */
-    responseSchema?: unknown;
+    abstract path: HTTPRoutes | WebsocketRoutes | HTTPManagementRoutes | string;
     /**
      * The tag(s) for the route to categorize it in the
      * documentation portal
      */
-    tags: APITags[];
+    abstract tags: APITags[];
 }
 /**
  * A primitive HTTP-based route that doesn't require a
  * browser in order to fulfill requests. Used by downstream HTTPRoute
  * and WebSocketRoute
  */
-interface BasicHTTPRoute extends Route {
+declare abstract class BasicHTTPRoute extends Route {
     /**
      * The allowed Content-Types that this route can read and handle.
      * If a request comes in with a Content-Type of 'application/json', then
      * this accepts would need to include ["application/json"] in order to not 404
      */
-    accepts: Array<contentTypes>;
+    abstract accepts: Array<contentTypes>;
     /**
      * The Content-Types that this route will will respond with, and must match the Accepts
      * Header from a client if present. If a request comes in with an Accepts of "application/json"
      * then the contentTypes here would need to include ["application/json"] in order to not 404.
      */
-    contentTypes: Array<contentTypes>;
+    abstract contentTypes: Array<contentTypes>;
     /**
      * The allowed methods ("GET", "POST", etc) this route can utilize and match against.
      */
-    method: Methods;
+    abstract method: Methods;
 }
 /**
  * A HTTP-based route, with a handler, that can fulfill requests without
  * a browser required.
  */
-export interface HTTPRoute extends BasicHTTPRoute {
-    browser: null;
+export declare abstract class HTTPRoute extends BasicHTTPRoute {
     /**
      * Handles an inbound HTTP request, and supplies the Request and Response objects from node's HTTP request event
      */
-    handler: (req: Request, res: http.ServerResponse) => Promise<unknown>;
+    abstract handler: (req: Request, res: http.ServerResponse) => Promise<unknown>;
 }
 /**
  * A HTTP-based route, with a handler, that can fulfill requests but
  * requires a browser in order to do so. Handler will then be called
  * with a 3rd argument of the browser class specified.
  */
-export interface BrowserHTTPRoute extends BasicHTTPRoute {
-    browser: BrowserClasses;
+export declare abstract class BrowserHTTPRoute extends BasicHTTPRoute {
     defaultLaunchOptions?: defaultLaunchOptions;
+    abstract browser: BrowserClasses;
     /**
      * Handles an inbound HTTP request with a 3rd param of the predefined
      * browser used for the route -- only Chrome CDP is support currently.
      */
-    handler: (req: Request, res: http.ServerResponse, browser: BrowserInstance) => Promise<unknown>;
-    onNewPage?: undefined;
+    abstract handler: (req: Request, res: http.ServerResponse, browser: BrowserInstance) => Promise<unknown>;
+    /**
+     * An optional function to automatically set up or handle new page
+     * creation. Useful for injecting behaviors or other functionality.
+     */
+    onNewPage?: (url: URL, page: Page) => Promise<void>;
 }
 /**
  * A WebSocket-based route, with a handler, that can fulfill requests
  * that do not require a browser in order to operate.
  */
-export interface WebSocketRoute extends Route {
+export declare abstract class WebSocketRoute extends Route {
     browser: null;
     /**
      * Handles an inbound Websocket request, and handles the connection
      */
-    handler: (req: Request, socket: stream.Duplex, head: Buffer) => Promise<unknown>;
+    abstract handler: (req: Request, socket: stream.Duplex, head: Buffer) => Promise<unknown>;
 }
 /**
  * A WebSocket-based route, with a handler, that can fulfill requests
  * that need a browser. Handler is called with an additional argument of
  * browser (the browser class required to run the route).
  */
-export interface BrowserWebsocketRoute extends Route {
-    browser: BrowserClasses;
+export declare abstract class BrowserWebsocketRoute extends Route {
+    abstract browser: BrowserClasses;
     defaultLaunchOptions?: defaultLaunchOptions;
     /**
      * Handles an inbound Websocket request, and handles the connection
      * with the prior set browser being injected.
      */
-    handler(req: Request, socket: stream.Duplex, head: Buffer, browser: BrowserInstance): Promise<unknown>;
+    abstract handler(req: Request, socket: stream.Duplex, head: Buffer, browser: BrowserInstance): Promise<unknown>;
     /**
      * An optional function to automatically set up or handle new page
      * creation. Useful for injecting behaviors or other functionality.

package/build/types.js

@@ -1,3 +1,138 @@
+class Route {
+    _browserManager;
+    _config;
+    _fileSystem;
+    _debug;
+    _metrics;
+    _monitoring;
+    constructor(_browserManager, _config, _fileSystem, _debug, _metrics, _monitoring) {
+        this._browserManager = _browserManager;
+        this._config = _config;
+        this._fileSystem = _fileSystem;
+        this._debug = _debug;
+        this._metrics = _metrics;
+        this._monitoring = _monitoring;
+    }
+    /**
+     * A boolean, or a function that returns a boolean, on
+     * whether the route requires an API token to access.
+     */
+    auth = true;
+    /**
+     * The schematic of the submitted BODY (typically)
+     * an object when the route is json-based. This is generated
+     * automatically if your route defines a BodySchema type.
+     */
+    bodySchema;
+    /**
+     * The query parameters accepted by the route, defined in
+     * an object format. This is auto-generated for you if your
+     * route defines and exports a QuerySchema type.
+     */
+    querySchema;
+    /**
+     * The structure of the routes response when successful. This
+     * is auto-generated for you if your route defines a ResponseSchema
+     * type and exports it in your route.
+     */
+    responseSchema;
+    /**
+     * Whether the route should be bound by the global
+     * concurrency limit defined in your configuration.
+     */
+    concurrency = true;
+    /**
+     * Description of the route and what it does. This description
+     * is then used in the embedded documentation site.
+     */
+    description;
+    /**
+     * Helper function to load the browser-manager instance. Defined
+     * and injected by browserless after initialization.
+     * @returns BrowserManager
+     */
+    browserManager = () => this._browserManager;
+    /**
+     * Helper function that loads the config module. Defined and injected by
+     * browserless after initialization.
+     * @returns Config
+     */
+    config = () => this._config;
+    /**
+     * Helper function that loads the debug module, useful
+     * for logging messages scoped to the routes path. Defined
+     * and injected by browserless after initialization.
+     * @returns Debug
+     */
+    debug = () => this._debug;
+    /**
+     * Helper function that loads the file-system module
+     * for interacting with file-systems. Defined and injected by
+     * browserless after initialization.
+     * @returns FileSystem
+     */
+    fileSystem = () => this._fileSystem;
+    /**
+     * Helper function that loads the metrics module for
+     * collecting and aggregating statistics. Defined and injected by
+     * browserless after initialization.
+     * @returns Metrics
+     */
+    metrics = () => this._metrics;
+    /**
+     * Helper function that loads the monitoring module useful
+     * for monitoring system health. Defined and injected by
+     * browserless after initialization.
+     * @returns Monitor
+     */
+    monitoring = () => this._monitoring;
+}
+/**
+ * A primitive HTTP-based route that doesn't require a
+ * browser in order to fulfill requests. Used by downstream HTTPRoute
+ * and WebSocketRoute
+ */
+class BasicHTTPRoute extends Route {
+}
+/**
+ * A HTTP-based route, with a handler, that can fulfill requests without
+ * a browser required.
+ */
+export class HTTPRoute extends BasicHTTPRoute {
+}
+/**
+ * A HTTP-based route, with a handler, that can fulfill requests but
+ * requires a browser in order to do so. Handler will then be called
+ * with a 3rd argument of the browser class specified.
+ */
+export class BrowserHTTPRoute extends BasicHTTPRoute {
+    defaultLaunchOptions;
+    /**
+     * An optional function to automatically set up or handle new page
+     * creation. Useful for injecting behaviors or other functionality.
+     */
+    onNewPage;
+}
+/**
+ * A WebSocket-based route, with a handler, that can fulfill requests
+ * that do not require a browser in order to operate.
+ */
+export class WebSocketRoute extends Route {
+    browser = null;
+}
+/**
+ * A WebSocket-based route, with a handler, that can fulfill requests
+ * that need a browser. Handler is called with an additional argument of
+ * browser (the browser class required to run the route).
+ */
+export class BrowserWebsocketRoute extends Route {
+    defaultLaunchOptions;
+    /**
+     * An optional function to automatically set up or handle new page
+     * creation. Useful for injecting behaviors or other functionality.
+     */
+    onNewPage;
+}
 export const debugScreenshotOpts = {
     encoding: 'base64',
     fullPage: true,

package/extensions/ublock/1p-filters.html

@@ -53,7 +53,6 @@
 <script src="js/vapi.js"></script>
 <script src="js/vapi-common.js"></script>
 <script src="js/vapi-client.js"></script>
-<script src="js/vapi-client-extra.js"></script>
 
 <script src="js/codemirror/search.js" type="module"></script>
 <script src="js/codemirror/search-thread.js"></script>