@jsenv/core 41.4.5 → 41.4.7

package/dist/start_dev_server/start_dev_server.js

@@ -2208,6 +2208,25 @@ const isWebWorkerUrlInfo = (urlInfo) => {
 //   return false
 // }
 
+// A bare specifier ("preact", "@jsenv/core/x.js") is resolved by node esm resolution,
+// everything else ("/a.js", "./a.js", "http://example.com/a.js") by url resolution
+const isBareSpecifier = (specifier) => {
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return false;
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier);
+    return false;
+  } catch {
+    return true;
+  }
+};
+
 const jsenvPluginJsReferenceAnalysis = ({ inlineContent }) => {
   return [
     {
@@ -2304,7 +2323,7 @@ const parseAndTransformJsReferences = async (
     let filenameHint;
     if (
       externalReferenceInfo.subtype === "import_dynamic" &&
-      isBareSpecifier$1(externalReferenceInfo.specifier)
+      isBareSpecifier(externalReferenceInfo.specifier)
     ) {
       filenameHint = `${externalReferenceInfo.specifier}.js`;
     }
@@ -2394,23 +2413,6 @@ const parseAndTransformJsReferences = async (
   return { content, sourcemap };
 };
 
-const isBareSpecifier$1 = (specifier) => {
-  if (
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
-  ) {
-    return false;
-  }
-  try {
-    // eslint-disable-next-line no-new
-    new URL(specifier);
-    return false;
-  } catch {
-    return true;
-  }
-};
-
 const jsenvPluginReferenceExpectedTypes = () => {
   const redirectJsReference = (reference) => {
     const urlObject = new URL(reference.url);
@@ -3080,23 +3082,6 @@ const createResolverWithFallbackOnError = (mainResolver, fallbackResolver) => {
   };
 };
 
-const isBareSpecifier = (specifier) => {
-  if (
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
-  ) {
-    return false;
-  }
-  try {
-    // eslint-disable-next-line no-new
-    new URL(specifier);
-    return false;
-  } catch {
-    return true;
-  }
-};
-
 const jsenvPluginNodeEsmResolution = ({
   packageDirectory,
   resolutionConfig = {},
@@ -3243,7 +3228,13 @@ const jsenvPluginWebResolution = () => {
         if (ownerUrlInfo.originalUrl?.startsWith("http")) {
           return new URL(resource, ownerUrlInfo.originalUrl);
         }
-        const url = new URL(resource.slice(1), ownerUrlInfo.entryUrlInfo.url);
+        // "/x" is the web meaning of a root-relative url: the root of what is
+        // served, which is the source directory — not the directory the entry
+        // point happens to sit in.
+        const url = new URL(
+          resource.slice(1),
+          ownerUrlInfo.context.rootDirectoryUrl,
+        );
         return url;
       }
       // baseUrl happens second argument to new URL() is different from
@@ -4858,9 +4849,10 @@ 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.
+// Injections write urls in html attributes before references are analyzed, so an url
+// that still cannot be resolved may be a placeholder no injection replaced. 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 {};
@@ -4879,7 +4871,7 @@ const detailsFromInjectionsOnOwner = (reference) => {
     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:
+    suggestion: `injections are configured for this file; when "${reference.specifier}" is meant to be written by one of them, check the placeholder spelling, or add "jsenv-ignore" so jsenv leaves that url alone:
 <${node.nodeName} jsenv-ignore ${attributeName}="${reference.specifier}" />`,
   };
 };
@@ -5047,6 +5039,13 @@ const INJECTIONS = {
   },
 };
 
+const readInjectionValue = (injection) => {
+  if (injection && injection[injectionSymbol]) {
+    return injection.value;
+  }
+  return injection;
+};
+
 const isPlaceholderInjection = (value) => {
   return (
     !value || !value[injectionSymbol] || value[injectionSymbol] !== "global"
@@ -5120,7 +5119,7 @@ const injectPlaceholderReplacements = (
   for (const { key, isOptional, value } of placeholderReplacements) {
     let index = content.indexOf(key);
     if (index === -1) {
-      if (!isOptional) {
+      if (!isOptional && !urlInfo.contentInjectionUsedKeySet.has(key)) {
         urlInfo.context.logger.warn(
           `placeholder "${key}" not found in ${urlInfo.url}.
 --- suggestion a ---
@@ -5145,7 +5144,7 @@ return {
       magicSource.replace({
         start,
         end,
-        replacement: asReplacement(value, urlInfo),
+        replacement: asReplacement(value, urlInfo.type),
       });
       index = content.indexOf(key, end);
     }
@@ -5156,8 +5155,8 @@ return {
 // 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") {
+const asReplacement = (value, type) => {
+  if (type === "js_classic" || type === "js_module") {
     return JSON.stringify(value, null, "  ");
   }
   if (typeof value === "string") {
@@ -5235,6 +5234,7 @@ const jsenvPluginInjections = (rawAssociations) => {
     }
     return null;
   };
+  const injectionsForUrlInfoMap = new WeakMap();
   let getInjections = null;
 
   return {
@@ -5253,8 +5253,8 @@ const jsenvPluginInjections = (rawAssociations) => {
           });
           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"
+        // errors and the build read this to know an unresolved url may come from
+        // an injection, and word what they report accordingly
         context.hasInjections = (url) => {
           return Boolean(findInjectionsGetterForUrl(url));
         };
@@ -5308,16 +5308,61 @@ const jsenvPluginInjections = (rawAssociations) => {
           contentInjections: defaultInjections,
         };
       }
+      injectionsForUrlInfoMap.set(urlInfo, injections);
       return {
-        contentInjections: {
-          ...defaultInjections,
-          ...injections,
-        },
+        contentInjections: { ...defaultInjections, ...injections },
       };
     },
+    // The content still holds the placeholders when references are analyzed: they are
+    // replaced at the very end, once the type of every inline content is known.
+    // A specifier must not wait for that, it would resolve "__BACKEND_URL__/users/me"
+    // as a file sitting next to the document. Only the placeholder is resolved here,
+    // then the specifier goes to whoever resolves this kind of url (node esm, web, ...)
+    resolveReference: (reference) => {
+      const { ownerUrlInfo } = reference;
+      const injections = injectionsForUrlInfoMap.get(ownerUrlInfo);
+      if (!injections) {
+        return null;
+      }
+      const { specifier, keySet } = injectIntoSpecifier(
+        reference.specifier,
+        injections,
+      );
+      if (keySet.size === 0) {
+        return null;
+      }
+      reference.specifier = specifier;
+      for (const key of keySet) {
+        // rewriting the specifier takes the placeholder out of the content,
+        // so the injection step must not expect to find it there
+        ownerUrlInfo.contentInjectionUsedKeySet.add(key);
+      }
+      return null;
+    },
   };
 };
 
+const injectIntoSpecifier = (specifier, injections) => {
+  let specifierInjected = specifier;
+  const keySet = new Set();
+  for (const key of Object.keys(injections)) {
+    if (!specifierInjected.includes(key)) {
+      continue;
+    }
+    const injection = injections[key];
+    if (!isPlaceholderInjection(injection)) {
+      continue;
+    }
+    const value = readInjectionValue(injection);
+    if (typeof value !== "string") {
+      continue;
+    }
+    specifierInjected = specifierInjected.replaceAll(key, value);
+    keySet.add(key);
+  }
+  return { specifier: specifierInjected, keySet };
+};
+
 // 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
@@ -7645,8 +7690,10 @@ const getCorePlugins = ({
     ...(packageBundle
       ? [jsenvPluginWorkspaceBundle({ packageDirectory })]
       : []),
-    jsenvPluginReferenceAnalysis(referenceAnalysis),
+    // before reference analysis: an url written by an injection must hold its
+    // final value when references are analyzed
     jsenvPluginInjections(injections),
+    jsenvPluginReferenceAnalysis(referenceAnalysis),
     jsenvPluginTranspilation(transpilation),
     // "jsenvPluginInlining" must be very soon because all other plugins will react differently once they see the file is inlined
     ...(inlining ? [jsenvPluginInlining()] : []),
@@ -9309,6 +9356,9 @@ const createUrlInfo = (url, context) => {
     contentFinalized: false,
     contentSideEffects: [],
     contentInjections: {},
+    // placeholders already consumed somewhere else than the content (in a specifier),
+    // so that not finding them in the content is not worth a warning
+    contentInjectionUsedKeySet: new Set(),
 
     sourcemap: null,
     sourcemapIsWrong: false,
@@ -11110,7 +11160,16 @@ const devServerPluginServeSourceFiles = ({
         }
       }
     });
-    const clientRuntimeCompat = { [runtimeName]: runtimeVersion };
+    // A client we cannot identify (curl, fetch, a healthcheck, a proxy dropping
+    // the user agent) is assumed to be one of the runtimes the project targets.
+    // Treating it as a runtime supporting nothing would serve it the js module
+    // fallback, breaking tooling perfectly capable of ES modules; an actual
+    // ancient browser hiding its identity fails loudly instead, which is the
+    // cheaper of the two mistakes.
+    const clientRuntimeCompat =
+      runtimeName === "unknown"
+        ? runtimeCompat
+        : { [runtimeName]: runtimeVersion };
 
     kitchen = createKitchen({
       name: runtimeId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "41.4.5",
+  "version": "41.4.7",
   "type": "module",
   "description": "Tool to develop, test and build js projects",
   "repository": {

package/src/build/build.js

@@ -69,6 +69,7 @@ import {
   createJsenvPluginsController,
   createJsenvPluginStore,
 } from "../plugins/jsenv_plugins_controller.js";
+import { isBareSpecifier } from "../helpers/bare_specifier.js";
 import { getCorePlugins } from "../plugins/plugins.js";
 import { jsenvPluginReferenceAnalysis } from "../plugins/reference_analysis/jsenv_plugin_reference_analysis.js";
 import { renderBuildDoneLog } from "./build_content_report.js";
@@ -1248,6 +1249,7 @@ const prepareEntryPointBuild = async (
         base,
         assetsDirectory,
         buildUrlsGenerator,
+        entryKey: sourceRelativeUrl,
 
         versioning,
         versioningMethod,
@@ -1488,7 +1490,10 @@ const prepareEntryPointBuild = async (
               const registerHtmlMutation = (callback) => {
                 htmlMutationCallbackSet.add(callback);
               };
-              htmlRefine(htmlAst, { registerHtmlMutation });
+              htmlRefine(htmlAst, {
+                registerHtmlMutation,
+                htmlUrlInfo: urlInfo,
+              });
               for (const htmlMutationCallback of htmlMutationCallbackSet) {
                 htmlMutationCallback();
               }
@@ -1572,20 +1577,3 @@ const prepareEntryPointBuild = async (
     },
   };
 };
-
-const isBareSpecifier = (specifier) => {
-  if (
-    specifier[0] === "/" ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../")
-  ) {
-    return false;
-  }
-  try {
-    // eslint-disable-next-line no-new
-    new URL(specifier);
-    return false;
-  } catch {
-    return true;
-  }
-};

package/src/build/build_specifier_manager.js

@@ -22,6 +22,7 @@ import {
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_special_chars.js";
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import { prependContent } from "../kitchen/prepend_content.js";
 import { GRAPH_VISITOR } from "../kitchen/url_graph/url_graph_visitor.js";
 import { isWebWorkerUrlInfo } from "../kitchen/web_workers.js";
@@ -38,6 +39,7 @@ export const createBuildSpecifierManager = ({
   buildDirectoryUrl,
   assetsDirectory,
   buildUrlsGenerator,
+  entryKey,
   base,
   length = 8,
 
@@ -76,6 +78,7 @@ export const createBuildSpecifierManager = ({
         urlInfo,
         ownerUrlInfo: reference.ownerUrlInfo,
         assetsDirectory,
+        entryKey,
       });
     }
 
@@ -895,7 +898,7 @@ export const createBuildSpecifierManager = ({
 
     prepareResyncResourceHints: ({ registerHtmlRefine }) => {
       const hintToInjectMap = new Map();
-      registerHtmlRefine((htmlAst, { registerHtmlMutation }) => {
+      registerHtmlRefine((htmlAst, { registerHtmlMutation, htmlUrlInfo }) => {
         visitHtmlNodes(htmlAst, {
           link: (node) => {
             if (getHtmlNodeAttribute(node, "jsenv-ignore") !== undefined) {
@@ -919,12 +922,39 @@ export const createBuildSpecifierManager = ({
               return;
             }
             const rawUrl = href;
+            if (targetsAFileThatDoesNotExist(rawUrl)) {
+              // this hint never designated anything, so nothing can explain its
+              // removal; taking away markup written by hand on a guess is worse
+              // than leaving it there
+              logger.warn(
+                createDetailedMessage(
+                  `${UNICODE.WARNING} resource hint kept as is: "${href}" cannot be resolved`,
+                  {
+                    "html file": htmlUrlInfo.url,
+                    ...(rawKitchen.context.hasInjections
+                      ? {
+                          suggestion: `when that url is written by an injection, jsenv resolves it in html attributes before analyzing references; check the placeholder spelling`,
+                        }
+                      : {}),
+                  },
+                ),
+              );
+              // the build url means nothing for something jsenv could not resolve,
+              // and it would leak a local path into the build
+              registerHtmlMutation(() => {
+                setHtmlNodeAttributes(node, {
+                  href: urlToRelativeUrl(rawUrl, htmlUrlInfo.url),
+                });
+              });
+              return;
+            }
             const finalUrl = internalRedirections.get(rawUrl) || rawUrl;
             const urlInfo = finalKitchen.graph.getUrlInfo(finalUrl);
             if (!urlInfo) {
-              if (rel === "preconnect" || rel === "dns-prefetch") {
-                // preconnect/dns-prefetch hints refer to origins, not specific resources in the graph.
-                // Keep them as-is — the author knows what external domains will be used at runtime.
+              if (!href.startsWith("file:")) {
+                // the hint designates a resource jsenv does not own: an origin for
+                // preconnect/dns-prefetch, a remote file for the others. The author
+                // knows what the page will request at runtime, keep it as-is.
                 return;
               }
               logger.warn(
@@ -1106,9 +1136,14 @@ export const createBuildSpecifierManager = ({
           let contentKey;
           // if to guard for html where versioned build specifier is not generated
           if (buildSpecifierVersioned) {
-            const buildUrlVersioned = asBuildUrlVersioned({
-              buildSpecifierVersioned,
-              buildDirectoryUrl,
+            // The version goes on the build url, not on the specifier: a
+            // specifier is written for one importer to read (base: "./" makes
+            // it relative to that importer, base: "https://cdn…" makes it
+            // absolute elsewhere) and says nothing about where the file lands.
+            const buildUrlVersioned = injectVersionIntoBuildSpecifier({
+              buildSpecifier: buildUrl,
+              version: versionMap.get(urlInfo),
+              versioningMethod,
             });
             const buildRelativeUrlVersioned = urlToRelativeUrl(
               buildUrlVersioned,
@@ -1352,21 +1387,14 @@ const injectVersionIntoBuildSpecifier = ({
   );
 };
 
-const asBuildUrlVersioned = ({
-  buildSpecifierVersioned,
-  buildDirectoryUrl,
-}) => {
-  if (buildSpecifierVersioned[0] === "/") {
-    return new URL(buildSpecifierVersioned.slice(1), buildDirectoryUrl).href;
-  }
-  const buildUrl = new URL(buildSpecifierVersioned, buildDirectoryUrl).href;
-  if (buildUrl.startsWith(buildDirectoryUrl)) {
-    return buildUrl;
+const targetsAFileThatDoesNotExist = (url) => {
+  if (!url.startsWith("file:")) {
+    return false;
   }
-  // it's likely "base" parameter was set to an url origin like "https://cdn.example.com"
-  // let's move url to build directory
-  const { pathname, search, hash } = new URL(buildSpecifierVersioned);
-  return `${buildDirectoryUrl}${pathname}${search}${hash}`;
+  const urlObject = new URL(url);
+  urlObject.search = "";
+  urlObject.hash = "";
+  return !existsSync(urlObject);
 };
 
 // export for unit tests

package/src/build/build_urls_generator.js

@@ -31,12 +31,41 @@ export const createBuildUrlsGenerator = ({
   };
 
   const nameSetPerDirectoryMap = new Map();
-  const generate = (url, { urlInfo, ownerUrlInfo, assetsDirectory }) => {
-    const buildUrlFromMap = buildUrlMap.get(url);
+  const reserveName = (directoryPath, urlName) => {
+    let nameSet = nameSetPerDirectoryMap.get(directoryPath);
+    if (!nameSet) {
+      nameSet = new Set();
+      nameSetPerDirectoryMap.set(directoryPath, nameSet);
+    }
+    let [basename, extension] = splitFileExtension(urlName);
+    extension = extensionMappings[extension] || extension;
+    let nameCandidate = `${basename}${extension}`; // reconstruct name in case extension was normalized
+    let integer = 1;
+    while (nameSet.has(nameCandidate)) {
+      integer++;
+      nameCandidate = `${basename}${integer}${extension}`;
+    }
+    nameSet.add(nameCandidate);
+    return nameCandidate;
+  };
+  const generate = (
+    url,
+    { urlInfo, ownerUrlInfo, assetsDirectory, entryKey },
+  ) => {
+    // A url already inside the build directory names a chunk a bundler just
+    // produced, and each entry point is bundled on its own: two of them
+    // routinely produce a chunk of the same name holding different code (the
+    // shared dependencies of THAT entry point, exported under names decided by
+    // THAT bundle). They are told apart by the entry point they come from —
+    // sharing the file would leave one entry importing exports the file on disk
+    // does not have.
+    const insideBuildDirectory = urlIsOrIsInsideOf(url, buildDirectoryUrl);
+    const key = insideBuildDirectory ? `${entryKey} ${url}` : url;
+    const buildUrlFromMap = buildUrlMap.get(key);
     if (buildUrlFromMap) {
       return buildUrlFromMap;
     }
-    if (urlIsOrIsInsideOf(url, buildDirectoryUrl)) {
+    if (insideBuildDirectory) {
       if (ownerUrlInfo.searchParams.has("dynamic_import_id")) {
         const ownerDirectoryPath = determineDirectoryPath({
           sourceDirectoryUrl,
@@ -48,11 +77,18 @@ export const createBuildUrlsGenerator = ({
         buildUrl = injectQueryParams(buildUrl, {
           dynamic_import_id: undefined,
         });
-        associateBuildUrl(url, buildUrl);
+        associateBuildUrl(key, buildUrl);
         return buildUrl;
       }
-      associateBuildUrl(url, url);
-      return url;
+      const urlObject = new URL(url);
+      const chunkDirectoryPath = urlToRelativeUrl(
+        new URL("./", urlObject),
+        buildDirectoryUrl,
+      );
+      const chunkName = reserveName(chunkDirectoryPath, urlToFilename(url));
+      const buildUrl = `${buildDirectoryUrl}${chunkDirectoryPath}${chunkName}${urlObject.search}${urlObject.hash}`;
+      associateBuildUrl(key, buildUrl);
+      return buildUrl;
     }
     if (urlInfo.type === "entry_build") {
       const buildUrl = new URL(urlInfo.filenameHint, buildDirectoryUrl).href;
@@ -84,25 +120,10 @@ export const createBuildUrlsGenerator = ({
       urlInfo,
       ownerUrlInfo,
     });
-    let nameSet = nameSetPerDirectoryMap.get(directoryPath);
-    if (!nameSet) {
-      nameSet = new Set();
-      nameSetPerDirectoryMap.set(directoryPath, nameSet);
-    }
     const urlObject = new URL(url);
     injectQueryParams(urlObject, { dynamic_import_id: undefined });
     let { search, hash } = urlObject;
-    let urlName = getUrlName(url, urlInfo);
-    let [basename, extension] = splitFileExtension(urlName);
-    extension = extensionMappings[extension] || extension;
-    let nameCandidate = `${basename}${extension}`; // reconstruct name in case extension was normalized
-    let integer = 1;
-    while (nameSet.has(nameCandidate)) {
-      integer++;
-      nameCandidate = `${basename}${integer}${extension}`;
-    }
-    const name = nameCandidate;
-    nameSet.add(name);
+    const name = reserveName(directoryPath, getUrlName(url, urlInfo));
     const buildUrl = `${buildDirectoryUrl}${directoryPath}${name}${search}${hash}`;
     associateBuildUrl(url, buildUrl);
     return buildUrl;

package/src/dev/dev_server_plugins/dev_server_plugin_serve_source_files.js

@@ -71,7 +71,16 @@ export const devServerPluginServeSourceFiles = ({
         }
       }
     });
-    const clientRuntimeCompat = { [runtimeName]: runtimeVersion };
+    // A client we cannot identify (curl, fetch, a healthcheck, a proxy dropping
+    // the user agent) is assumed to be one of the runtimes the project targets.
+    // Treating it as a runtime supporting nothing would serve it the js module
+    // fallback, breaking tooling perfectly capable of ES modules; an actual
+    // ancient browser hiding its identity fails loudly instead, which is the
+    // cheaper of the two mistakes.
+    const clientRuntimeCompat =
+      runtimeName === "unknown"
+        ? runtimeCompat
+        : { [runtimeName]: runtimeVersion };
 
     kitchen = createKitchen({
       name: runtimeId,

package/src/helpers/bare_specifier.js

@@ -0,0 +1,18 @@
+// A bare specifier ("preact", "@jsenv/core/x.js") is resolved by node esm resolution,
+// everything else ("/a.js", "./a.js", "http://example.com/a.js") by url resolution
+export const isBareSpecifier = (specifier) => {
+  if (
+    specifier[0] === "/" ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../")
+  ) {
+    return false;
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier);
+    return false;
+  } catch {
+    return true;
+  }
+};

package/src/kitchen/errors.js

@@ -373,9 +373,10 @@ 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.
+// Injections write urls in html attributes before references are analyzed, so an url
+// that still cannot be resolved may be a placeholder no injection replaced. 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 {};
@@ -394,7 +395,7 @@ const detailsFromInjectionsOnOwner = (reference) => {
     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:
+    suggestion: `injections are configured for this file; when "${reference.specifier}" is meant to be written by one of them, check the placeholder spelling, or add "jsenv-ignore" so jsenv leaves that url alone:
 <${node.nodeName} jsenv-ignore ${attributeName}="${reference.specifier}" />`,
   };
 };

package/src/kitchen/url_graph/url_graph.js

@@ -214,6 +214,9 @@ const createUrlInfo = (url, context) => {
     contentFinalized: false,
     contentSideEffects: [],
     contentInjections: {},
+    // placeholders already consumed somewhere else than the content (in a specifier),
+    // so that not finding them in the content is not worth a warning
+    contentInjectionUsedKeySet: new Set(),
 
     sourcemap: null,
     sourcemapIsWrong: false,

package/src/kitchen/url_graph/url_info_injections.js

@@ -25,6 +25,13 @@ export const INJECTIONS = {
   },
 };
 
+export const readInjectionValue = (injection) => {
+  if (injection && injection[injectionSymbol]) {
+    return injection.value;
+  }
+  return injection;
+};
+
 export const isPlaceholderInjection = (value) => {
   return (
     !value || !value[injectionSymbol] || value[injectionSymbol] !== "global"
@@ -98,7 +105,7 @@ export const injectPlaceholderReplacements = (
   for (const { key, isOptional, value } of placeholderReplacements) {
     let index = content.indexOf(key);
     if (index === -1) {
-      if (!isOptional) {
+      if (!isOptional && !urlInfo.contentInjectionUsedKeySet.has(key)) {
         urlInfo.context.logger.warn(
           `placeholder "${key}" not found in ${urlInfo.url}.
 --- suggestion a ---
@@ -123,7 +130,7 @@ return {
       magicSource.replace({
         start,
         end,
-        replacement: asReplacement(value, urlInfo),
+        replacement: asReplacement(value, urlInfo.type),
       });
       index = content.indexOf(key, end);
     }
@@ -134,8 +141,8 @@ return {
 // 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") {
+export const asReplacement = (value, type) => {
+  if (type === "js_classic" || type === "js_module") {
     return JSON.stringify(value, null, "  ");
   }
   if (typeof value === "string") {