@jsenv/core 41.4.3 → 41.4.5

package/dist/start_dev_server/start_dev_server.js

@@ -1321,7 +1321,9 @@ const jsenvPluginClientMonitoring = () => {
 
 /*
  * cmd+K (ctrl+K elsewhere) on any page the dev server serves opens a list of
- * the .html files it serves, filter as you type, Enter to go there.
+ * the .html files it serves, filter as you type, Enter to go there. cmd+E
+ * (ctrl+E elsewhere) opens a page's file in the editor instead of going to it:
+ * the current page from anywhere, the selected row from inside the switcher.
  *
  * The list is the one the filesystem plugin already publishes for everyone
  * (GET /.internal/pages.json, see protocol_file/html_pages.js) — this only adds
@@ -3327,7 +3329,9 @@ const FILE_AND_SERVER_URLS_CONVERTER = {
  * of them, the page switcher (cmd+K) opens one in the current tab. Whoever asks
  * gets the same answer.
  *
- * Each page comes with what kind of page it is, read from where it sits and
+ * Each page comes with where its file is (so it can be opened in an editor as
+ * well as in the browser) and with what kind of page it is, read from where it
+ * sits and
  * what it is called — the two conventions this repo already follows:
  * - "experiment": something tried out, under a lab/ directory or named
  *   *_experiment.html;
@@ -3426,6 +3430,10 @@ const createHtmlPageLister = ({ rootDirectoryUrl }) => {
       );
       return {
         url: `/${relativeUrl}`,
+        // Where the file actually is, so whoever wants to open it in an editor
+        // rather than in the browser has what GET /.internal/open_file/* asks
+        // for (a file url) without having to know the root directory.
+        fileUrl,
         kind: readKind(meta),
         // Relative to the root and without its trailing slash, which is how a
         // tree names its own nodes.
@@ -4092,6 +4100,10 @@ const jsenvPluginFsRedirection = ({
           }
           const { requestedUrl, rootDirectoryUrl, mainFilePath } =
             reference.ownerUrlInfo.context;
+          if (!requestedUrl) {
+            // the SPA fallback answers a request; during build there is none
+            return null;
+          }
           const closestHtmlRootFile = getClosestHtmlRootFile(
             requestedUrl,
             rootDirectoryUrl,
@@ -4551,6 +4563,7 @@ ${reason}`,
   }
   return createFailedToResolveUrlError({
     reason: `An error occured during specifier resolution`,
+    ...detailsFromInjectionsOnOwner(reference),
     ...detailsFromValueThrown(error),
   });
 };
@@ -4612,6 +4625,7 @@ ${reason}`,
       return createFailedToFetchUrlContentError({
         code: "NOT_FOUND",
         reason: "no entry on filesystem",
+        ...detailsFromInjectionsOnOwner(urlInfo.firstReference),
       });
     }
   }
@@ -4844,6 +4858,32 @@ const getFirstReferenceInProject = (reference) => {
   return getFirstReferenceInProject(firstReference);
 };
 
+// An url written by an injection cannot be resolved: the placeholder is still there
+// when references are analyzed. Rather than guessing what a placeholder looks like
+// (the key is free-form), tell the file it comes from: injections are configured for it.
+const detailsFromInjectionsOnOwner = (reference) => {
+  if (!reference) {
+    return {};
+  }
+  const ownerUrlInfo = reference.ownerUrlInfo;
+  if (ownerUrlInfo.type !== "html") {
+    // "jsenv-ignore" is an html attribute
+    return {};
+  }
+  const { hasInjections } = ownerUrlInfo.context;
+  if (!hasInjections || !hasInjections(ownerUrlInfo.url)) {
+    return {};
+  }
+  const { node, attributeName } = reference.astInfo || {};
+  if (!node || !attributeName) {
+    return {};
+  }
+  return {
+    suggestion: `injections are configured for this file; when "${reference.specifier}" is meant to be written by one of them, add "jsenv-ignore" so jsenv leaves that url alone:
+<${node.nodeName} jsenv-ignore ${attributeName}="${reference.specifier}" />`,
+  };
+};
+
 const detailsFromPluginController = (jsenvPluginsController) => {
   const currentPlugin = jsenvPluginsController.getCurrentPlugin();
   if (!currentPlugin) {
@@ -4986,11 +5026,21 @@ const jsenvPluginDirectoryReferenceEffect = (
 
 const injectionSymbol = Symbol.for("jsenv_injection");
 const INJECTIONS = {
+  /**
+   * Inject `Object.assign(window, { [key]: value })` at the top of the file
+   * (into a script for html, into the module itself for js) instead of
+   * replacing a placeholder: the value is read at runtime as a global.
+   */
   global: (value) => {
     return { [injectionSymbol]: "global", value };
   },
+  /**
+   * Replace the placeholder when the file contains it, stay silent when it does not
+   * (without this a missing placeholder is reported as a warning).
+   */
   optional: (value) => {
-    if (value && value[injectionSymbol] === "optional") {
+    if (value && value[injectionSymbol]) {
+      // a global injection is not a placeholder, it can't be missing from the file
       return value;
     }
     return { [injectionSymbol]: "optional", value };
@@ -5095,12 +5145,7 @@ return {
       magicSource.replace({
         start,
         end,
-        replacement:
-          urlInfo.type === "js_classic" ||
-          urlInfo.type === "js_module" ||
-          urlInfo.type === "html"
-            ? JSON.stringify(value, null, "  ")
-            : value,
+        replacement: asReplacement(value, urlInfo),
       });
       index = content.indexOf(key, end);
     }
@@ -5108,6 +5153,19 @@ return {
   return magicSource.toContentAndSourcemap();
 };
 
+// In JS the placeholder stands for a value, so it must be substituted by a literal.
+// Everywhere else (html attributes and text, css, ...) it stands for a piece of text
+// and is substituted as-is, so it can be concatenated: href="__BACKEND_URL__/users/me"
+const asReplacement = (value, urlInfo) => {
+  if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
+    return JSON.stringify(value, null, "  ");
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value, null, "  ");
+};
+
 const injectGlobals = (content, globals, urlInfo) => {
   if (urlInfo.type === "html") {
     return globalInjectorOnHtml(content, globals, urlInfo);
@@ -5115,7 +5173,14 @@ const injectGlobals = (content, globals, urlInfo) => {
   if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
     return globalsInjectorOnJs(content, globals, urlInfo);
   }
-  throw new Error(`cannot inject globals into "${urlInfo.type}"`);
+  throw new Error(
+    createDetailedMessage(`cannot inject globals into "${urlInfo.type}"`, {
+      file: urlInfo.url,
+      ...(urlInfo.isInline
+        ? { "inline content of": urlInfo.inlineUrlSite.url }
+        : {}),
+    }),
+  );
 };
 const globalInjectorOnHtml = (content, globals, urlInfo) => {
   // ideally we would inject an importmap but browser support is too low
@@ -5181,18 +5246,52 @@ const jsenvPluginInjections = (rawAssociations) => {
           { injectionsGetter: rawAssociations },
           context.rootDirectoryUrl,
         );
-        getInjections = (urlInfo) => {
+        const findInjectionsGetterForUrl = (url) => {
           const { injectionsGetter } = URL_META.applyAssociations({
-            url: asUrlWithoutSearch(urlInfo.url),
+            url: asUrlWithoutSearch(url),
             associations: resolvedAssociations,
           });
-          if (!injectionsGetter) {
+          return injectionsGetter;
+        };
+        // an url written by an injection cannot be resolved during reference analysis;
+        // errors use this to tell the file holds injections and suggest "jsenv-ignore"
+        context.hasInjections = (url) => {
+          return Boolean(findInjectionsGetterForUrl(url));
+        };
+        const findInjectionsGetter = (urlInfo) => {
+          const injectionsGetter = findInjectionsGetterForUrl(urlInfo.url);
+          if (injectionsGetter) {
+            return { injectionsGetter, isInherited: false };
+          }
+          if (urlInfo.isInline) {
+            // content inlined into a file (a <script> inside html) is authored in that
+            // file, so injections configured for the file must reach it too
+            const found = findInjectionsGetter(
+              urlInfo.firstReference.ownerUrlInfo,
+            );
+            if (found) {
+              return {
+                injectionsGetter: found.injectionsGetter,
+                isInherited: true,
+              };
+            }
+          }
+          return null;
+        };
+        getInjections = async (urlInfo) => {
+          const found = findInjectionsGetter(urlInfo);
+          if (!found) {
             return null;
           }
+          const { injectionsGetter, isInherited } = found;
           if (typeof injectionsGetter !== "function") {
             throw new TypeError("injectionsGetter must be a function");
           }
-          return injectionsGetter(urlInfo);
+          const injections = await injectionsGetter(urlInfo);
+          if (!injections || !isInherited) {
+            return injections;
+          }
+          return asInheritedInjections(injections);
         };
       }
     },
@@ -5203,13 +5302,12 @@ const jsenvPluginInjections = (rawAssociations) => {
           contentInjections: defaultInjections,
         };
       }
-      const injectionsResult = getInjections(urlInfo);
-      if (!injectionsResult) {
+      const injections = await getInjections(urlInfo);
+      if (!injections) {
         return {
           contentInjections: defaultInjections,
         };
       }
-      const injections = await injectionsResult;
       return {
         contentInjections: {
           ...defaultInjections,
@@ -5220,6 +5318,26 @@ const jsenvPluginInjections = (rawAssociations) => {
   };
 };
 
+// What a file inlines (a <script> or a <style> inside html) is authored in that file
+// and inherits its injections, with two adjustments:
+// - a global belongs to the file itself, injecting it into each inline content would
+//   repeat it and reach types that cannot receive globals (css)
+// - a placeholder configured for the file is expected in one of its inline contents,
+//   not in each, so a missing one is not worth a warning
+const asInheritedInjections = (injections) => {
+  const inheritedInjections = {};
+  for (const key of Object.keys(injections)) {
+    const value = injections[key];
+    if (isPlaceholderInjection(value)) {
+      inheritedInjections[key] = INJECTIONS.optional(value);
+    }
+  }
+  if (Object.keys(inheritedInjections).length === 0) {
+    return null;
+  }
+  return inheritedInjections;
+};
+
 const jsenvPluginInliningAsDataUrl = () => {
   return {
     name: "jsenv:inlining_as_data_url",
@@ -11434,6 +11552,7 @@ const EXECUTED_BY_TEST_PLAN = process.argv.includes("--jsenv-test");
  * @param {boolean} [params.ribbon=true] - The dev "ribbon" overlay.
  * @param {boolean} [params.supervisor=true] - Script supervisor (better error reporting).
  * @param {boolean|object} [params.directoryListing=true] - Directory listing pages.
+ * @param {object} [params.injections] - Values to inject into files, as `{ urlPattern: getInjections }`. Keys are url patterns relative to sourceDirectoryUrl (`"./index.html"`, `"**\/*.js"`), values are functions receiving `urlInfo` and returning (or resolving to) an object of placeholders to replace, named `__LIKE_THIS__` by convention. In JS the value is injected as a JS literal (a string brings its own quotes), everywhere else as-is so it can be concatenated: `href="__BACKEND_URL__/users/me"`. An html url pattern also covers what is inlined in that html, so `<script>window.backendUrl = __BACKEND_URL__;</script>` shares the value with every js file of the page. See `INJECTIONS.optional` and `INJECTIONS.global`.
  * @param {object} [params.runtimeCompat] - Target runtimes; warns when dev code wouldn't survive the build.
  * @param {string} [params.sourcemaps="inline"] - Sourcemap mode.
  * @param {AbortSignal} [params.signal] - Abort to stop the server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "41.4.3",
+  "version": "41.4.5",
   "type": "module",
   "description": "Tool to develop, test and build js projects",
   "repository": {
@@ -72,12 +72,12 @@
     "test:snapshot_clear": "npx @jsenv/filesystem clear **/tests/**/side_effects/"
   },
   "dependencies": {
-    "@jsenv/ast": "6.8.4",
-    "@jsenv/js-module-fallback": "1.4.37",
+    "@jsenv/ast": "6.8.5",
+    "@jsenv/js-module-fallback": "1.4.38",
     "@jsenv/plugin-bundling": "2.10.16",
-    "@jsenv/plugin-minification": "1.7.5",
-    "@jsenv/plugin-supervisor": "1.8.8",
-    "@jsenv/plugin-transpilation": "1.5.78",
+    "@jsenv/plugin-minification": "1.7.6",
+    "@jsenv/plugin-supervisor": "1.8.9",
+    "@jsenv/plugin-transpilation": "1.5.79",
     "@jsenv/server": "17.6.0",
     "@jsenv/sourcemap": "1.4.2",
     "react-table": "7.8.0"

package/src/build/build.js

@@ -133,6 +133,25 @@ import { jsenvPluginMappings } from "./jsenv_plugin_mappings.js";
  *        How URLs are versioned for this entry point (defaults to "search_param")
  * @param {('none'|'inline'|'file'|'programmatic')} [entryPoint.sourcemaps]
  *        Sourcemap generation strategy for this entry point (defaults to "none")
+ * @param {object} [entryPoint.injections]
+ *        Values to inject into files, as { urlPattern: getInjections }.
+ *        Keys are url patterns relative to sourceDirectoryUrl ("./index.html", "**\/*.js"),
+ *        values are functions receiving urlInfo and returning (or resolving to)
+ *        an object of placeholders to replace, named `__LIKE_THIS__` by convention:
+ *
+ *          injections: {
+ *            "./index.html": () => ({ __BACKEND_URL__: "https://api.example.com" }),
+ *          }
+ *
+ *        In JS files the value is injected as a JS literal (a string value brings its own quotes),
+ *        everywhere else it is injected as-is, so it can be concatenated:
+ *        `href="__BACKEND_URL__/users/me"`.
+ *        An html url pattern also covers what is inlined in that html: an inline
+ *        `<script>window.backendUrl = __BACKEND_URL__;</script>` gets the JS literal,
+ *        which is how a value is shared with every js file of the page.
+ *        Use INJECTIONS.optional(value) for a placeholder that may be absent from the file
+ *        and INJECTIONS.global(value) to inject `Object.assign(window, { ... })` instead of
+ *        replacing a placeholder.
  *
  * @return {Promise<Object>} buildReturnValue
  * @return {Promise<Object>} [buildReturnValue.buildInlineContents]
@@ -170,6 +189,17 @@ export const build = async ({
   {
     const unexpectedParamNames = Object.keys(rest);
     if (unexpectedParamNames.length > 0) {
+      const entryPointParamNames = unexpectedParamNames.filter((name) =>
+        Object.hasOwn(entryPointDefaultParams, name),
+      );
+      if (entryPointParamNames.length > 0) {
+        throw new TypeError(
+          `${entryPointParamNames.join(",")}: param(s) configured per entry point, move them into entryPoints, as in:
+entryPoints: {
+  "./index.html": { ${entryPointParamNames.map((name) => `${name}: ...`).join(", ")} },
+}`,
+        );
+      }
       throw new TypeError(
         `${unexpectedParamNames.join(",")}: there is no such param`,
       );

package/src/build/build_specifier_manager.js

@@ -898,6 +898,11 @@ export const createBuildSpecifierManager = ({
       registerHtmlRefine((htmlAst, { registerHtmlMutation }) => {
         visitHtmlNodes(htmlAst, {
           link: (node) => {
+            if (getHtmlNodeAttribute(node, "jsenv-ignore") !== undefined) {
+              // reference analysis skipped this node, so it has no urlInfo in the graph
+              // and there is nothing to resync
+              return;
+            }
             const href = getHtmlNodeAttribute(node, "href");
             if (href === undefined || href.startsWith("data:")) {
               return;

package/src/dev/start_dev_server.js

@@ -51,6 +51,7 @@ const EXECUTED_BY_TEST_PLAN = process.argv.includes("--jsenv-test");
  * @param {boolean} [params.ribbon=true] - The dev "ribbon" overlay.
  * @param {boolean} [params.supervisor=true] - Script supervisor (better error reporting).
  * @param {boolean|object} [params.directoryListing=true] - Directory listing pages.
+ * @param {object} [params.injections] - Values to inject into files, as `{ urlPattern: getInjections }`. Keys are url patterns relative to sourceDirectoryUrl (`"./index.html"`, `"**\/*.js"`), values are functions receiving `urlInfo` and returning (or resolving to) an object of placeholders to replace, named `__LIKE_THIS__` by convention. In JS the value is injected as a JS literal (a string brings its own quotes), everywhere else as-is so it can be concatenated: `href="__BACKEND_URL__/users/me"`. An html url pattern also covers what is inlined in that html, so `<script>window.backendUrl = __BACKEND_URL__;</script>` shares the value with every js file of the page. See `INJECTIONS.optional` and `INJECTIONS.global`.
  * @param {object} [params.runtimeCompat] - Target runtimes; warns when dev code wouldn't survive the build.
  * @param {string} [params.sourcemaps="inline"] - Sourcemap mode.
  * @param {AbortSignal} [params.signal] - Abort to stop the server.

package/src/kitchen/errors.js

@@ -78,6 +78,7 @@ ${reason}`,
   }
   return createFailedToResolveUrlError({
     reason: `An error occured during specifier resolution`,
+    ...detailsFromInjectionsOnOwner(reference),
     ...detailsFromValueThrown(error),
   });
 };
@@ -139,6 +140,7 @@ ${reason}`,
       return createFailedToFetchUrlContentError({
         code: "NOT_FOUND",
         reason: "no entry on filesystem",
+        ...detailsFromInjectionsOnOwner(urlInfo.firstReference),
       });
     }
   }
@@ -371,6 +373,32 @@ const getFirstReferenceInProject = (reference) => {
   return getFirstReferenceInProject(firstReference);
 };
 
+// An url written by an injection cannot be resolved: the placeholder is still there
+// when references are analyzed. Rather than guessing what a placeholder looks like
+// (the key is free-form), tell the file it comes from: injections are configured for it.
+const detailsFromInjectionsOnOwner = (reference) => {
+  if (!reference) {
+    return {};
+  }
+  const ownerUrlInfo = reference.ownerUrlInfo;
+  if (ownerUrlInfo.type !== "html") {
+    // "jsenv-ignore" is an html attribute
+    return {};
+  }
+  const { hasInjections } = ownerUrlInfo.context;
+  if (!hasInjections || !hasInjections(ownerUrlInfo.url)) {
+    return {};
+  }
+  const { node, attributeName } = reference.astInfo || {};
+  if (!node || !attributeName) {
+    return {};
+  }
+  return {
+    suggestion: `injections are configured for this file; when "${reference.specifier}" is meant to be written by one of them, add "jsenv-ignore" so jsenv leaves that url alone:
+<${node.nodeName} jsenv-ignore ${attributeName}="${reference.specifier}" />`,
+  };
+};
+
 const detailsFromPluginController = (jsenvPluginsController) => {
   const currentPlugin = jsenvPluginsController.getCurrentPlugin();
   if (!currentPlugin) {

package/src/kitchen/url_graph/url_info_injections.js

@@ -1,13 +1,24 @@
 import { injectJsenvScript, parseHtml, stringifyHtmlAst } from "@jsenv/ast";
+import { createDetailedMessage } from "@jsenv/humanize";
 import { composeTwoSourcemaps, createMagicSource } from "@jsenv/sourcemap";
 
 const injectionSymbol = Symbol.for("jsenv_injection");
 export const INJECTIONS = {
+  /**
+   * Inject `Object.assign(window, { [key]: value })` at the top of the file
+   * (into a script for html, into the module itself for js) instead of
+   * replacing a placeholder: the value is read at runtime as a global.
+   */
   global: (value) => {
     return { [injectionSymbol]: "global", value };
   },
+  /**
+   * Replace the placeholder when the file contains it, stay silent when it does not
+   * (without this a missing placeholder is reported as a warning).
+   */
   optional: (value) => {
-    if (value && value[injectionSymbol] === "optional") {
+    if (value && value[injectionSymbol]) {
+      // a global injection is not a placeholder, it can't be missing from the file
       return value;
     }
     return { [injectionSymbol]: "optional", value };
@@ -112,12 +123,7 @@ return {
       magicSource.replace({
         start,
         end,
-        replacement:
-          urlInfo.type === "js_classic" ||
-          urlInfo.type === "js_module" ||
-          urlInfo.type === "html"
-            ? JSON.stringify(value, null, "  ")
-            : value,
+        replacement: asReplacement(value, urlInfo),
       });
       index = content.indexOf(key, end);
     }
@@ -125,6 +131,19 @@ return {
   return magicSource.toContentAndSourcemap();
 };
 
+// In JS the placeholder stands for a value, so it must be substituted by a literal.
+// Everywhere else (html attributes and text, css, ...) it stands for a piece of text
+// and is substituted as-is, so it can be concatenated: href="__BACKEND_URL__/users/me"
+const asReplacement = (value, urlInfo) => {
+  if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
+    return JSON.stringify(value, null, "  ");
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value, null, "  ");
+};
+
 export const injectGlobals = (content, globals, urlInfo) => {
   if (urlInfo.type === "html") {
     return globalInjectorOnHtml(content, globals, urlInfo);
@@ -132,7 +151,14 @@ export const injectGlobals = (content, globals, urlInfo) => {
   if (urlInfo.type === "js_classic" || urlInfo.type === "js_module") {
     return globalsInjectorOnJs(content, globals, urlInfo);
   }
-  throw new Error(`cannot inject globals into "${urlInfo.type}"`);
+  throw new Error(
+    createDetailedMessage(`cannot inject globals into "${urlInfo.type}"`, {
+      file: urlInfo.url,
+      ...(urlInfo.isInline
+        ? { "inline content of": urlInfo.inlineUrlSite.url }
+        : {}),
+    }),
+  );
 };
 const globalInjectorOnHtml = (content, globals, urlInfo) => {
   // ideally we would inject an importmap but browser support is too low

package/src/plugins/injections/jsenv_plugin_injections.js

@@ -1,6 +1,9 @@
 import { URL_META } from "@jsenv/url-meta";
 import { asUrlWithoutSearch, urlToRelativeUrl } from "@jsenv/urls";
-import { INJECTIONS } from "../../kitchen/url_graph/url_info_injections.js";
+import {
+  INJECTIONS,
+  isPlaceholderInjection,
+} from "../../kitchen/url_graph/url_info_injections.js";
 
 export const jsenvPluginInjections = (rawAssociations) => {
   const getDefaultInjections = (urlInfo) => {
@@ -26,18 +29,52 @@ export const jsenvPluginInjections = (rawAssociations) => {
           { injectionsGetter: rawAssociations },
           context.rootDirectoryUrl,
         );
-        getInjections = (urlInfo) => {
+        const findInjectionsGetterForUrl = (url) => {
           const { injectionsGetter } = URL_META.applyAssociations({
-            url: asUrlWithoutSearch(urlInfo.url),
+            url: asUrlWithoutSearch(url),
             associations: resolvedAssociations,
           });
-          if (!injectionsGetter) {
+          return injectionsGetter;
+        };
+        // an url written by an injection cannot be resolved during reference analysis;
+        // errors use this to tell the file holds injections and suggest "jsenv-ignore"
+        context.hasInjections = (url) => {
+          return Boolean(findInjectionsGetterForUrl(url));
+        };
+        const findInjectionsGetter = (urlInfo) => {
+          const injectionsGetter = findInjectionsGetterForUrl(urlInfo.url);
+          if (injectionsGetter) {
+            return { injectionsGetter, isInherited: false };
+          }
+          if (urlInfo.isInline) {
+            // content inlined into a file (a <script> inside html) is authored in that
+            // file, so injections configured for the file must reach it too
+            const found = findInjectionsGetter(
+              urlInfo.firstReference.ownerUrlInfo,
+            );
+            if (found) {
+              return {
+                injectionsGetter: found.injectionsGetter,
+                isInherited: true,
+              };
+            }
+          }
+          return null;
+        };
+        getInjections = async (urlInfo) => {
+          const found = findInjectionsGetter(urlInfo);
+          if (!found) {
             return null;
           }
+          const { injectionsGetter, isInherited } = found;
           if (typeof injectionsGetter !== "function") {
             throw new TypeError("injectionsGetter must be a function");
           }
-          return injectionsGetter(urlInfo);
+          const injections = await injectionsGetter(urlInfo);
+          if (!injections || !isInherited) {
+            return injections;
+          }
+          return asInheritedInjections(injections);
         };
       }
     },
@@ -48,13 +85,12 @@ export const jsenvPluginInjections = (rawAssociations) => {
           contentInjections: defaultInjections,
         };
       }
-      const injectionsResult = getInjections(urlInfo);
-      if (!injectionsResult) {
+      const injections = await getInjections(urlInfo);
+      if (!injections) {
         return {
           contentInjections: defaultInjections,
         };
       }
-      const injections = await injectionsResult;
       return {
         contentInjections: {
           ...defaultInjections,
@@ -64,3 +100,23 @@ export const jsenvPluginInjections = (rawAssociations) => {
     },
   };
 };
+
+// What a file inlines (a <script> or a <style> inside html) is authored in that file
+// and inherits its injections, with two adjustments:
+// - a global belongs to the file itself, injecting it into each inline content would
+//   repeat it and reach types that cannot receive globals (css)
+// - a placeholder configured for the file is expected in one of its inline contents,
+//   not in each, so a missing one is not worth a warning
+const asInheritedInjections = (injections) => {
+  const inheritedInjections = {};
+  for (const key of Object.keys(injections)) {
+    const value = injections[key];
+    if (isPlaceholderInjection(value)) {
+      inheritedInjections[key] = INJECTIONS.optional(value);
+    }
+  }
+  if (Object.keys(inheritedInjections).length === 0) {
+    return null;
+  }
+  return inheritedInjections;
+};