@jsenv/core 25.3.0-alpha.0 → 25.4.2

package/src/dev_server.js

@@ -1,11 +1,12 @@
+import { setupRoutes } from "@jsenv/server"
 import {
   normalizeStructuredMetaMap,
   collectFiles,
   urlToRelativeUrl,
 } from "@jsenv/filesystem"
-import { setupRoutes } from "@jsenv/server"
 
 import { REDIRECTOR_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
+import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
 import { jsenvCoreDirectoryUrl } from "./internal/jsenvCoreDirectoryUrl.js"
 import {
   assertProjectDirectoryUrl,
@@ -13,14 +14,13 @@ import {
 } from "./internal/argUtils.js"
 import {
   startCompileServer,
-  computeOutDirectoryRelativeUrl,
+  assertAndNormalizeJsenvDirectoryRelativeUrl,
 } from "./internal/compiling/startCompileServer.js"
-import { jsenvExplorableConfig } from "./jsenvExplorableConfig.js"
-
 import {
   sourcemapMainFileInfo,
   sourcemapMappingFileInfo,
 } from "./internal/jsenvInternalFiles.js"
+import { jsenvExplorableConfig } from "./jsenvExplorableConfig.js"
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
@@ -28,7 +28,7 @@ export const startDevServer = async ({
   port,
   ip,
   protocol,
-  http2,
+  http2 = false, // disable by default for now because it is buggy on safari
   certificate,
   privateKey,
   plugins,
@@ -38,7 +38,6 @@ export const startDevServer = async ({
   explorableConfig = jsenvExplorableConfig,
   mainFileRelativeUrl,
   jsenvDirectoryRelativeUrl,
-  outDirectoryName = "dev",
   jsenvToolbar = true,
   livereloading = true,
   inlineImportMapIntoHTML = true,
@@ -66,7 +65,6 @@ export const startDevServer = async ({
 }) => {
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
   if (mainFileRelativeUrl === undefined) {
     mainFileRelativeUrl = urlToRelativeUrl(
       new URL(
@@ -76,13 +74,10 @@ export const startDevServer = async ({
       projectDirectoryUrl,
     )
   }
-
-  const outDirectoryRelativeUrl = computeOutDirectoryRelativeUrl({
+  jsenvDirectoryRelativeUrl = assertAndNormalizeJsenvDirectoryRelativeUrl({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
-    outDirectoryName,
   })
-
   const compileServer = await startCompileServer({
     signal,
     handleSIGINT,
@@ -103,14 +98,14 @@ export const startDevServer = async ({
       }),
       "jsenv:exploring_json": createExploringJsonService({
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl,
         mainFileRelativeUrl,
         explorableConfig,
         livereloading,
       }),
       "jsenv:explorables_json": createExplorableJsonService({
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl,
         explorableConfig,
       }),
     },
@@ -120,7 +115,6 @@ export const startDevServer = async ({
     jsenvEventSourceClientInjection: true,
     jsenvToolbarInjection: jsenvToolbar,
     jsenvDirectoryRelativeUrl,
-    outDirectoryName,
     inlineImportMapIntoHTML,
 
     compileServerCanReadFromFilesystem,
@@ -155,20 +149,45 @@ const createRedirectorService = async ({
       return {
         status: 307,
         headers: {
-          location: `${request.origin}/${redirectorRelativeUrlForProject}?redirect=${redirectTarget}`,
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+            },
+          ),
         },
       }
     },
+    // compile server (compiled file service to be precised)
+    // is already implementing this redirection when a compile id do not exists
+    // and "redirect" is not a valid compile id
+    // That being said I prefer to keep it to be explicit and shortcircuit the logic
     "/.jsenv/redirect/:rest*": (request) => {
       const redirectTarget = request.ressource.slice("/.jsenv/redirect/".length)
       return {
         status: 307,
         headers: {
-          location: `${
-            request.origin
-          }/${redirectorRelativeUrlForProject}?redirect=${encodeURIComponent(
-            redirectTarget,
-          )}`,
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+            },
+          ),
+        },
+      }
+    },
+    "/.jsenv/force/:rest*": (request) => {
+      const redirectTarget = request.ressource.slice("/.jsenv/force/".length)
+      return {
+        status: 307,
+        headers: {
+          location: setUrlSearchParamsDescriptor(
+            `${request.origin}/${redirectorRelativeUrlForProject}`,
+            {
+              redirect: redirectTarget,
+              force_compilation: 1,
+            },
+          ),
         },
       }
     },
@@ -177,98 +196,98 @@ const createRedirectorService = async ({
 
 const createExploringJsonService = ({
   projectDirectoryUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   explorableConfig,
   livereloading,
   mainFileRelativeUrl,
 }) => {
   return (request) => {
     if (
-      request.ressource === "/.jsenv/exploring.json" &&
-      request.method === "GET"
+      request.ressource !== "/.jsenv/exploring.json" ||
+      request.method !== "GET"
     ) {
-      const data = {
+      return null
+    }
+    const data = {
+      projectDirectoryUrl,
+      jsenvDirectoryRelativeUrl,
+      jsenvCoreDirectoryRelativeUrl: urlToRelativeUrl(
+        jsenvCoreDirectoryUrl,
         projectDirectoryUrl,
-        outDirectoryRelativeUrl,
-        jsenvDirectoryRelativeUrl: urlToRelativeUrl(
-          jsenvCoreDirectoryUrl,
-          projectDirectoryUrl,
-        ),
-        exploringHtmlFileRelativeUrl: mainFileRelativeUrl,
-        sourcemapMainFileRelativeUrl: urlToRelativeUrl(
-          sourcemapMainFileInfo.url,
-          jsenvCoreDirectoryUrl,
-        ),
-        sourcemapMappingFileRelativeUrl: urlToRelativeUrl(
-          sourcemapMappingFileInfo.url,
-          jsenvCoreDirectoryUrl,
-        ),
-        explorableConfig,
-        livereloading,
-      }
-      const json = JSON.stringify(data)
-      return {
-        status: 200,
-        headers: {
-          "cache-control": "no-store",
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(json),
-        },
-        body: json,
-      }
+      ),
+      exploringHtmlFileRelativeUrl: mainFileRelativeUrl,
+      sourcemapMainFileRelativeUrl: urlToRelativeUrl(
+        sourcemapMainFileInfo.url,
+        jsenvCoreDirectoryUrl,
+      ),
+      sourcemapMappingFileRelativeUrl: urlToRelativeUrl(
+        sourcemapMappingFileInfo.url,
+        jsenvCoreDirectoryUrl,
+      ),
+      explorableConfig,
+      livereloading,
+    }
+    const json = JSON.stringify(data)
+    return {
+      status: 200,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(json),
+      },
+      body: json,
     }
-    return null
   }
 }
 
 const createExplorableJsonService = ({
   projectDirectoryUrl,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   explorableConfig,
 }) => {
   return async (request) => {
     if (
-      request.ressource === "/.jsenv/explorables.json" &&
-      request.method === "GET"
+      request.ressource !== "/.jsenv/explorables.json" ||
+      request.method !== "GET"
     ) {
-      const structuredMetaMapRelativeForExplorable = {}
-      Object.keys(explorableConfig).forEach((explorableGroup) => {
-        const explorableGroupConfig = explorableConfig[explorableGroup]
-        structuredMetaMapRelativeForExplorable[explorableGroup] = {
-          "**/.jsenv/": false, // temporary (in theory) to avoid visting .jsenv directory in jsenv itself
-          ...explorableGroupConfig,
-          [outDirectoryRelativeUrl]: false,
-        }
-      })
-      const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
-        structuredMetaMapRelativeForExplorable,
-        projectDirectoryUrl,
-      )
-      const matchingFileResultArray = await collectFiles({
-        directoryUrl: projectDirectoryUrl,
-        structuredMetaMap: structuredMetaMapForExplorable,
-        predicate: (meta) =>
-          Object.keys(meta).some((explorableGroup) =>
-            Boolean(meta[explorableGroup]),
-          ),
-      })
-      const explorableFiles = matchingFileResultArray.map(
-        ({ relativeUrl, meta }) => ({
-          relativeUrl,
-          meta,
-        }),
-      )
-      const json = JSON.stringify(explorableFiles)
-      return {
-        status: 200,
-        headers: {
-          "cache-control": "no-store",
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(json),
-        },
-        body: json,
+      return null
+    }
+    const structuredMetaMapRelativeForExplorable = {}
+    Object.keys(explorableConfig).forEach((explorableGroup) => {
+      const explorableGroupConfig = explorableConfig[explorableGroup]
+      structuredMetaMapRelativeForExplorable[explorableGroup] = {
+        "**/.jsenv/": false, // temporary (in theory) to avoid visting .jsenv directory in jsenv itself
+        ...explorableGroupConfig,
+        [jsenvDirectoryRelativeUrl]: false,
       }
+    })
+    const structuredMetaMapForExplorable = normalizeStructuredMetaMap(
+      structuredMetaMapRelativeForExplorable,
+      projectDirectoryUrl,
+    )
+    const matchingFileResultArray = await collectFiles({
+      directoryUrl: projectDirectoryUrl,
+      structuredMetaMap: structuredMetaMapForExplorable,
+      predicate: (meta) =>
+        Object.keys(meta).some((explorableGroup) =>
+          Boolean(meta[explorableGroup]),
+        ),
+    })
+    const explorableFiles = matchingFileResultArray.map(
+      ({ relativeUrl, meta }) => ({
+        relativeUrl,
+        meta,
+      }),
+    )
+    const json = JSON.stringify(explorableFiles)
+    return {
+      status: 200,
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(json),
+      },
+      body: json,
     }
-    return null
   }
 }

package/src/execute.js

@@ -1,6 +1,6 @@
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
-import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
+import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/runtime_support/runtime_support.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -61,14 +61,12 @@ export const execute = async ({
 }) => {
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
-
   if (typeof fileRelativeUrl !== "string") {
     throw new TypeError(
       `fileRelativeUrl must be a string, got ${fileRelativeUrl}`,
     )
   }
   fileRelativeUrl = fileRelativeUrl.replace(/\\/g, "/")
-
   if (typeof runtime !== "object") {
     throw new TypeError(`runtime must be an object, got ${runtime}`)
   }
@@ -77,7 +75,6 @@ export const execute = async ({
       `runtime.launch must be a function, got ${runtime.launch}`,
     )
   }
-
   const executeOperation = Abort.startOperation()
   executeOperation.addAbortSignal(signal)
   if (handleSIGINT) {
@@ -90,7 +87,6 @@ export const execute = async ({
       )
     })
   }
-
   try {
     const compileServer = await startCompileServer({
       signal: executeOperation.signal,
@@ -99,7 +95,6 @@ export const execute = async ({
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       jsenvDirectoryClean,
-      outDirectoryName: "dev",
 
       importDefaultExtension,
 
@@ -133,7 +128,7 @@ export const execute = async ({
         projectDirectoryUrl,
         compileServerOrigin: compileServer.origin,
         compileServerId: compileServer.id,
-        outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+        jsenvDirectoryRelativeUrl: compileServer.jsenvDirectoryRelativeUrl,
         ...runtimeParams,
       },
       executeParams: {
@@ -161,7 +156,7 @@ export const execute = async ({
 
     if (collectCompileServerInfo) {
       result.compileServerOrigin = compileServer.origin
-      result.outDirectoryRelativeUrl = compileServer.outDirectoryRelativeUrl
+      result.jsenvDirectoryRelativeUrl = compileServer.jsenvDirectoryRelativeUrl
     }
 
     if (result.status === "errored") {

package/src/importUsingChildProcess.js

@@ -15,6 +15,7 @@ export const importUsingChildProcess = async (
     stderr,
   } = {},
 ) => {
+  fileUrl = String(fileUrl)
   const result = await launchAndExecute({
     stopAfterExecute: true,
     fileRelativeUrl: String(fileUrl),

package/src/internal/browser_launcher/{browser_runtime_report.js → browser_runtime_profile.js}

@@ -1,34 +1,39 @@
-export const getBrowserRuntimeReport = async ({
+export const getBrowserRuntimeProfile = async ({
   page,
-  coverageHandledFromOutside,
   runtime,
   compileServerId,
+  coverageHandledFromOutside,
+  forceSource,
+  forceCompilation,
 }) => {
   const cache = cacheFromParams({
     runtime,
     compileServerId,
     coverageHandledFromOutside,
+    forceSource,
+    forceCompilation,
   })
   const entry = cache.read()
   if (entry) {
     return entry
   }
-  const browserRuntimeFeaturesReport = await page.evaluate(
+  const browserRuntimeProfile = await page.evaluate(
+    /* eslint-disable no-undef */
     /* istanbul ignore next */
-    async ({ coverageHandledFromOutside }) => {
-      // eslint-disable-next-line no-undef
+    async ({ coverageHandledFromOutside, forceSource, forceCompilation }) => {
       await window.readyPromise
-
-      // eslint-disable-next-line no-undef
-      return window.scanBrowserRuntimeFeatures({
+      const runtimeProfile = await window.scanBrowserRuntimeFeatures({
         coverageHandledFromOutside,
-        failFastOnFeatureDetection: true,
+        forceSource,
+        forceCompilation,
       })
+      return runtimeProfile
     },
-    { coverageHandledFromOutside },
+    /* eslint-enable no-undef */
+    { coverageHandledFromOutside, forceSource, forceCompilation },
   )
-  cache.write(browserRuntimeFeaturesReport)
-  return browserRuntimeFeaturesReport
+  cache.write(browserRuntimeProfile)
+  return browserRuntimeProfile
 }
 
 let currentCacheParams
@@ -37,13 +42,16 @@ const cacheFromParams = ({
   runtime,
   compileServerId,
   coverageHandledFromOutside,
+  forceSource,
+  forceCompilation,
 }) => {
   const params = {
     compileServerId,
     coverageHandledFromOutside,
+    forceSource,
+    forceCompilation,
   }
   const runtimeLabel = `${runtime.name}/${runtime.version}`
-
   if (!currentCacheParams) {
     currentCacheParams = params
     currentCacheValue = {}
@@ -54,7 +62,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
     return {
       read: () => null,
@@ -65,7 +72,6 @@ const cacheFromParams = ({
       },
     }
   }
-
   return {
     read: () => currentCacheValue[runtimeLabel],
     write: (value) => {

package/src/internal/browser_launcher/executeHtmlFile.js

@@ -10,7 +10,7 @@ import { filterV8Coverage } from "@jsenv/core/src/internal/executing/coverage_ut
 import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage_utils/istanbul_coverage_composition.js"
 import { evalSource } from "../node_runtime/evalSource.js"
 import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.js"
-import { getBrowserRuntimeReport } from "./browser_runtime_report.js"
+import { getBrowserRuntimeProfile } from "./browser_runtime_profile.js"
 
 export const executeHtmlFile = async (
   fileRelativeUrl,
@@ -20,7 +20,7 @@ export const executeHtmlFile = async (
     projectDirectoryUrl,
     compileServerOrigin,
     compileServerId,
-    outDirectoryRelativeUrl,
+    jsenvDirectoryRelativeUrl,
     page,
 
     // measurePerformance,
@@ -30,6 +30,7 @@ export const executeHtmlFile = async (
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable,
     transformErrorHook,
+    forceSource,
     forceCompilation,
   },
 ) => {
@@ -56,36 +57,42 @@ export const executeHtmlFile = async (
 
   const coverageHandledFromOutside =
     coveragePlaywrightAPIAvailable && !coverageForceIstanbul
-  const browserRuntimeFeaturesReport = await getBrowserRuntimeReport({
+  const browserRuntimeProfile = await getBrowserRuntimeProfile({
     page,
-    coverageHandledFromOutside,
     compileServerId,
     runtime,
+    // js coverage
+    // When instrumentation CAN be handed by playwright
+    // https://playwright.dev/docs/api/class-chromiumcoverage#chromiumcoveragestartjscoverageoptions
+    // coverageHandledFromOutside is true and "transform-instrument" becomes non mandatory
+    coverageHandledFromOutside,
+    forceSource,
+    forceCompilation,
   })
 
   try {
     let executionResult
-    const { canAvoidCompilation, compileId } = browserRuntimeFeaturesReport
+    const { compileId } = browserRuntimeProfile
     executeOperation.throwIfAborted()
-    if (canAvoidCompilation && !forceCompilation) {
-      executionResult = await executeSource({
+    if (compileId) {
+      executionResult = await executeCompiledVersion({
         projectDirectoryUrl,
         compileServerOrigin,
         fileRelativeUrl,
         page,
+        jsenvDirectoryRelativeUrl,
+        compileId,
         collectCoverage,
-        coverageIgnorePredicate,
         transformErrorHook,
       })
     } else {
-      executionResult = await executeCompiledVersion({
+      executionResult = await executeSource({
         projectDirectoryUrl,
         compileServerOrigin,
         fileRelativeUrl,
         page,
-        outDirectoryRelativeUrl,
-        compileId,
         collectCoverage,
+        coverageIgnorePredicate,
         transformErrorHook,
       })
     }
@@ -238,7 +245,7 @@ const executeCompiledVersion = async ({
   compileServerOrigin,
   fileRelativeUrl,
   page,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   compileId,
   collectCoverage,
   transformErrorHook,
@@ -259,7 +266,7 @@ const executeCompiledVersion = async ({
     })
   }
 
-  const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
   const compileDirectoryRemoteUrl = resolveUrl(
     compileDirectoryRelativeUrl,
     compileServerOrigin,
@@ -268,11 +275,12 @@ const executeCompiledVersion = async ({
   await page.goto(fileClientUrl, { timeout: 0 })
 
   const executionResult = await page.evaluate(
+    /* eslint-disable no-undef */
     /* istanbul ignore next */
     () => {
-      // eslint-disable-next-line no-undef
       return window.__jsenv__.executionResultPromise
     },
+    /* eslint-enable no-undef */
   )
 
   const { fileExecutionResultMap } = executionResult

package/src/internal/browser_launcher/from_playwright.js

@@ -33,7 +33,8 @@ export const createRuntimeFromPlaywright = ({
 
     projectDirectoryUrl,
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+    compileServerId,
+    jsenvDirectoryRelativeUrl,
 
     collectPerformance,
     measurePerformance,
@@ -130,7 +131,8 @@ export const createRuntimeFromPlaywright = ({
 
       projectDirectoryUrl,
       compileServerOrigin,
-      outDirectoryRelativeUrl,
+      compileServerId,
+      jsenvDirectoryRelativeUrl,
 
       collectPerformance,
       measurePerformance,
@@ -264,7 +266,7 @@ const createExecuteHook = ({
   projectDirectoryUrl,
   compileServerOrigin,
   compileServerId,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
 
   collectPerformance,
   measurePerformance,
@@ -287,7 +289,7 @@ const createExecuteHook = ({
       projectDirectoryUrl,
       compileServerOrigin,
       compileServerId,
-      outDirectoryRelativeUrl,
+      jsenvDirectoryRelativeUrl,
 
       page,
       measurePerformance,

package/src/internal/browser_runtime/browser_runtime.js

@@ -1,7 +1,7 @@
 /* eslint-env browser */
 
 import { installBrowserErrorStackRemapping } from "../error-stack-remapping/installBrowserErrorStackRemapping.js"
-import { fetchUrl } from "../browser_utils/fetch-browser.js"
+import { fetchUrl } from "../browser_utils/fetch_browser.js"
 import { fetchAndEvalUsingFetch } from "../browser_utils/fetchAndEvalUsingFetch.js"
 import { unevalException } from "../unevalException.js"
 import { memoize } from "../memoize.js"
@@ -165,26 +165,27 @@ const onExecutionError = (
 
 const getBrowserRuntime = memoize(async () => {
   const compileServerOrigin = document.location.origin
-  const compileMetaResponse = await fetchUrl(
-    `${compileServerOrigin}/.jsenv/__compile_server_meta__.json`,
+  const compileServerResponse = await fetchUrl(
+    `${compileServerOrigin}/__jsenv_compile_profile__`,
   )
-  const compileMeta = await compileMetaResponse.json()
-  const { outDirectoryRelativeUrl, errorStackRemapping } = compileMeta
-  const outDirectoryUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
-  const afterOutDirectory = document.location.href.slice(outDirectoryUrl.length)
-  const parts = afterOutDirectory.split("/")
+  const compileServerMeta = await compileServerResponse.json()
+  const { jsenvDirectoryRelativeUrl, errorStackRemapping } = compileServerMeta
+  const jsenvDirectoryServerUrl = `${compileServerOrigin}/${jsenvDirectoryRelativeUrl}`
+  const afterJsenvDirectory = document.location.href.slice(
+    jsenvDirectoryServerUrl.length,
+  )
+  const parts = afterJsenvDirectory.split("/")
   const compileId = parts[0]
 
   const browserRuntime = await createBrowserRuntime({
     compileServerOrigin,
-    outDirectoryRelativeUrl,
+    jsenvDirectoryRelativeUrl,
     compileId,
   })
 
   if (errorStackRemapping && Error.captureStackTrace) {
     const { sourcemapMainFileRelativeUrl, sourcemapMappingFileRelativeUrl } =
-      compileMeta
-
+      compileServerMeta
     await fetchAndEvalUsingFetch(
       `${compileServerOrigin}/${sourcemapMainFileRelativeUrl}`,
     )
@@ -195,7 +196,6 @@ const getBrowserRuntime = memoize(async () => {
     const { getErrorOriginalStackString } = installBrowserErrorStackRemapping({
       SourceMapConsumer,
     })
-
     const errorTransform = async (error) => {
       // code can throw something else than an error
       // in that case return it unchanged
@@ -204,13 +204,11 @@ const getBrowserRuntime = memoize(async () => {
       error.stack = originalStack
       return error
     }
-
     const executeFile = browserRuntime.executeFile
     browserRuntime.executeFile = (file, options = {}) => {
       return executeFile(file, { errorTransform, ...options })
     }
   }
-
   return browserRuntime
 })