mikser-io 9.88.0 → 9.89.0

package/docs/diagnostics.md

@@ -948,6 +948,15 @@ surfaces that turn silence into a statement:
     sitemap — and warns under `asset-missing`. Where both can see the
     same file, the output scan reports it and this one stays quiet.
 
+  A `url()` inside a **custom property** is resolved from the stylesheet that
+  substitutes it, for both of these questions and for the climb check below.
+  It is substituted where it is *used*, so the page that declared it in a
+  style attribute is not its base — a bundle at `styles/` is. Every emitted
+  stylesheet is a candidate, since which one substitutes the variable is not
+  knowable from the bytes; a clean resolution settles it, one that resolves
+  only by climbing is a genuine over-deep against *that* base, and a url that
+  resolves from none of them is reported as broken.
+
   A url under the assets folder gets a cause rather than a guess. Whether a
   preset covers a file is decided by `match` against the entity id, which is
   not visible from a url, so the assets plugin is asked and the answer is one
@@ -971,7 +980,11 @@ surfaces that turn silence into a statement:
 - **A link that works only by accident** — a url with one `..` too many
   still loads, because a browser discards a climb above the origin root
   rather than failing. Reported under `reference-over-deep`, separately
-  from the outright failures, and grouped by how far each climbed:
+  from the outright failures, and grouped by how far each climbed. A custom
+  property is judged against its stylesheet here too: judged against the page
+  it produced a climb report for references that are correct, with a reason
+  — "a browser discards the extra `..`" — that was false for them, which
+  sends the reader to fix a base that is right:
   - **One url, or several climbing different distances** — each is a
     latent 404, working today and broken as soon as the same markup
     renders one level deeper.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io",
-  "version": "9.88.0",
+  "version": "9.89.0",
   "files": [
     "app.js",
     "index.js",

package/src/references.js

@@ -198,21 +198,46 @@ export async function checkReferences(outputFolder, { siteRoots = [] } = {}) {
         const pageDir = path.dirname(file).slice(root.length).replace(/^\/+/, '')
 
         for (const { url, customProperty } of extractReferences(source)) {
-            const { target, overDeep, floored } = resolveUrl(pageDir, url, { root })
+            let { target, overDeep, floored } = resolveUrl(pageDir, url, { root })
             checked++
 
-            if (!exists.has(target)) {
-                exists.set(target, existsSync(path.join(outputFolder, target)))
+            const resolves = (candidate) => {
+                if (!exists.has(candidate)) {
+                    exists.set(candidate, existsSync(path.join(outputFolder, candidate)))
+                }
+                return exists.get(candidate)
             }
+            resolves(target)
 
-            // Resolved from a stylesheet instead, and correct there.
-            if (!exists.get(target) && customProperty && styleBases.some((base) => {
-                const from = resolveUrl(base.dir, url, { root: base.root }).target
-                if (!exists.has(from)) {
-                    exists.set(from, existsSync(path.join(outputFolder, from)))
+            // A custom property is resolved from the STYLESHEET, for BOTH
+            // questions this check asks.
+            //
+            // The first version of this only replaced the verdict when the
+            // page-relative target was missing, which left the climb check
+            // answering from a base it had already been told was the wrong
+            // one. Where the discarded `..` happened to land on a real file,
+            // the reference was reported as climbing above the site root, and
+            // the explanation said it loads "because a browser discards the
+            // extra `..`" — when it loads because it is correct where it is
+            // actually read from. A wrong reason on a correct reference is
+            // worse than the original false positive: it sends the reader to
+            // fix a base that is right.
+            //
+            // Clean beats floored beats missing. A stylesheet that resolves it
+            // without climbing settles it; one that resolves it only by
+            // climbing is a genuine over-deep against THAT base; and if none
+            // resolves it the page-relative answer stands and the url is
+            // simply broken.
+            if (customProperty && styleBases.length) {
+                let best = null
+                for (const base of styleBases) {
+                    const from = resolveUrl(base.dir, url, { root: base.root })
+                    if (!resolves(from.target)) continue
+                    if (!from.overDeep) { best = from; break }
+                    best ??= from
                 }
-                return exists.get(from)
-            })) continue
+                if (best) ({ target, overDeep, floored } = best)
+            }
 
             // Broken outranks over-deep: a url that resolves nowhere is the
             // failure, and adding that it is also one level too deep is noise.