mikser-io 9.19.1 → 9.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io",
-  "version": "9.19.1",
+  "version": "9.20.0",
   "description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
   "main": "index.js",
   "exports": {

package/src/database/index.js

@@ -331,6 +331,11 @@ export function createSqliteDatabase({
             logger: logger ?? null,
         }
 
+        // Published so plugins can tell an everything-was-evaluated cycle
+        // from an incremental one without reaching into the db handle. Read
+        // through `isFullCycle()` in utils.js rather than directly.
+        runtime.options.firstRun = provisioningCtx.firstRun
+
         // Fire provisioning callbacks before schema apply, so they can
         // load runtime extensions (sqlite-vec's vec0, etc.) that the
         // schemas about to apply might reference, register custom

package/src/manifest.js

@@ -190,9 +190,34 @@ function snapToRow(snap) {
     }
 }
 
-async function hashOutputFile(destination) {
+// Where a `destination` actually is on disk.
+//
+// Two shapes are in circulation and both are legitimate. A page's is
+// output-relative with a leading slash (`/bg/index.html`); an asset's is a
+// real filesystem path, because assets.js builds it from
+// `runtime.options.assetsFolder`, which resolves inside the WORKING folder
+// and can sit outside outputFolder entirely.
+//
+// `path.isAbsolute` cannot separate them — on POSIX `/bg/index.html` is
+// absolute too — so resolve by EXISTENCE, output-relative first since that
+// is the dominant shape. A page destination treated as a filesystem path
+// would otherwise be looked for at the root of the disk.
+//
+// Shared, because the two callers needing it drifted into two separate
+// bugs: verify() reported every asset missing while printing its real
+// path, and hashOutputFile silently recorded no outputHash for one, which
+// left 78% of a real project's snapshots presence-checked only.
+export function resolveOutputPath(destination, outputFolder = runtime.options?.outputFolder) {
     if (!destination) return undefined
-    const filePath = path.join(runtime.options.outputFolder, destination)
+    const joined = path.join(outputFolder ?? '', destination)
+    if (existsSync(joined)) return joined
+    if (path.isAbsolute(destination) && existsSync(destination)) return destination
+    return joined
+}
+
+async function hashOutputFile(destination) {
+    const filePath = resolveOutputPath(destination)
+    if (!filePath) return undefined
     try {
         const buf = await readFile(filePath)
         return sha1(buf)
@@ -552,31 +577,7 @@ export function createManifest(db) {
             for (const row of stmtSelectAll.iterate()) {
                 const snap = rowToSnap(row)
                 if (!snap.destination) continue
-                // `destination` arrives in two shapes and both are legitimate.
-                // A page's is output-relative with a leading slash
-                // (`/bg/index.html`); an asset's is a real filesystem path,
-                // because assets.js builds it from
-                // `runtime.options.assetsFolder` — which resolves inside the
-                // WORKING folder and may sit outside outputFolder entirely
-                // (a `derived/` tree that `shares` symlinks into each language
-                // root is the case that proves it).
-                //
-                // `path.isAbsolute` cannot tell them apart: on POSIX
-                // `/bg/index.html` is absolute too. So resolve by EXISTENCE,
-                // output-relative first — that is the dominant shape, and a
-                // page destination interpreted as a filesystem path would
-                // otherwise be looked for at the root of the disk.
-                //
-                // Only the fallback path is a filesystem path, so it is only
-                // tried when the destination is absolute and joining changed
-                // nothing that resolves.
-                const joined = path.join(outputFolder, snap.destination)
-                let filePath = joined
-                if (!existsSync(joined)
-                    && path.isAbsolute(snap.destination)
-                    && existsSync(snap.destination)) {
-                    filePath = snap.destination
-                }
+                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

package/src/plugins/assets.js

@@ -6,6 +6,7 @@ import { globby } from 'globby'
 import _ from 'lodash'
 import map from 'p-map'
 import { reportWarning } from '../report.js'
+import { isFullCycle } from '../utils.js'
 
 // Normalize a `options.presets[name]` value to a consistent
 // { matches, options } shape so callers don't have to inspect which form
@@ -120,6 +121,14 @@ export function assets(options = {}) {
         if (matchTally.reported) return
         const configured = Object.keys(options.presets || {})
         if (!configured.length || !matchTally.evaluated) return
+        // Only when the cycle evaluated everything. On an incremental run the
+        // evaluated set is whatever changed, so a healthy preset matches
+        // nothing in a run of two and the warning fires on every build —
+        // which trains the reader to filter it, and the filtered-out line is
+        // the real one. The message already told the reader to use --force to
+        // check the whole catalog; that condition gates it now instead of
+        // annotating it.
+        if (!isFullCycle(runtime)) return
         matchTally.reported = true
 
         for (const preset of configured) {
@@ -129,8 +138,7 @@ export function assets(options = {}) {
             logger.warn(
                 'Assets preset %j matched none of the %d entities evaluated (patterns: %s). ' +
                 'Patterns run against entity.id, which files({ outputFolder }) does NOT prefix — ' +
-                'the prefix appears on name and meta.url only. On an incremental run unchanged ' +
-                'entities are not re-evaluated; use --force to check the whole catalog.',
+                'the prefix appears on name and meta.url only.',
                 preset, matchTally.evaluated, matches.join(', '))
         }
     }

package/src/utils.js

@@ -990,6 +990,29 @@ export async function writeOutput(file, bytes) {
     return true
 }
 
+// Did this cycle evaluate the whole corpus, or only what changed?
+//
+// The distinction is what makes a "declared X matched nothing" warning
+// worth printing. On an incremental cycle only changed entities are
+// re-evaluated, so a pattern or preset legitimately matches nothing in a
+// run of two — printing it there means the warning fires on every healthy
+// build, and a warning that always fires is one people filter out, taking
+// the real instance with it.
+//
+// True for: --force, a first-run or wiped database, and a cache
+// invalidation. Those are exactly the cases where the import gate is
+// bypassed and every entity is presented for evaluation.
+// Takes the runtime rather than reading the singleton, so a plugin passes
+// the one it was injected with — which is the singleton in a real build and
+// the harness's stand-in under test.
+export function isFullCycle(rt = runtime) {
+    return !!(
+        rt?.options?.force
+        || rt?.options?.firstRun
+        || rt?.catalog?.cacheInvalidated
+    )
+}
+
 // ── operating-system and file-manager litter ────────────────────────────
 //
 // Exposing a source folder over a network filesystem (mikser-io-webdav) or