@jsenv/core 24.3.3 → 24.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "24.3.3",
+  "version": "24.4.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/src/executeTestPlan.js

@@ -36,11 +36,16 @@ export const executeTestPlan = async ({
   cooldownBetweenExecutions,
 
   maxExecutionsInParallel,
-
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
   logSummary = true,
   updateProcessExitCode = true,
+  // stopAfterExecute: true to ensure runtime is stopped once executed
+  // because we have what we wants: execution is completed and
+  // we have associated coverage and capturedConsole
+  // passsing false means all node process and browsers launched stays opened
+  // (can eventually be used for debug)
+  stopAfterExecute = true,
 
   coverage = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
@@ -145,6 +150,7 @@ export const executeTestPlan = async ({
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    stopAfterExecute,
     cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,

package/src/internal/browser_launcher/from_playwright.js

@@ -0,0 +1,314 @@
+// https://github.com/microsoft/playwright/blob/master/docs/api.md
+
+import { createDetailedMessage } from "@jsenv/logger"
+import {
+  Abort,
+  createCallbackListNotifiedOnce,
+  createCallbackList,
+  raceProcessTeardownEvents,
+} from "@jsenv/abort"
+import { memoize } from "@jsenv/filesystem"
+
+import { trackPageToNotify } from "./trackPageToNotify.js"
+import { executeHtmlFile } from "./executeHtmlFile.js"
+
+export const createRuntimeFromPlaywright = ({
+  browserName,
+  browserVersion,
+  coveragePlaywrightAPIAvailable = false,
+  ignoreErrorHook = () => false,
+  transformErrorHook = (error) => error,
+  tab = false,
+}) => {
+  const runtime = {
+    name: browserName,
+    version: browserVersion,
+  }
+
+  let browserAndContextPromise
+  runtime.launch = async ({
+    signal = new AbortController().signal,
+    executablePath,
+    browserServerLogLevel,
+
+    projectDirectoryUrl,
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+
+    collectPerformance,
+    measurePerformance,
+    collectCoverage,
+    coverageIgnorePredicate,
+    coverageForceIstanbul,
+
+    headless = true,
+    stopOnExit = true,
+    ignoreHTTPSErrors = true,
+    stopAfterAllExecutionCallbackList,
+  }) => {
+    const stopCallbackList = createCallbackListNotifiedOnce()
+    const stoppedCallbackList = createCallbackListNotifiedOnce()
+    const errorCallbackList = createCallbackList()
+    const outputCallbackList = createCallbackList()
+
+    const stop = memoize(async (reason) => {
+      await stopCallbackList.notify({ reason })
+      stoppedCallbackList.notify({ reason })
+      return { graceful: false }
+    })
+    const closeBrowser = async () => {
+      const { browser } = await browserAndContextPromise
+      browserAndContextPromise = null
+      await stopBrowser(browser)
+    }
+
+    if (
+      !browserAndContextPromise ||
+      !tab ||
+      !stopAfterAllExecutionCallbackList
+    ) {
+      browserAndContextPromise = (async () => {
+        const browser = await launchBrowserUsingPlaywright({
+          signal,
+          browserName,
+          stopOnExit,
+          playwrightOptions: {
+            headless,
+            executablePath,
+          },
+        })
+        const browserContext = await browser.newContext({ ignoreHTTPSErrors })
+        return { browser, browserContext }
+      })()
+
+      // when using chromium tab during multiple executions we reuse the chromium browser
+      // and only once all executions are done we close the browser
+      if (tab && stopAfterAllExecutionCallbackList) {
+        stopAfterAllExecutionCallbackList.add(async () => {
+          await closeBrowser()
+        })
+      } else {
+        stopCallbackList.add(async () => {
+          await closeBrowser()
+        })
+      }
+    }
+
+    const { browser, browserContext } = await browserAndContextPromise
+    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
+    browser.on("disconnected", () => {
+      stop()
+    })
+
+    const page = await browserContext.newPage()
+    stoppedCallbackList.add(async () => {
+      try {
+        await page.close()
+      } catch (e) {
+        if (isTargetClosedError(e)) {
+          return
+        }
+        throw e
+      }
+    })
+    const stopTrackingToNotify = trackPageToNotify(page, {
+      onError: (error) => {
+        error = transformErrorHook(error)
+        if (!ignoreErrorHook(error)) {
+          errorCallbackList.notify(error)
+        }
+      },
+      onConsole: outputCallbackList.notify,
+    })
+    stoppedCallbackList.add(stopTrackingToNotify)
+
+    const execute = createExecuteHook({
+      page,
+      runtime,
+      browserServerLogLevel,
+
+      projectDirectoryUrl,
+      compileServerOrigin,
+      outDirectoryRelativeUrl,
+
+      collectPerformance,
+      measurePerformance,
+      collectCoverage,
+      coverageIgnorePredicate,
+      coverageForceIstanbul,
+
+      coveragePlaywrightAPIAvailable,
+      transformErrorHook,
+    })
+
+    return {
+      stopCallbackList,
+      stoppedCallbackList,
+      errorCallbackList,
+      outputCallbackList,
+      execute,
+      stop,
+    }
+  }
+  if (!tab) {
+    runtime.tab = createRuntimeFromPlaywright({
+      browserName,
+      browserVersion,
+      coveragePlaywrightAPIAvailable,
+      ignoreErrorHook,
+      transformErrorHook,
+      tab: true,
+    })
+  }
+  return runtime
+}
+
+const stopBrowser = async (browser) => {
+  const disconnected = browser.isConnected()
+    ? new Promise((resolve) => {
+        const disconnectedCallback = () => {
+          browser.removeListener("disconnected", disconnectedCallback)
+          resolve()
+        }
+        browser.on("disconnected", disconnectedCallback)
+      })
+    : Promise.resolve()
+
+  // for some reason without this 100ms timeout
+  // browser.close() never resolves (playwright does not like something)
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  try {
+    await browser.close()
+  } catch (e) {
+    if (isTargetClosedError(e)) {
+      return
+    }
+    throw e
+  }
+  await disconnected
+}
+
+const launchBrowserUsingPlaywright = async ({
+  signal,
+  browserName,
+  stopOnExit,
+  playwrightOptions,
+}) => {
+  const launchBrowserOperation = Abort.startOperation()
+  launchBrowserOperation.addAbortSignal(signal)
+  const playwright = await importPlaywright({ browserName })
+  if (stopOnExit) {
+    launchBrowserOperation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGHUP: true,
+          SIGTERM: true,
+          SIGINT: true,
+          beforeExit: true,
+          exit: true,
+        },
+        abort,
+      )
+    })
+  }
+
+  const browserClass = playwright[browserName]
+  try {
+    const browser = await browserClass.launch({
+      ...playwrightOptions,
+      // let's handle them to close properly browser + remove listener
+      // instead of relying on playwright to do so
+      handleSIGINT: false,
+      handleSIGTERM: false,
+      handleSIGHUP: false,
+    })
+    launchBrowserOperation.throwIfAborted()
+    return browser
+  } catch (e) {
+    if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
+      // rethrow the abort error
+      launchBrowserOperation.throwIfAborted()
+    }
+    throw e
+  } finally {
+    await launchBrowserOperation.end()
+  }
+}
+
+const importPlaywright = async ({ browserName }) => {
+  try {
+    const namespace = await import("playwright")
+    return namespace
+  } catch (e) {
+    if (e.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(
+        createDetailedMessage(
+          `"playwright" not found. You need playwright in your dependencies when using "${browserName}Runtime"`,
+          {
+            suggestion: `npm install --save-dev playwright`,
+          },
+        ),
+        { cause: e },
+      )
+    }
+    throw e
+  }
+}
+
+const createExecuteHook = ({
+  page,
+  runtime,
+  projectDirectoryUrl,
+  compileServerOrigin,
+  compileServerId,
+  outDirectoryRelativeUrl,
+
+  collectPerformance,
+  measurePerformance,
+  collectCoverage,
+  coverageIgnorePredicate,
+  coverageForceIstanbul,
+
+  coveragePlaywrightAPIAvailable,
+  transformErrorHook,
+}) => {
+  const execute = async ({ signal, fileRelativeUrl }) => {
+    const executeOperation = Abort.startOperation()
+    executeOperation.addAbortSignal(signal)
+    executeOperation.throwIfAborted()
+    const result = await executeHtmlFile(fileRelativeUrl, {
+      runtime,
+      executeOperation,
+
+      projectDirectoryUrl,
+      compileServerOrigin,
+      compileServerId,
+      outDirectoryRelativeUrl,
+
+      page,
+      measurePerformance,
+      collectPerformance,
+      collectCoverage,
+      coverageForceIstanbul,
+      coveragePlaywrightAPIAvailable,
+      coverageIgnorePredicate,
+      transformErrorHook,
+    })
+    return result
+  }
+  return execute
+}
+
+const isTargetClosedError = (error) => {
+  if (error.message.match(/Protocol error \(.*?\): Target closed/)) {
+    return true
+  }
+  if (error.message.match(/Protocol error \(.*?\): Browser.*?closed/)) {
+    return true
+  }
+  if (error.message.includes("browserContext.close: Browser closed")) {
+    return true
+  }
+  return false
+}

package/src/internal/executing/executeConcurrently.js

@@ -11,7 +11,7 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
+import { Abort, createCallbackListNotifiedOnce } from "@jsenv/abort"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
@@ -34,6 +34,7 @@ export const executeConcurrently = async (
     defaultMsAllocatedPerExecution = 30000,
     cooldownBetweenExecutions = 0,
     maxExecutionsInParallel = 1,
+    stopAfterExecute,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
 
@@ -137,6 +138,8 @@ export const executeConcurrently = async (
   let timedoutCount = 0
   let erroredCount = 0
   let completedCount = 0
+  const stopAfterAllExecutionCallbackList = createCallbackListNotifiedOnce()
+
   const executionsDone = await executeInParallel({
     multipleExecutionsOperation,
     maxExecutionsInParallel,
@@ -153,12 +156,7 @@ export const executeConcurrently = async (
         measurePerformance: false,
         collectPerformance: false,
         captureConsole: true,
-        // stopAfterExecute: true to ensure runtime is stopped once executed
-        // because we have what we wants: execution is completed and
-        // we have associated coverage and capturedConsole
-        // passsing false means all node process and browsers launched stays opened
-        // (can eventually be used for debug)
-        stopAfterExecute: true,
+        stopAfterExecute,
         stopAfterExecuteReason: "execution-done",
         allocatedMs: defaultMsAllocatedPerExecution,
         ...paramsFromStep,
@@ -212,6 +210,7 @@ export const executeConcurrently = async (
             collectCoverage: coverage,
             coverageIgnorePredicate,
             coverageForceIstanbul,
+            stopAfterAllExecutionCallbackList,
             ...executionParams.runtimeParams,
           },
           executeParams: {
@@ -283,6 +282,10 @@ export const executeConcurrently = async (
     },
   })
 
+  if (stopAfterExecute) {
+    stopAfterAllExecutionCallbackList.notify()
+  }
+
   const summaryCounts = reportToSummary(report)
 
   const summary = {

package/src/internal/executing/executePlan.js

@@ -26,6 +26,7 @@ export const executePlan = async (
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    stopAfterExecute,
     cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
@@ -156,6 +157,7 @@ export const executePlan = async (
 
       defaultMsAllocatedPerExecution,
       maxExecutionsInParallel,
+      stopAfterExecute,
       cooldownBetweenExecutions,
       completedExecutionLogMerging,
       completedExecutionLogAbbreviation,

package/src/launchBrowser.js

@@ -1,511 +1,43 @@
-// https://github.com/microsoft/playwright/blob/master/docs/api.md
-
-import { createDetailedMessage } from "@jsenv/logger"
-import {
-  Abort,
-  createCallbackListNotifiedOnce,
-  createCallbackList,
-  raceProcessTeardownEvents,
-} from "@jsenv/abort"
-import { memoize } from "@jsenv/filesystem"
-
-import { fetchUrl } from "./internal/fetchUrl.js"
-import { validateResponse } from "./internal/response_validation.js"
-import { trackPageToNotify } from "./internal/browser_launcher/trackPageToNotify.js"
-import { createSharing } from "./internal/browser_launcher/createSharing.js"
-import { executeHtmlFile } from "./internal/browser_launcher/executeHtmlFile.js"
+import { createRuntimeFromPlaywright } from "@jsenv/core/src/internal/browser_launcher/from_playwright.js"
 import {
   PLAYWRIGHT_CHROMIUM_VERSION,
   PLAYWRIGHT_FIREFOX_VERSION,
   PLAYWRIGHT_WEBKIT_VERSION,
 } from "./playwright_browser_versions.js"
 
-const chromiumSharing = createSharing()
-export const chromiumRuntime = {
-  name: "chromium",
-  version: PLAYWRIGHT_CHROMIUM_VERSION,
-}
-chromiumRuntime.launch = async ({
-  signal = new AbortController().signal,
-  browserServerLogLevel,
-  chromiumExecutablePath,
-
-  projectDirectoryUrl,
-  compileServerOrigin,
-  compileServerId,
-  outDirectoryRelativeUrl,
-
-  collectPerformance,
-  measurePerformance,
-  collectCoverage,
-  coverageIgnorePredicate,
-  coverageForceIstanbul,
-
-  headless = true,
-  // about debug check https://github.com/microsoft/playwright/blob/master/docs/api.md#browsertypelaunchserveroptions
-  debug = false,
-  debugPort = 0,
-  stopOnExit = true,
-  share = false,
-}) => {
-  const launchBrowserOperation = Abort.startOperation()
-  launchBrowserOperation.addAbortSignal(signal)
-
-  const sharingToken = share
-    ? chromiumSharing.getSharingToken({
-        chromiumExecutablePath,
-        headless,
-        debug,
-        debugPort,
-      })
-    : chromiumSharing.getUniqueSharingToken()
-  if (!sharingToken.isUsed()) {
-    const { chromium } = await importPlaywright({ browserName: "chromium" })
-    const launchOperation = launchBrowser("chromium", {
-      browserClass: chromium,
-      launchBrowserOperation,
-      options: {
-        headless,
-        executablePath: chromiumExecutablePath,
-        ...(debug ? { devtools: true } : {}),
-        args: [
-          // https://github.com/GoogleChrome/puppeteer/issues/1834
-          // https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md#tips
-          // "--disable-dev-shm-usage",
-          ...(debug ? [`--remote-debugging-port=${debugPort}`] : []),
-        ],
-      },
-      stopOnExit,
-    })
-    sharingToken.setSharedValue(launchOperation)
-  }
-
-  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.addEndCallback(stopUsingBrowser)
-  const browser = await browserPromise
-
-  if (debug) {
-    // https://github.com/puppeteer/puppeteer/blob/v2.0.0/docs/api.md#browserwsendpoint
-    // https://chromedevtools.github.io/devtools-protocol/#how-do-i-access-the-browser-target
-    const webSocketEndpoint = browser.wsEndpoint()
-    const webSocketUrl = new URL(webSocketEndpoint)
-    const browserEndpoint = `http://${webSocketUrl.host}/json/version`
-    const browserResponse = await fetchUrl(browserEndpoint, {
-      signal,
-      ignoreHttpsError: true,
-    })
-    const { isValid, message, details } = await validateResponse(
-      browserResponse,
-    )
-    if (!isValid) {
-      throw new Error(createDetailedMessage(message, details))
+export const chromiumRuntime = createRuntimeFromPlaywright({
+  browserName: "chromium",
+  browserVersion: PLAYWRIGHT_CHROMIUM_VERSION,
+  coveragePlaywrightAPIAvailable: true,
+})
+export const chromiumTabRuntime = chromiumRuntime.tab
+
+export const firefoxRuntime = createRuntimeFromPlaywright({
+  browserName: "firefox",
+  browserVersion: PLAYWRIGHT_FIREFOX_VERSION,
+})
+export const firefoxTabRuntime = firefoxRuntime.tab
+
+export const webkitRuntime = createRuntimeFromPlaywright({
+  browserName: "webkit",
+  browserVersion: PLAYWRIGHT_WEBKIT_VERSION,
+  ignoreErrorHook: (error) => {
+    // we catch error during execution but safari throw unhandled rejection
+    // in a non-deterministic way.
+    // I suppose it's due to some race condition to decide if the promise is catched or not
+    // for now we'll ignore unhandled rejection on wekbkit
+    if (error.name === "Unhandled Promise Rejection") {
+      return true
     }
-
-    const browserResponseObject = JSON.parse(browserResponse.body)
-    const { webSocketDebuggerUrl } = browserResponseObject
-    console.log(`Debugger listening on ${webSocketDebuggerUrl}`)
-  }
-
-  const browserHooks = browserToRuntimeHooks(browser, {
-    runtime: chromiumRuntime,
-    browserServerLogLevel,
-
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileServerId,
-    outDirectoryRelativeUrl,
-
-    collectPerformance,
-    measurePerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-    coveragePlaywrightAPIAvailable: true,
-  })
-
-  return {
-    browser,
-    ...browserHooks,
-  }
-}
-export const chromiumTabRuntime = {
-  ...chromiumRuntime,
-  launch: (params) =>
-    chromiumRuntime.launch({
-      shared: true,
-      ...params,
-    }),
-}
-
-const firefoxSharing = createSharing()
-export const firefoxRuntime = {
-  name: "firefox",
-  version: PLAYWRIGHT_FIREFOX_VERSION,
-}
-firefoxRuntime.launch = async ({
-  signal = new AbortController().signal,
-  firefoxExecutablePath,
-  browserServerLogLevel,
-
-  projectDirectoryUrl,
-  compileServerOrigin,
-  outDirectoryRelativeUrl,
-
-  collectPerformance,
-  measurePerformance,
-  collectCoverage,
-  coverageIgnorePredicate,
-  coverageForceIstanbul,
-
-  headless = true,
-  stopOnExit = true,
-  share = false,
-}) => {
-  const launchBrowserOperation = Abort.startOperation()
-  launchBrowserOperation.addAbortSignal(signal)
-
-  const sharingToken = share
-    ? firefoxSharing.getSharingToken({ firefoxExecutablePath, headless })
-    : firefoxSharing.getUniqueSharingToken()
-  if (!sharingToken.isUsed()) {
-    const { firefox } = await importPlaywright({ browserName: "firefox" })
-    const launchOperation = launchBrowser("firefox", {
-      browserClass: firefox,
-
-      launchBrowserOperation,
-      options: {
-        headless,
-        executablePath: firefoxExecutablePath,
-      },
-      stopOnExit,
-    })
-    sharingToken.setSharedValue(launchOperation)
-  }
-
-  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.addEndCallback(stopUsingBrowser)
-  const browser = await browserPromise
-
-  const browserHooks = browserToRuntimeHooks(browser, {
-    runtime: firefoxRuntime,
-    launchBrowserOperation,
-    browserServerLogLevel,
-
-    projectDirectoryUrl,
-    compileServerOrigin,
-    outDirectoryRelativeUrl,
-
-    collectPerformance,
-    measurePerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-  })
-
-  return {
-    browser,
-    ...browserHooks,
-  }
-}
-export const firefoxTabRuntime = {
-  ...firefoxRuntime,
-  launch: (params) =>
-    firefoxRuntime.launch({
-      shared: true,
-      ...params,
-    }),
-}
-
-const webkitSharing = createSharing()
-export const webkitRuntime = {
-  name: "webkit",
-  version: PLAYWRIGHT_WEBKIT_VERSION,
-}
-webkitRuntime.launch = async ({
-  signal = new AbortController().signal,
-  browserServerLogLevel,
-  webkitExecutablePath,
-
-  projectDirectoryUrl,
-  compileServerOrigin,
-  outDirectoryRelativeUrl,
-
-  collectPerformance,
-  measurePerformance,
-  collectCoverage,
-  coverageIgnorePredicate,
-  coverageForceIstanbul,
-
-  headless = true,
-  stopOnExit = true,
-  share = false,
-}) => {
-  const launchBrowserOperation = Abort.startOperation()
-  launchBrowserOperation.addAbortSignal(signal)
-
-  const sharingToken = share
-    ? webkitSharing.getSharingToken({ webkitExecutablePath, headless })
-    : webkitSharing.getUniqueSharingToken()
-
-  if (!sharingToken.isUsed()) {
-    const { webkit } = await await importPlaywright({ browserName: "webkit" })
-    const launchOperation = launchBrowser("webkit", {
-      browserClass: webkit,
-      launchBrowserOperation,
-      options: {
-        headless,
-        executablePath: webkitExecutablePath,
-      },
-      stopOnExit,
-    })
-    sharingToken.setSharedValue(launchOperation)
-  }
-
-  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.addEndCallback(stopUsingBrowser)
-  const browser = await browserPromise
-
-  const browserHooks = browserToRuntimeHooks(browser, {
-    runtime: webkitRuntime,
-    launchBrowserOperation,
-    browserServerLogLevel,
-
-    projectDirectoryUrl,
-    compileServerOrigin,
-    outDirectoryRelativeUrl,
-
-    collectPerformance,
-    measurePerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-    ignoreErrorHook: (error) => {
-      // we catch error during execution but safari throw unhandled rejection
-      // in a non-deterministic way.
-      // I suppose it's due to some race condition to decide if the promise is catched or not
-      // for now we'll ignore unhandled rejection on wekbkit
-      if (error.name === "Unhandled Promise Rejection") {
-        return true
-      }
-      return false
-    },
-    transformErrorHook: (error) => {
-      // Force error stack to contain the error message
-      // because it's not the case on webkit
-      error.stack = `${error.message}
+    return false
+  },
+  transformErrorHook: (error) => {
+    // Force error stack to contain the error message
+    // because it's not the case on webkit
+    error.stack = `${error.message}
   at ${error.stack}`
 
-      return error
-    },
-  })
-
-  return {
-    browser,
-    ...browserHooks,
-  }
-}
-export const webkitTabRuntime = {
-  ...webkitRuntime,
-  launch: (params) =>
-    webkitRuntime.launch({
-      shared: true,
-      ...params,
-    }),
-}
-
-const launchBrowser = async (
-  browserName,
-  { launchBrowserOperation, browserClass, options, stopOnExit },
-) => {
-  if (stopOnExit) {
-    launchBrowserOperation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGHUP: true,
-          SIGTERM: true,
-          SIGINT: true,
-          beforeExit: true,
-          exit: true,
-        },
-        abort,
-      )
-    })
-  }
-
-  try {
-    const browser = await browserClass.launch({
-      ...options,
-      // let's handle them to close properly browser + remove listener
-      // instead of relying on playwright to do so
-      handleSIGINT: false,
-      handleSIGTERM: false,
-      handleSIGHUP: false,
-    })
-    launchBrowserOperation.throwIfAborted()
-    return browser
-  } catch (e) {
-    if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
-      // rethrow the abort error
-      launchBrowserOperation.throwIfAborted()
-    }
-    throw e
-  } finally {
-    await launchBrowserOperation.end()
-  }
-}
-
-const importPlaywright = async ({ browserName }) => {
-  try {
-    const namespace = await import("playwright")
-    return namespace
-  } catch (e) {
-    if (e.code === "ERR_MODULE_NOT_FOUND") {
-      throw new Error(
-        createDetailedMessage(
-          `"playwright" not found. You need playwright in your dependencies when using "${browserName}Runtime"`,
-          {
-            suggestion: `npm install --save-dev playwright`,
-          },
-        ),
-        { cause: e },
-      )
-    }
-    throw e
-  }
-}
-
-const stopBrowser = async (browser) => {
-  const disconnected = browser.isConnected()
-    ? new Promise((resolve) => {
-        const disconnectedCallback = () => {
-          browser.removeListener("disconnected", disconnectedCallback)
-          resolve()
-        }
-        browser.on("disconnected", disconnectedCallback)
-      })
-    : Promise.resolve()
-
-  // for some reason without this 100ms timeout
-  // browser.close() never resolves (playwright does not like something)
-  await new Promise((resolve) => setTimeout(resolve, 100))
-
-  await browser.close()
-  await disconnected
-}
-
-const browserToRuntimeHooks = (
-  browser,
-  {
-    runtime,
-    projectDirectoryUrl,
-    compileServerOrigin,
-    compileServerId,
-    outDirectoryRelativeUrl,
-
-    collectPerformance,
-    measurePerformance,
-    collectCoverage,
-    coverageIgnorePredicate,
-    coverageForceIstanbul,
-    coveragePlaywrightAPIAvailable = false,
-    ignoreErrorHook = () => false,
-    transformErrorHook = (error) => error,
+    return error
   },
-) => {
-  const stopCallbackList = createCallbackListNotifiedOnce()
-  const stoppedCallbackList = createCallbackListNotifiedOnce()
-  const stop = memoize(async (reason) => {
-    await stopCallbackList.notify({ reason })
-    stoppedCallbackList.notify({ reason })
-    return { graceful: false }
-  })
-
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-  browser.on("disconnected", () => {
-    stop()
-  })
-
-  stopCallbackList.add(async () => {
-    await stopBrowser(browser)
-  })
-
-  const errorCallbackList = createCallbackList()
-
-  const outputCallbackList = createCallbackList()
-
-  const execute = async ({
-    signal,
-    fileRelativeUrl,
-    ignoreHTTPSErrors = true, // we mostly use self signed certificates during tests
-  }) => {
-    const executeOperation = Abort.startOperation()
-    executeOperation.addAbortSignal(signal)
-    executeOperation.throwIfAborted()
-    // open a tab to execute to the file
-    const browserContext = await browser.newContext({ ignoreHTTPSErrors })
-    executeOperation.throwIfAborted()
-    const page = await browserContext.newPage()
-    executeOperation.addEndCallback(async () => {
-      try {
-        await browserContext.close()
-      } catch (e) {
-        if (isTargetClosedError(e)) {
-          return
-        }
-        throw e
-      }
-    })
-    // track tab error and console
-    const stopTrackingToNotify = trackPageToNotify(page, {
-      onError: (error) => {
-        error = transformErrorHook(error)
-        if (!ignoreErrorHook(error)) {
-          errorCallbackList.notify(error)
-        }
-      },
-      onConsole: outputCallbackList.notify,
-    })
-    stoppedCallbackList.add(stopTrackingToNotify)
-
-    const result = await executeHtmlFile(fileRelativeUrl, {
-      runtime,
-      executeOperation,
-
-      projectDirectoryUrl,
-      compileServerOrigin,
-      compileServerId,
-      outDirectoryRelativeUrl,
-
-      page,
-      measurePerformance,
-      collectPerformance,
-      collectCoverage,
-      coverageForceIstanbul,
-      coveragePlaywrightAPIAvailable,
-      coverageIgnorePredicate,
-      transformErrorHook,
-    })
-    return result
-  }
-
-  return {
-    stoppedCallbackList,
-    errorCallbackList,
-    outputCallbackList,
-    execute,
-    stop,
-  }
-}
-
-const isTargetClosedError = (error) => {
-  if (error.message.match(/Protocol error \(.*?\): Target closed/)) {
-    return true
-  }
-  if (error.message.match(/Protocol error \(.*?\): Browser.*?closed/)) {
-    return true
-  }
-  if (error.message.includes("browserContext.close: Browser closed")) {
-    return true
-  }
-  return false
-}
+})
+export const webkitTabRuntime = webkitRuntime.tab

package/src/internal/browser_launcher/createSharing.js

@@ -1,70 +0,0 @@
-export const createSharing = ({ argsToId = argsToIdFallback } = {}) => {
-  const tokenMap = {}
-
-  const getSharingToken = (...args) => {
-    const id = argsToId(args)
-
-    if (id in tokenMap) {
-      return tokenMap[id]
-    }
-
-    const sharingToken = createSharingToken({
-      unusedCallback: () => {
-        delete tokenMap[id]
-      },
-    })
-    tokenMap[id] = sharingToken
-    return sharingToken
-  }
-
-  const getUniqueSharingToken = () => {
-    return createSharingToken()
-  }
-
-  return { getSharingToken, getUniqueSharingToken }
-}
-
-const createSharingToken = ({ unusedCallback = () => {} } = {}) => {
-  let useCount = 0
-  let sharedValue
-  let cleanup
-  const sharingToken = {
-    isUsed: () => useCount > 0,
-
-    setSharedValue: (value, cleanupFunction = () => {}) => {
-      sharedValue = value
-      cleanup = cleanupFunction
-    },
-
-    useSharedValue: () => {
-      useCount++
-
-      let stopped = false
-      let stopUsingReturnValue
-      const stopUsing = () => {
-        // ensure if stopUsing is called many times
-        // it returns the same value and does not decrement useCount more than once
-        if (stopped) {
-          return stopUsingReturnValue
-        }
-
-        stopped = true
-        useCount--
-        if (useCount === 0) {
-          unusedCallback()
-          sharedValue = undefined
-          stopUsingReturnValue = cleanup()
-        } else {
-          stopUsingReturnValue = undefined
-        }
-
-        return stopUsingReturnValue
-      }
-
-      return [sharedValue, stopUsing]
-    },
-  }
-  return sharingToken
-}
-
-const argsToIdFallback = (args) => JSON.stringify(args)