mikser-io 10.10.1 → 10.11.0

package/package.json

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

package/src/engine.js

@@ -835,7 +835,17 @@ The full version, with what each code means: docs/diagnostics.md`)
         // creates for itself. By `import` every onLoaded has run and the
         // registry is complete. Nothing is imported, because this exits first,
         // the same way --explain and --audit-output do.
-        if (runtime.options.tools || runtime.options.tool) {
+        //
+        // --audit-output is here for the same reason, found the same way. It
+        // asks which trees hold outputs, and a plugin cannot answer until its
+        // own onLoaded has run — the assets plugin resolves the folder its
+        // derivatives live in there, because `--assets` is a plugin option
+        // and stage two of the parse is what makes it readable. Dispatched
+        // from the engine's onLoaded it ran ahead of all of them, so the one
+        // check that reports unclaimed files could not see the one tree whose
+        // files reach the site through a symlink it does not follow. It
+        // reported `0 orphaned` over any amount of debris.
+        if (runtime.options.tools || runtime.options.tool || runtime.options.auditOutput) {
             const code = await runReportOnly()
             if (code !== null) process.exit(code)
         }
@@ -877,14 +887,16 @@ The full version, with what each code means: docs/diagnostics.md`)
         // one implementation, so a forwarded --audit-output cannot disagree with a
         // local one about what it checked.
         //
-        // --tools and --tool are NOT among them: they are dispatched at `import`
-        // instead, because the tool registry is not complete until every
-        // plugin's onLoaded has run and this hook runs ahead of all of them.
+        // --tools, --tool and --audit-output are NOT among them: they are
+        // dispatched at `import` instead, because what they read is not
+        // complete until every plugin's onLoaded has run and this hook runs
+        // ahead of all of them — the tool registry for the first two, the set
+        // of trees that hold outputs for the third.
         // The import dispatch existed already and was documented as
         // load-bearing, but this call reached the same code first and exited,
         // so it never ran — and every tool a plugin registers was missing from
         // the CLI while the listing looked healthy, just short.
-        if (!runtime.options.tools && !runtime.options.tool) {
+        if (!runtime.options.tools && !runtime.options.tool && !runtime.options.auditOutput) {
             const code = await runReportOnly()
             if (code !== null) process.exit(code)
         }

package/src/manifest.js

@@ -1102,7 +1102,7 @@ export function createManifest(db) {
         // Walk the output folder against recorded snapshots, returning
         // a diff describing missing / mismatched / orphaned /
         // unverifiable. Backs `mikser --audit-output`. Pure: no mutations.
-        async auditOutput({ outputFolder } = {}) {
+        async auditOutput({ outputFolder, roots } = {}) {
             outputFolder = outputFolder || runtime.options.outputFolder
             const missing = []
             const mismatched = []
@@ -1112,16 +1112,12 @@ export function createManifest(db) {
                 const snap = rowToSnap(row)
                 if (!snap.destination) continue
                 const filePath = resolveOutputPath(snap.destination, outputFolder)
-                // Orphan detection compares against a globby walk of
-                // outputFolder, so `claimed` has to hold exactly the relative
-                // form that walk produces. A destination resolving outside
-                // outputFolder can never appear in it and is not claimable;
-                // one inside it must be claimed by its relative path, not by
-                // the raw string with its leading slashes stripped.
-                const relative = path.relative(outputFolder, filePath)
-                if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
-                    claimed.add(relative)
-                }
+                // Claimed by ABSOLUTE path, so the set does not depend on the
+                // relative form any particular walk produces. It was keyed on
+                // a path relative to outputFolder, which worked only while
+                // that was the one tree walked — and quietly claimed nothing
+                // for every destination outside it.
+                claimed.add(path.resolve(filePath))
                 if (!existsSync(filePath)) {
                     missing.push({ id: snap.id, destination: snap.destination })
                     continue
@@ -1150,15 +1146,47 @@ export function createManifest(db) {
                 }
             }
             const { globby } = await import('globby')
-            const onDisk = await globby('**/*', {
-                cwd: outputFolder,
-                onlyFiles: true,
-                followSymbolicLinks: false,
-            })
+            // Every tree mikser writes into, not only the output folder.
+            //
+            // Preset derivatives live at the working-folder root and reach
+            // the site through a symlink, which the walk does not follow — so
+            // a file nothing claims there was invisible to this check, which
+            // is the one place the concept of an orphan exists. Plugins
+            // declare their own trees on `runtime.options.auditRoots`,
+            // carrying their own ignore patterns, so nothing here has to know
+            // what a preset is or that a `.md5` beside a derivative is
+            // bookkeeping rather than output.
+            const declared = [{ path: outputFolder }, ...(roots ?? runtime.options.auditRoots ?? [])]
+            const walked = []
+            for (const root of declared) {
+                const resolved = path.resolve(root.path ?? root)
+                // A root inside one already walked would report every file in
+                // it twice.
+                const nested = walked.some(({ resolved: seen }) =>
+                    resolved === seen || resolved.startsWith(seen + path.sep))
+                if (nested) continue
+                walked.push({ resolved, ignore: root.ignore ?? [] })
+            }
             const orphaned = []
-            for (const rel of onDisk) {
-                if (claimed.has(rel)) continue
-                orphaned.push({ path: rel })
+            for (const { resolved, ignore } of walked) {
+                const onDisk = await globby('**/*', {
+                    cwd: resolved,
+                    onlyFiles: true,
+                    followSymbolicLinks: false,
+                    ignore,
+                })
+                for (const rel of onDisk) {
+                    if (claimed.has(path.join(resolved, rel))) continue
+                    // Relative to the output folder for the output folder, as
+                    // before; relative to the working folder for anything
+                    // else, because `web/media/x.jpg` alone does not say which
+                    // tree it is in.
+                    const isOutput = resolved === path.resolve(outputFolder)
+                    const display = isOutput
+                        ? rel
+                        : path.relative(runtime.options.workingFolder ?? resolved, path.join(resolved, rel))
+                    orphaned.push({ path: display, root: resolved })
+                }
             }
             // Reported alongside, not as a mismatch: two entities claiming one
             // destination usually produces NO mismatch at all, because each

package/src/plugins/assets.js

@@ -505,6 +505,7 @@ export function assets(options = {}) {
         runtime.engine ??= {}
         runtime.engine.assets = { explainMissing }
 
+
         // `??`, not `||`: an option commander did not see is undefined, and
         // falling through to the config is the point. `||` would also fall
         // through for an intentional empty string, which is a different
@@ -516,6 +517,28 @@ export function assets(options = {}) {
 
         runtime.options.assets = runtime.options.assets ?? options.assetsFolder ?? 'assets'
         runtime.options.assetsFolder = path.join(runtime.options.workingFolder, runtime.options.assets)
+        // This tree holds outputs too, and --audit-output could not see it:
+        // it walks the output folder, and derivatives reach the site through
+        // a symlink the walk does not follow. Declared rather than hardcoded
+        // in the manifest, with the ignore that only this plugin can state —
+        // a `.md5` beside a derivative is bookkeeping, and without excluding
+        // them every derivative on the site would report one orphan.
+        //
+        // `auditIgnore` is the escape hatch for a preset that writes MORE
+        // than one file. The engine records the one destination it handed
+        // over, so a poster frame written beside a video is genuinely
+        // unclaimed and genuinely reported — correct, and a permanent
+        // non-zero exit for a legitimate preset if there were no way to say
+        // "these are expected". Stated in config, next to the preset that
+        // produces them, rather than inferred.
+        const auditRoot = {
+            path: runtime.options.assetsFolder,
+            ignore: ['**/*.md5', ...(options.auditIgnore ?? [])],
+        }
+        runtime.options.auditRoots = [
+            ...(runtime.options.auditRoots ?? []).filter(root => root.path !== auditRoot.path),
+            auditRoot,
+        ]
         logger.debug('Assets folder: %s', runtime.options.assetsFolder)
 
         // --clear means "throw away what was derived and build it again", and