@jsenv/core 25.2.1 → 25.4.1

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
 })
 

package/src/internal/browser_runtime/createBrowserRuntime.js

@@ -3,7 +3,7 @@
 import { normalizeImportMap } from "@jsenv/importmap/src/normalizeImportMap.js"
 
 // do not use memoize from @jsenv/filesystem to avoid pulling @jsenv/filesystem code into the browser build
-import { fetchUrl } from "../browser_utils/fetch-browser.js"
+import { fetchUrl } from "../browser_utils/fetch_browser.js"
 import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
 import { memoize } from "../memoize.js"
 import { measureAsyncFnPerf } from "../perf_browser.js"
@@ -15,7 +15,7 @@ const memoizedCreateBrowserSystem = memoize(createBrowserSystem)
 
 export const createBrowserRuntime = async ({
   compileServerOrigin,
-  outDirectoryRelativeUrl,
+  jsenvDirectoryRelativeUrl,
   compileId,
 }) => {
   const fetchSource = (url, { contentTypeExpected }) => {
@@ -33,10 +33,11 @@ export const createBrowserRuntime = async ({
     return json
   }
 
-  const outDirectoryUrl = `${compileServerOrigin}/${outDirectoryRelativeUrl}`
-  const envUrl = String(new URL("env.json", outDirectoryUrl))
-  const { importDefaultExtension } = await fetchJson(envUrl)
-  const compileDirectoryRelativeUrl = `${outDirectoryRelativeUrl}${compileId}/`
+  const compileServerMetaUrl = String(
+    new URL("__jsenv_compile_profile__", `${compileServerOrigin}/`),
+  )
+  const { importDefaultExtension } = await fetchJson(compileServerMetaUrl)
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
   // if there is an importmap in the document we use it instead of fetching.
   // systemjs style with systemjs-importmap
   const importmapScript = document.querySelector(

package/src/internal/browser_utils/fetchAndEvalUsingFetch.js

@@ -2,7 +2,7 @@
 
 import { createDetailedMessage } from "@jsenv/logger"
 
-import { fetchUrl } from "./fetch-browser.js"
+import { fetchUrl } from "./fetch_browser.js"
 
 export const fetchAndEvalUsingFetch = async (url) => {
   const response = await fetchUrl(url)

package/src/internal/browser_utils/fetchJson.js

@@ -1,4 +1,4 @@
-import { fetchUrl } from "./fetch-browser.js"
+import { fetchUrl } from "./fetch_browser.js"
 
 export const fetchJson = async (url, options = {}) => {
   const response = await fetchUrl(url, options)

package/src/internal/browser_utils/{fetch-browser.js → fetch_browser.js}

@@ -1,5 +1,3 @@
-/* eslint-env browser */
-
 import { fetchUsingXHR } from "./fetchUsingXHR.js"
 
 const fetchNative = async (url, { mode = "cors", ...options } = {}) => {

package/src/internal/building/buildUsingRollup.js

@@ -9,82 +9,60 @@ import {
 import { createDetailedMessage } from "@jsenv/logger"
 
 import { humanizeUrl } from "@jsenv/core/src/internal/building/url_trace.js"
-import {
-  isNodePartOfSupportedRuntimes,
-  isBrowserPartOfSupportedRuntimes,
-} from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
-import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/runtime_compat.js"
+
 import { createRollupPlugins } from "./rollup_plugin_jsenv.js"
 
 export const buildUsingRollup = async ({
   buildOperation,
   logger,
 
-  projectDirectoryUrl,
   entryPoints,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  jsenvDirectoryRelativeUrl,
+  projectDirectoryUrl,
   buildDirectoryUrl,
   buildDirectoryClean,
-  assetManifestFile = false,
+  assetManifestFile,
   assetManifestFileRelativeUrl,
-  sourcemapExcludeSources,
-  writeOnFileSystem,
-
-  format,
-  systemJsUrl,
-  globalName,
-  globals,
-  babelPluginMap,
-  runtimeSupport,
 
   urlMappings,
   importResolutionMethod,
   importMapFileRelativeUrl,
   importDefaultExtension,
   externalImportSpecifiers,
-  importPaths,
   preservedUrls,
+  importPaths,
+
+  format,
+  systemJsUrl,
+  globalName,
+  globals,
   workers,
   serviceWorkers,
   serviceWorkerFinalizer,
   classicWorkers,
   classicServiceWorkers,
 
+  node,
+  browser,
+  compileServer,
+  compileProfile,
+  compileId,
+
   urlVersioning,
   lineBreakNormalization,
-  jsConcatenation,
-  cssConcatenation,
   useImportMapToMaximizeCacheReuse,
   preserveEntrySignatures,
   treeshake,
+  jsConcatenation,
+  cssConcatenation,
 
   minify,
+  minifyHtmlOptions,
   minifyJsOptions,
   minifyCssOptions,
-  minifyHtmlOptions,
-}) => {
-  const node = isNodePartOfSupportedRuntimes(runtimeSupport)
-  const browser = isBrowserPartOfSupportedRuntimes(runtimeSupport)
-
-  const runtimeCompatMap = createRuntimeCompat({
-    runtimeSupport,
-    featureNames: ["import_assertion_type_json", "import_assertion_type_css"],
-  })
-  const importAssertionsSupport = {
-    json:
-      format === "esmodule" &&
-      !runtimeCompatMap.missingFeatureNames.includes(
-        "import_assertion_type_json",
-      ),
-    css:
-      format === "esmodule" &&
-      !runtimeCompatMap.missingFeatureNames.includes(
-        "import_assertion_type_json",
-      ),
-  }
 
+  writeOnFileSystem,
+  sourcemapExcludeSources,
+}) => {
   const {
     rollupPlugins,
     getLastErrorMessage,
@@ -97,18 +75,10 @@ export const buildUsingRollup = async ({
 
     projectDirectoryUrl,
     entryPoints,
-    compileServerOrigin,
-    compileDirectoryRelativeUrl,
-    jsenvDirectoryRelativeUrl,
     buildDirectoryUrl,
 
     format,
     systemJsUrl,
-    babelPluginMap,
-    node,
-    browser,
-    importAssertionsSupport,
-
     urlMappings,
     importResolutionMethod,
     importMapFileRelativeUrl,
@@ -122,6 +92,12 @@ export const buildUsingRollup = async ({
     classicWorkers,
     classicServiceWorkers,
 
+    node,
+    browser,
+    compileServer,
+    compileProfile,
+    compileId,
+
     urlVersioning,
     lineBreakNormalization,
     jsConcatenation,
@@ -140,7 +116,7 @@ export const buildUsingRollup = async ({
       logger,
 
       rollupPlugins,
-      babelPluginMap,
+      compileProfile,
       format,
       globals,
       globalName,
@@ -246,7 +222,7 @@ const useRollup = async ({
   buildOperation,
   logger,
   rollupPlugins,
-  babelPluginMap,
+  compileProfile,
   format,
   globals,
   globalName,
@@ -319,10 +295,18 @@ const useRollup = async ({
     // experimentalTopLevelAwait: true,
     // https://rollupjs.org/guide/en/#outputgeneratedcode
     generatedCode: {
-      arrowFunctions: !babelPluginMap["transform-arrow-functions"],
-      constBindings: !babelPluginMap["transform-block-scoping"],
-      objectShorthand: !babelPluginMap["transform-shorthand-properties"],
-      reservedNamesAsProps: !babelPluginMap["transform-reserved-words"],
+      arrowFunctions:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-arrow-functions"],
+      constBindings:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-block-scoping"],
+      objectShorthand:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-shorthand-properties"],
+      reservedNamesAsProps:
+        compileProfile &&
+        !compileProfile.missingFeatures["transform-reserved-words"],
     },
     // https://rollupjs.org/guide/en#output-dir
     dir: urlToFileSystemPath(buildDirectoryUrl),

package/src/internal/building/html/parseHtmlRessource.js

@@ -17,6 +17,8 @@ Or be sure to also reference this url somewhere in the html file like
 */
 
 import { urlToFilename, urlToRelativeUrl, resolveUrl } from "@jsenv/filesystem"
+import { applyAlgoToRepresentationData } from "@jsenv/integrity"
+
 
 import {
   parseHtmlString,
@@ -48,7 +50,6 @@ import { collectNodesMutations } from "../parsing.utils.js"
 
 import { collectSvgMutations } from "../svg/parseSvgRessource.js"
 import { moveCssUrls } from "../css/moveCssUrls.js"
-import { applyAlgoToRepresentationData } from "../../integrity/integrity_algorithms.js"
 
 export const parseHtmlRessource = async (
   htmlRessource,

package/src/internal/building/rollup_plugin_jsenv.js

@@ -32,6 +32,7 @@ import { createImportResolverForImportmap } from "@jsenv/core/src/internal/impor
 import { getDefaultImportmap } from "@jsenv/core/src/internal/import-resolution/importmap_default.js"
 import { createJsenvRemoteDirectory } from "@jsenv/core/src/internal/jsenv_remote_directory.js"
 import { setUrlSearchParamsDescriptor } from "@jsenv/core/src/internal/url_utils.js"
+import { shakeBabelPluginMap } from "@jsenv/core/src/internal/compiling/jsenv_directory/compile_profile.js"
 
 import {
   formatBuildStartLog,
@@ -56,9 +57,6 @@ export const createRollupPlugins = async ({
 
   projectDirectoryUrl,
   entryPoints,
-  compileServerOrigin,
-  compileDirectoryRelativeUrl,
-  jsenvDirectoryRelativeUrl,
   buildDirectoryUrl,
 
   urlMappings,
@@ -73,12 +71,13 @@ export const createRollupPlugins = async ({
   serviceWorkerFinalizer,
   classicWorkers,
   classicServiceWorkers,
-
   format,
   systemJsUrl,
-  babelPluginMap,
+
   node,
-  importAssertionsSupport,
+  compileServer,
+  compileProfile,
+  compileId,
 
   urlVersioning,
   lineBreakNormalization,
@@ -91,6 +90,29 @@ export const createRollupPlugins = async ({
   minifyCssOptions,
   minifyHtmlOptions,
 }) => {
+  const compileServerOrigin = compileServer.origin
+  // For now the compilation is forced during build because this plugin
+  // was coded assuming build always requires to be compiled.
+  // Ideally jsenv should also be able to build a project using source files
+  // and in that case compileProfile and compileId are null
+  // the babel plugin map is useless (we can just fetch the source file directly)
+  const jsenvDirectoryRelativeUrl = compileServer.jsenvDirectoryRelativeUrl
+  const compileDirectoryRelativeUrl = `${jsenvDirectoryRelativeUrl}${compileId}/`
+  const babelPluginMap = shakeBabelPluginMap({
+    babelPluginMap: compileServer.babelPluginMap,
+    compileProfile,
+  })
+  const importAssertionsSupport = {
+    json:
+      format === "esmodule" &&
+      compileProfile &&
+      !compileProfile.missingFeatures["import_assertion_type_json"],
+    css:
+      format === "esmodule" &&
+      compileProfile &&
+      !compileProfile.missingFeatures["import_assertion_type_css"],
+  }
+
   const jsenvRemoteDirectory = createJsenvRemoteDirectory({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
@@ -433,7 +455,6 @@ export const createRollupPlugins = async ({
               asCompiledServerUrl(importMapInfoFromHtml.htmlUrl),
             )
             importMapUrl = applyUrlMappings(importMapUrl)
-
             if (!urlIsInsideOf(importMapUrl, compileDirectoryServerUrl)) {
               logger.warn(
                 formatImportmapOutsideCompileDirectory({
@@ -442,7 +463,6 @@ export const createRollupPlugins = async ({
                 }),
               )
             }
-
             fetchImportMap = () => {
               return fetchImportMapFromUrl(
                 importMapUrl,

package/src/internal/compiling/babel_parse_error.js

@@ -0,0 +1,9 @@
+export const createParseError = ({ message, cause, ...data }) => {
+  const parseError = new Error(message, { cause })
+  parseError.code = "PARSE_ERROR"
+  parseError.data = {
+    message,
+    ...data,
+  }
+  return parseError
+}

package/src/internal/{babel_plugin_transform_import_meta.js → compiling/babel_plugin_transform_import_meta.js}

@@ -4,23 +4,75 @@
 
 import { require } from "@jsenv/core/src/internal/require.js"
 
-export const babelPluginTransformImportMeta = (api, pluginOptions) => {
+import { createParseError } from "./babel_parse_error.js"
+
+export const babelPluginTransformImportMeta = (api, { importMetaFormat }) => {
   const {
     addNamespace,
     addDefault,
     addNamed,
   } = require("@babel/helper-module-imports")
   const { parseExpression } = require("@babel/parser")
-
-  const { replaceImportMeta } = pluginOptions
-
   let babelState
   const jsValueToAst = (jsValue) => {
     const valueAst = parseExpression(jsValue, babelState.opts)
     return valueAst
   }
+  const visitImportMetaProperty = ({
+    importMetaPropertyName,
+    replaceWithImport,
+    replaceWithValue,
+  }) => {
+    if (importMetaPropertyName === "url") {
+      if (importMetaFormat === "esmodule") {
+        // keep native version
+        return
+      }
+      if (importMetaFormat === "systemjs") {
+        // systemjs will handle it
+        return
+      }
+      if (importMetaFormat === "commonjs") {
+        replaceWithImport({
+          from: `@jsenv/core/helpers/import-meta/import-meta-url-commonjs.js`,
+        })
+        return
+      }
+      if (importMetaFormat === "global") {
+        replaceWithImport({
+          from: `@jsenv/core/helpers/import-meta/import-meta-url-global.js`,
+        })
+        return
+      }
+      return
+    }
+    if (importMetaPropertyName === "resolve") {
+      if (importMetaFormat === "esmodule") {
+        // keep native version
+        return
+      }
+      if (importMetaFormat === "systemjs") {
+        // systemjs will handle it
+        return
+      }
+      if (importMetaFormat === "commonjs") {
+        throw createParseError({
+          message: `import.meta.resolve() not supported with commonjs format`,
+        })
+      }
+      if (importMetaFormat === "global") {
+        throw createParseError({
+          message: `import.meta.resolve() not supported with global format`,
+        })
+      }
+      return
+    }
+    replaceWithValue(undefined)
+  }
 
   return {
+    name: "transform-import-meta",
+
     pre: (state) => {
       babelState = state
     },
@@ -53,7 +105,6 @@ export const babelPluginTransformImportMeta = (api, pluginOptions) => {
     visitor: {
       Program(programPath) {
         const metaPropertyPathMap = {}
-
         programPath.traverse({
           MemberExpression(path) {
             const { node } = path
@@ -61,12 +112,10 @@ export const babelPluginTransformImportMeta = (api, pluginOptions) => {
             if (object.type !== "MetaProperty") {
               return
             }
-
             const { property: objectProperty } = object
             if (objectProperty.name !== "meta") {
               return
             }
-
             const { property } = node
             const { name } = property
             if (name in metaPropertyPathMap) {
@@ -76,9 +125,9 @@ export const babelPluginTransformImportMeta = (api, pluginOptions) => {
             }
           },
         })
-
         Object.keys(metaPropertyPathMap).forEach((importMetaPropertyName) => {
-          replaceImportMeta(importMetaPropertyName, {
+          visitImportMetaProperty({
+            importMetaPropertyName,
             replaceWithImport: ({ namespace, name, from, nameHint }) => {
               let importAst
               if (namespace) {

package/src/internal/compiling/compileFile.js

@@ -7,8 +7,8 @@ import {
 } from "@jsenv/filesystem"
 import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
 
-import { getOrGenerateCompiledFile } from "./compile-directory/getOrGenerateCompiledFile.js"
-import { updateMeta } from "./compile-directory/updateMeta.js"
+import { getOrGenerateCompiledFile } from "./jsenv_directory/getOrGenerateCompiledFile.js"
+import { updateMeta } from "./jsenv_directory/updateMeta.js"
 
 export const compileFile = async ({
   logger,