@aluvia/sdk 1.4.0 → 2.0.0

package/dist/cjs/session/lock.js

@@ -47,12 +47,48 @@ const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
 const LOCK_DIR = path.join(os.tmpdir(), 'aluvia-sdk');
 const ADJECTIVES = [
-    'swift', 'bold', 'calm', 'keen', 'warm', 'bright', 'silent', 'rapid', 'steady', 'clever',
-    'vivid', 'agile', 'noble', 'lucid', 'crisp', 'gentle', 'fierce', 'nimble', 'sturdy', 'witty',
+    'swift',
+    'bold',
+    'calm',
+    'keen',
+    'warm',
+    'bright',
+    'silent',
+    'rapid',
+    'steady',
+    'clever',
+    'vivid',
+    'agile',
+    'noble',
+    'lucid',
+    'crisp',
+    'gentle',
+    'fierce',
+    'nimble',
+    'sturdy',
+    'witty',
 ];
 const NOUNS = [
-    'falcon', 'tiger', 'river', 'maple', 'coral', 'cedar', 'orbit', 'prism', 'flint', 'spark',
-    'ridge', 'ember', 'crane', 'grove', 'stone', 'brook', 'drift', 'crest', 'sage', 'lynx',
+    'falcon',
+    'tiger',
+    'river',
+    'maple',
+    'coral',
+    'cedar',
+    'orbit',
+    'prism',
+    'flint',
+    'spark',
+    'ridge',
+    'ember',
+    'crane',
+    'grove',
+    'stone',
+    'brook',
+    'drift',
+    'crest',
+    'sage',
+    'lynx',
 ];
 function lockFileName(sessionName) {
     return `cli-${sessionName ?? 'default'}.lock`;

package/dist/esm/api/apiUtils.js

@@ -14,7 +14,10 @@ export function asErrorEnvelope(value) {
     const message = error['message'];
     if (typeof code !== 'string' || typeof message !== 'string')
         return null;
-    return { success: false, error: { code, message, details: error['details'] } };
+    return {
+        success: false,
+        error: { code, message, details: error['details'] },
+    };
 }
 export function formatErrorDetails(details) {
     if (details == null)

package/dist/esm/client/AluviaClient.js

@@ -1,12 +1,12 @@
 // AluviaClient - Main public class for Aluvia Client
-import { ConfigManager } from "./ConfigManager.js";
-import { ProxyServer } from "./ProxyServer.js";
-import { ApiError, MissingApiKeyError } from "../errors.js";
-import { createNodeProxyAgents, createUndiciDispatcher, createUndiciFetch, toAxiosConfig, toGotOptions, toPlaywrightProxySettings, toPuppeteerArgs, toSeleniumArgs, } from "./adapters.js";
-import { Logger } from "./logger.js";
-import { AluviaApi } from "../api/AluviaApi.js";
-import { BlockDetection, } from "./BlockDetection.js";
-import * as net from "node:net";
+import { ConfigManager } from './ConfigManager.js';
+import { ProxyServer } from './ProxyServer.js';
+import { ApiError, MissingApiKeyError } from '../errors.js';
+import { createNodeProxyAgents, createUndiciDispatcher, createUndiciFetch, toAxiosConfig, toGotOptions, toPlaywrightProxySettings, toPuppeteerArgs, toSeleniumArgs, } from './adapters.js';
+import { Logger } from './logger.js';
+import { AluviaApi } from '../api/AluviaApi.js';
+import { BlockDetection } from './BlockDetection.js';
+import * as net from 'node:net';
 /**
  * AluviaClient is the main entry point for the Aluvia Client.
  *
@@ -25,9 +25,9 @@ export class AluviaClient {
         this.pageStates = new WeakMap();
         /** Promise-based mutex to serialize handleDetectionResult's critical section. */
         this._detectionMutex = Promise.resolve();
-        const apiKey = String(options.apiKey ?? "").trim();
+        const apiKey = String(options.apiKey ?? '').trim();
         if (!apiKey) {
-            throw new MissingApiKeyError("Aluvia apiKey is required");
+            throw new MissingApiKeyError('Aluvia apiKey is required');
         }
         const strict = options.strict ?? true;
         this.options = { ...options, apiKey, strict };
@@ -35,12 +35,12 @@ export class AluviaClient {
         if (connectionId !== undefined && !Number.isFinite(connectionId)) {
             throw new Error('connectionId must be a finite number');
         }
-        const apiBaseUrl = options.apiBaseUrl ?? "https://api.aluvia.io/v1";
+        const apiBaseUrl = options.apiBaseUrl ?? 'https://api.aluvia.io/v1';
         const pollIntervalMs = Math.max(options.pollIntervalMs ?? 5000, 1000);
         const timeoutMs = options.timeoutMs;
-        const gatewayProtocol = options.gatewayProtocol ?? "http";
-        const gatewayPort = options.gatewayPort ?? (gatewayProtocol === "https" ? 8443 : 8080);
-        const logLevel = options.logLevel ?? "info";
+        const gatewayProtocol = options.gatewayProtocol ?? 'http';
+        const gatewayPort = options.gatewayPort ?? (gatewayProtocol === 'https' ? 8443 : 8080);
+        const logLevel = options.logLevel ?? 'info';
         this.logger = new Logger(logLevel);
         // Create ConfigManager
         this.configManager = new ConfigManager({
@@ -62,7 +62,7 @@ export class AluviaClient {
         });
         // Initialize block detection if configured
         if (options.blockDetection !== undefined || options.startPlaywright) {
-            this.logger.debug("Initializing block detection");
+            this.logger.debug('Initializing block detection');
             const detectionConfig = options.blockDetection ?? { enabled: true };
             this.blockDetection = new BlockDetection(detectionConfig, this.logger);
         }
@@ -79,10 +79,9 @@ export class AluviaClient {
         };
         this.pageStates.set(page, pageState);
         // Capture navigation responses on main frame
-        page.on("response", (response) => {
+        page.on('response', (response) => {
             try {
-                if (response.request().isNavigationRequest() &&
-                    response.request().frame() === page.mainFrame()) {
+                if (response.request().isNavigationRequest() && response.request().frame() === page.mainFrame()) {
                     pageState.lastResponse = response;
                     pageState.skipFullPass = false;
                     pageState.fastResult = null;
@@ -93,7 +92,7 @@ export class AluviaClient {
             }
         });
         // Fast pass at domcontentloaded
-        page.on("domcontentloaded", async () => {
+        page.on('domcontentloaded', async () => {
             if (!this.blockDetection)
                 return;
             try {
@@ -110,13 +109,13 @@ export class AluviaClient {
             }
         });
         // Full pass at load
-        page.on("load", async () => {
+        page.on('load', async () => {
             if (!this.blockDetection || pageState.skipFullPass)
                 return;
             try {
                 // Wait for networkidle with timeout cap
                 try {
-                    await page.waitForLoadState("networkidle", {
+                    await page.waitForLoadState('networkidle', {
                         timeout: this.blockDetection.getNetworkIdleTimeoutMs(),
                     });
                 }
@@ -132,7 +131,7 @@ export class AluviaClient {
             }
         });
         // SPA detection via framenavigated
-        page.on("framenavigated", async (frame) => {
+        page.on('framenavigated', async (frame) => {
             if (!this.blockDetection)
                 return;
             try {
@@ -161,14 +160,14 @@ export class AluviaClient {
      * Attaches page listeners to all existing and future pages in a context.
      */
     attachBlockDetectionListener(context) {
-        this.logger.debug("Attaching block detection listener to context");
+        this.logger.debug('Attaching block detection listener to context');
         // Attach to existing pages
         try {
             const existingPages = context.pages();
             for (const page of existingPages) {
                 this.attachPageListeners(page);
                 // Check if page has already loaded (not about:blank)
-                if (page.url() !== "about:blank" && this.blockDetection) {
+                if (page.url() !== 'about:blank' && this.blockDetection) {
                     this.blockDetection
                         .analyzeFull(page, null)
                         .then((result) => {
@@ -184,7 +183,7 @@ export class AluviaClient {
             // Ignore errors
         }
         // Attach to future pages
-        context.on("page", (page) => {
+        context.on('page', (page) => {
             this.logger.debug(`New page detected: ${page.url()}`);
             this.attachPageListeners(page);
         });
@@ -218,15 +217,16 @@ export class AluviaClient {
         if (!this.blockDetection.isAutoUnblock())
             return;
         // Check if auto-reload should fire for this blockStatus
-        const shouldReload = result.blockStatus === "blocked" ||
-            (result.blockStatus === "suspected" &&
-                this.blockDetection.isAutoUnblockOnSuspected());
+        const shouldReload = result.blockStatus === 'blocked' ||
+            (result.blockStatus === 'suspected' && this.blockDetection.isAutoUnblockOnSuspected());
         if (!shouldReload)
             return;
         // Serialize the critical section: persistent-block state, rule updates, reload.
         // This prevents concurrent handlers from reading stale retriedUrls/persistentHostnames.
         let release;
-        const gate = new Promise((resolve) => { release = resolve; });
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
         const acquired = this._detectionMutex;
         this._detectionMutex = this._detectionMutex.then(() => gate);
         await acquired;
@@ -302,9 +302,7 @@ export class AluviaClient {
         this.startPromise = (async () => {
             // Fetch initial configuration (may throw InvalidApiKeyError or ApiError)
             await this.configManager.init();
-            const browserInstance = this.options.startPlaywright
-                ? await this._initPlaywright()
-                : undefined;
+            const browserInstance = this.options.startPlaywright ? await this._initPlaywright() : undefined;
             // Keep config fresh so routing decisions update without restarting.
             this.configManager.startPolling();
             try {
@@ -329,10 +327,10 @@ export class AluviaClient {
                     if (!d)
                         return;
                     try {
-                        if (typeof d.close === "function") {
+                        if (typeof d.close === 'function') {
                             await d.close();
                         }
-                        else if (typeof d.destroy === "function") {
+                        else if (typeof d.destroy === 'function') {
                             d.destroy();
                         }
                     }
@@ -510,20 +508,20 @@ export class AluviaClient {
      */
     async _initPlaywright() {
         try {
-            const pw = await import("playwright");
+            const pw = await import('playwright');
             // @ts-ignore
             return pw.chromium;
         }
         catch {
             // Playwright not installed — attempt auto-install
-            this.logger.info("Playwright not found. Installing playwright...");
-            const { execSync } = await import("node:child_process");
+            this.logger.info('Playwright not found. Installing playwright...');
+            const { execSync } = await import('node:child_process');
             try {
-                execSync("npm install playwright", {
-                    stdio: "inherit",
+                execSync('npm install playwright', {
+                    stdio: 'inherit',
                     cwd: process.cwd(),
                 });
-                const pw = await import("playwright");
+                const pw = await import('playwright');
                 // @ts-ignore
                 return pw.chromium;
             }

package/dist/esm/client/BlockDetection.js

@@ -1,46 +1,35 @@
 // BlockDetection - Website block detection with weighted scoring
 const DEFAULT_CHALLENGE_SELECTORS = [
-    "#challenge-form",
-    "#challenge-running",
-    ".cf-browser-verification",
+    '#challenge-form',
+    '#challenge-running',
+    '.cf-browser-verification',
     'iframe[src*="recaptcha"]',
-    ".g-recaptcha",
-    "#px-captcha",
+    '.g-recaptcha',
+    '#px-captcha',
     'iframe[src*="hcaptcha"]',
-    ".h-captcha",
+    '.h-captcha',
 ];
 const TITLE_KEYWORDS = [
-    "access denied",
-    "blocked",
-    "forbidden",
-    "security check",
-    "attention required",
-    "just a moment",
-];
-const STRONG_TEXT_KEYWORDS = [
-    "captcha",
-    "access denied",
-    "verify you are human",
-    "bot detection",
-];
-const WEAK_TEXT_KEYWORDS = [
-    "blocked",
-    "forbidden",
-    "cloudflare",
-    "please verify",
-    "unusual activity",
+    'access denied',
+    'blocked',
+    'forbidden',
+    'security check',
+    'attention required',
+    'just a moment',
 ];
+const STRONG_TEXT_KEYWORDS = ['captcha', 'access denied', 'verify you are human', 'bot detection'];
+const WEAK_TEXT_KEYWORDS = ['blocked', 'forbidden', 'cloudflare', 'please verify', 'unusual activity'];
 function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 const WEAK_TEXT_REGEXES = WEAK_TEXT_KEYWORDS.map((keyword) => ({
     keyword,
-    regex: new RegExp("\\b" + escapeRegex(keyword) + "\\b", "i"),
+    regex: new RegExp('\\b' + escapeRegex(keyword) + '\\b', 'i'),
 }));
 const CHALLENGE_DOMAIN_PATTERNS = [
-    "/cdn-cgi/challenge-platform/",
-    "challenges.cloudflare.com",
-    "geo.captcha-delivery.com",
+    '/cdn-cgi/challenge-platform/',
+    'challenges.cloudflare.com',
+    'geo.captcha-delivery.com',
 ];
 /**
  * BlockDetection handles detection of website blocks, CAPTCHAs, and WAF challenges
@@ -84,9 +73,9 @@ export class BlockDetection {
     // --- Scoring Engine ---
     computeScore(signals) {
         if (signals.length === 0)
-            return { score: 0, blockStatus: "clear" };
+            return { score: 0, blockStatus: 'clear' };
         const score = 1 - signals.reduce((product, s) => product * (1 - s.weight), 1);
-        const blockStatus = score >= 0.7 ? "blocked" : score >= 0.4 ? "suspected" : "clear";
+        const blockStatus = score >= 0.7 ? 'blocked' : score >= 0.4 ? 'suspected' : 'clear';
         return { score, blockStatus };
     }
     // --- Fast-pass Signal Detectors ---
@@ -99,15 +88,15 @@ export class BlockDetection {
                 name: `http_status_${status}`,
                 weight: 0.85,
                 details: `HTTP ${status} response`,
-                source: "fast",
+                source: 'fast',
             };
         }
         if (status === 503) {
             return {
-                name: "http_status_503",
+                name: 'http_status_503',
                 weight: 0.6,
-                details: "HTTP 503 response",
-                source: "fast",
+                details: 'HTTP 503 response',
+                source: 'fast',
             };
         }
         return null;
@@ -118,23 +107,22 @@ export class BlockDetection {
             return signals;
         try {
             const headers = response.headers?.() ?? {};
-            const cfMitigated = headers["cf-mitigated"];
-            if (cfMitigated &&
-                cfMitigated.toLowerCase().includes("challenge")) {
+            const cfMitigated = headers['cf-mitigated'];
+            if (cfMitigated && cfMitigated.toLowerCase().includes('challenge')) {
                 signals.push({
-                    name: "waf_header_cf_mitigated",
+                    name: 'waf_header_cf_mitigated',
                     weight: 0.9,
                     details: `cf-mitigated: ${cfMitigated}`,
-                    source: "fast",
+                    source: 'fast',
                 });
             }
-            const server = headers["server"];
-            if (server && server.toLowerCase().includes("cloudflare")) {
+            const server = headers['server'];
+            if (server && server.toLowerCase().includes('cloudflare')) {
                 signals.push({
-                    name: "waf_header_cloudflare",
+                    name: 'waf_header_cloudflare',
                     weight: 0.1,
                     details: `server: ${server}`,
-                    source: "fast",
+                    source: 'fast',
                 });
             }
         }
@@ -150,10 +138,10 @@ export class BlockDetection {
             for (const keyword of this.allTitleKeywords) {
                 if (title.includes(keyword.toLowerCase())) {
                     return {
-                        name: "title_keyword",
+                        name: 'title_keyword',
                         weight: 0.8,
                         details: `Title contains "${keyword}"`,
-                        source: "full",
+                        source: 'full',
                     };
                 }
             }
@@ -175,10 +163,10 @@ export class BlockDetection {
             }, selectors);
             if (found) {
                 return {
-                    name: "challenge_selector",
+                    name: 'challenge_selector',
                     weight: 0.8,
                     details: `Challenge selector found: ${found}`,
-                    source: "full",
+                    source: 'full',
                 };
             }
         }
@@ -191,30 +179,27 @@ export class BlockDetection {
         const signals = [];
         try {
             const text = useInnerText
-                ? await page.evaluate(() => document.body?.innerText ?? "")
-                : await page.evaluate(() => document.body?.textContent ?? "");
+                ? await page.evaluate(() => document.body?.innerText ?? '')
+                : await page.evaluate(() => document.body?.textContent ?? '');
             const textLower = text.toLowerCase();
             if (text.length < 50) {
                 signals.push({
-                    name: "visible_text_short",
+                    name: 'visible_text_short',
                     weight: 0.2,
                     details: `Visible text very short (${text.length} chars)`,
-                    source: "full",
+                    source: 'full',
                 });
             }
             // Strong keywords (substring match, short page < 500 chars)
             if (text.length < 500) {
-                const allStrong = [
-                    ...STRONG_TEXT_KEYWORDS,
-                    ...this.config.extraKeywords,
-                ];
+                const allStrong = [...STRONG_TEXT_KEYWORDS, ...this.config.extraKeywords];
                 for (const keyword of allStrong) {
                     if (textLower.includes(keyword.toLowerCase())) {
                         signals.push({
-                            name: "visible_text_keyword_strong",
+                            name: 'visible_text_keyword_strong',
                             weight: 0.6,
                             details: `Strong keyword "${keyword}" on short page`,
-                            source: "full",
+                            source: 'full',
                         });
                         break;
                     }
@@ -224,10 +209,10 @@ export class BlockDetection {
             for (const { keyword, regex } of WEAK_TEXT_REGEXES) {
                 if (regex.test(text)) {
                     signals.push({
-                        name: "visible_text_keyword_weak",
+                        name: 'visible_text_keyword_weak',
                         weight: 0.15,
                         details: `Weak keyword "${keyword}" found with word boundary`,
-                        source: "full",
+                        source: 'full',
                     });
                     break;
                 }
@@ -241,17 +226,16 @@ export class BlockDetection {
     async detectTextToHtmlRatio(page) {
         try {
             const result = await page.evaluate(() => {
-                const html = document.documentElement?.outerHTML ?? "";
-                const text = document.body?.textContent ?? "";
+                const html = document.documentElement?.outerHTML ?? '';
+                const text = document.body?.textContent ?? '';
                 return { htmlLength: html.length, textLength: text.length };
             });
-            if (result.htmlLength >= 1000 &&
-                result.textLength / result.htmlLength < 0.03) {
+            if (result.htmlLength >= 1000 && result.textLength / result.htmlLength < 0.03) {
                 return {
-                    name: "low_text_ratio",
+                    name: 'low_text_ratio',
                     weight: 0.2,
                     details: `Low text/HTML ratio: ${result.textLength}/${result.htmlLength}`,
-                    source: "full",
+                    source: 'full',
                 };
             }
         }
@@ -275,7 +259,7 @@ export class BlockDetection {
                     break;
                 const redirectResponse = redirectedFrom.response?.();
                 hops.push({
-                    url: redirectedFrom.url?.() ?? "",
+                    url: redirectedFrom.url?.() ?? '',
                     statusCode: redirectResponse?.status?.() ?? 0,
                 });
                 req = redirectedFrom;
@@ -288,24 +272,24 @@ export class BlockDetection {
                 for (const pattern of CHALLENGE_DOMAIN_PATTERNS) {
                     if (hop.url.includes(pattern)) {
                         signals.push({
-                            name: "redirect_to_challenge",
+                            name: 'redirect_to_challenge',
                             weight: 0.7,
                             details: `Redirect through challenge domain: ${hop.url}`,
-                            source: "full",
+                            source: 'full',
                         });
                         return { signals, chain };
                     }
                 }
             }
             // Also check the final response URL
-            const finalUrl = response.url?.() ?? "";
+            const finalUrl = response.url?.() ?? '';
             for (const pattern of CHALLENGE_DOMAIN_PATTERNS) {
                 if (finalUrl.includes(pattern)) {
                     signals.push({
-                        name: "redirect_to_challenge",
+                        name: 'redirect_to_challenge',
                         weight: 0.7,
                         details: `Final URL is challenge domain: ${finalUrl}`,
-                        source: "full",
+                        source: 'full',
                     });
                     break;
                 }
@@ -322,7 +306,7 @@ export class BlockDetection {
                 const meta = document.querySelector('meta[http-equiv="refresh"]');
                 if (!meta)
                     return null;
-                const content = meta.getAttribute("content") ?? "";
+                const content = meta.getAttribute('content') ?? '';
                 const match = content.match(/url\s*=\s*(.+)/i);
                 return match ? match[1].trim() : null;
             });
@@ -330,10 +314,10 @@ export class BlockDetection {
                 for (const pattern of CHALLENGE_DOMAIN_PATTERNS) {
                     if (refreshUrl.includes(pattern)) {
                         return {
-                            name: "meta_refresh_challenge",
+                            name: 'meta_refresh_challenge',
                             weight: 0.65,
                             details: `Meta refresh to challenge URL: ${refreshUrl}`,
-                            source: "full",
+                            source: 'full',
                         };
                     }
                 }
@@ -353,7 +337,7 @@ export class BlockDetection {
         const url = page.url();
         const hostname = this.extractHostname(url);
         if (!this.config.enabled) {
-            return this.makeResult(url, hostname, [], "fast", []);
+            return this.makeResult(url, hostname, [], 'fast', []);
         }
         const signals = [];
         const statusSignal = this.detectHttpStatus(response);
@@ -361,7 +345,7 @@ export class BlockDetection {
             signals.push(statusSignal);
         const headerSignals = this.detectResponseHeaders(response);
         signals.push(...headerSignals);
-        const result = this.makeResult(url, hostname, signals, "fast", []);
+        const result = this.makeResult(url, hostname, signals, 'fast', []);
         this.logResult(result);
         return result;
     }
@@ -396,12 +380,10 @@ export class BlockDetection {
         const url = page.url();
         const hostname = this.extractHostname(url);
         if (!this.config.enabled) {
-            return this.makeResult(url, hostname, [], "full", []);
+            return this.makeResult(url, hostname, [], 'full', []);
         }
         // Start with fast-pass signals
-        const signals = fastResult
-            ? [...fastResult.signals]
-            : [];
+        const signals = fastResult ? [...fastResult.signals] : [];
         // If no fast pass was done and we have a response, run fast detectors
         if (!fastResult && response) {
             const statusSignal = this.detectHttpStatus(response);
@@ -410,7 +392,7 @@ export class BlockDetection {
             const headerSignals = this.detectResponseHeaders(response);
             signals.push(...headerSignals);
         }
-        signals.push(...await this.runContentDetectors(page));
+        signals.push(...(await this.runContentDetectors(page)));
         const { signals: redirectSignals, chain } = this.detectRedirectChain(response);
         signals.push(...redirectSignals);
         return this.reEvaluateIfSuspected(page, url, hostname, signals, chain);
@@ -422,7 +404,7 @@ export class BlockDetection {
         const url = page.url();
         const hostname = this.extractHostname(url);
         if (!this.config.enabled) {
-            return this.makeResult(url, hostname, [], "full", []);
+            return this.makeResult(url, hostname, [], 'full', []);
         }
         const signals = await this.runContentDetectors(page);
         return this.reEvaluateIfSuspected(page, url, hostname, signals, []);
@@ -430,14 +412,14 @@ export class BlockDetection {
     async reEvaluateIfSuspected(page, url, hostname, signals, redirectChain) {
         const preliminary = this.computeScore(signals);
         if (preliminary.score >= 0.4 && preliminary.score < 0.7) {
-            const nonTextSignals = signals.filter((s) => !s.name.startsWith("visible_text_"));
+            const nonTextSignals = signals.filter((s) => !s.name.startsWith('visible_text_'));
             const innerTextSignals = await this.detectVisibleText(page, true);
             nonTextSignals.push(...innerTextSignals);
-            const result = this.makeResult(url, hostname, nonTextSignals, "full", redirectChain);
+            const result = this.makeResult(url, hostname, nonTextSignals, 'full', redirectChain);
             this.logResult(result);
             return result;
         }
-        const result = this.makeResult(url, hostname, signals, "full", redirectChain);
+        const result = this.makeResult(url, hostname, signals, 'full', redirectChain);
         this.logResult(result);
         return result;
     }

package/dist/esm/client/rules.js

@@ -56,7 +56,12 @@ export function matchPattern(hostname, pattern) {
  */
 export function normalizeRules(rules) {
     if (!rules || rules.length === 0) {
-        return { positiveRules: [], negativeRules: [], hasCatchAll: false, empty: true };
+        return {
+            positiveRules: [],
+            negativeRules: [],
+            hasCatchAll: false,
+            empty: true,
+        };
     }
     const trimmed = rules
         .filter((r) => typeof r === 'string')
@@ -64,7 +69,12 @@ export function normalizeRules(rules) {
         .filter((r) => r.length > 0)
         .filter((r) => r !== 'auto');
     if (trimmed.length === 0) {
-        return { positiveRules: [], negativeRules: [], hasCatchAll: false, empty: true };
+        return {
+            positiveRules: [],
+            negativeRules: [],
+            hasCatchAll: false,
+            empty: true,
+        };
     }
     const negativeRules = [];
     const positiveRules = [];

package/dist/esm/connect.js

@@ -60,8 +60,8 @@ export async function connect(sessionName) {
     let context;
     let page;
     try {
-        context = browser.contexts()[0] ?? await browser.newContext();
-        page = context.pages()[0] ?? await context.newPage();
+        context = browser.contexts()[0] ?? (await browser.newContext());
+        page = context.pages()[0] ?? (await context.newPage());
     }
     catch (err) {
         await browser.close().catch(() => { });