mikser-io 10.0.2 → 10.0.4

package/docs/configuration.md

@@ -47,7 +47,7 @@ These options are part of `runtime.options` and apply to the engine itself.
 | `outputFolder` | `-o, --output-folder` | string | `out` | Folder where rendered output is written. |
 | `runtimeFolder` | `-e, --runtime-folder` | string | `runtime` | Folder for temporary files. The engine's sqlite substrate lives at `runtime/mikser.sqlite` (entities, refs, snapshots, journal, schema-version meta all in one file). |
 | `plugins` | — | factory-call[] | `[]` | Array of factory returns. Import the factory by name and call it: `plugins: [documents(), layouts({ cleanUrls: true })]`. Config-only — there's no `--plugins` CLI flag under v9 because identifiers can't be passed via the command line (ADR-0010). |
-| `config` | `-c, --config` | string | `./mikser.config.js` | Path to the config file. |
+| `config` | `-c, --config` | string | `./mikser.config.js` | Path to the config file, relative to `workingFolder` like every other path — so `-c prod.config.js` means the one in the folder you pointed at, and repeating the working folder in the path doubles it. A project with no config file at the default location runs on defaults; a path given here that does not exist is an error, because the alternative is a green build with an empty output folder. |
 | `mode` | `-m, --mode` | string | `development` | Runtime mode, accessible as `runtime.options.mode`. |
 | `clear` | `-r, --clear` | boolean | `false` | Delete `outputFolder` and `runtimeFolder` before each run. |
 | `watch` | `-w, --watch` | boolean | `false` | Watch source folders for changes and rebuild incrementally. |

package/package.json

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

package/src/config.js

@@ -103,6 +103,18 @@ onLoad(async () => {
     // during evaluation both exit 1. Module resolution is the only one that
     // needs this to stay in line with them.
     if (!existsSync(configFile)) {
+        // Absent by DEFAULT is a project without a config, which is allowed.
+        // Absent after the caller named it is a typo, and continuing on
+        // defaults answers a question nobody asked: the build prints the path
+        // it did not find, reports "No plugins loaded", writes nothing and
+        // exits 0. That is the same green-build-empty-output failure the
+        // module-resolution note above exists to prevent, reached by the
+        // shorter route of getting the path wrong.
+        if (runtime.options.configExplicit) {
+            throw new Error(`No config file at ${configFile} — it was named with --config, so this is a wrong `
+                + 'path rather than a project without a config. A relative --config resolves against the '
+                + `working folder (${runtime.options.workingFolder}), so it does not repeat it.`)
+        }
         logger.debug('No config file at %s — using defaults', configFile)
     } else {
         // No catch: any failure loading a config that EXISTS is fatal.

package/src/engine.js

@@ -683,6 +683,22 @@ The full version, with what each code means: docs/diagnostics.md`)
         // deliberate: engine's onInitialize does setup that the rest of
         // the engine infrastructure depends on; onInitialized does
         // things plugins may need.
+        // Whether --config was TYPED, for config.js.
+        //
+        // Relative config paths resolve against the working folder, not the
+        // folder the command was run in — that is what makes the default
+        // './mikser.config.js' follow --working-folder, and `-c prod.js`
+        // reads as "the prod config of the site I am pointing at", which is
+        // how it is used. Deliberately unchanged.
+        //
+        // What was missing is what happens when the path is wrong. Nothing
+        // distinguished "this project has no config" from "the config you
+        // named is not there", so a mistyped path printed the path, reported
+        // no plugins, and exited 0 over an empty output folder. config.js
+        // needs to know which case it is in, and only commander can say.
+        runtime.options.configExplicit =
+            runtime.engine?.commander?.getOptionValueSource?.('config') === 'cli'
+
         runtime.options.workingFolder = path.resolve(runtime.options.workingFolder)
         process.chdir(runtime.options.workingFolder)
 

package/src/manifest.js

@@ -1122,9 +1122,12 @@ export function createManifest(db) {
         // One stat per recorded snapshot, once per cycle, hoisted out of the
         // per-file path exactly like checksumsByCollection. The syscalls are
         // ~2.2ms per 1842 paths and cost the same whether the files are there
-        // or not; at the build level a warm 2000-document rebuild measured
-        // 1.05s against 1.08s without it, which is inside the run-to-run
-        // spread — the walk disappears into the cycle it is part of.
+        // or not. At the build level it does not register: warm rebuilds of
+        // the 10k perf corpus ran 3.36s median with this against 3.56s
+        // without, i.e. nominally faster, which is only to say the difference
+        // is well inside the run-to-run spread (3.0-4.1 vs 3.5-4.7 over five
+        // runs each). Re-measure with `npm run test:perf` before trusting a
+        // claim that it got slower.
         //
         // Resolves destinations through resolveOutputPath, which is what
         // auditOutput uses. The two must agree — `--audit-output` reporting

package/src/plugins/assets.js

@@ -348,6 +348,17 @@ export function assets(options = {}) {
     }
 
     async function isPresetRendered(entity) {
+        // The marker says a render HAPPENED. It does not say the file it
+        // produced is still there, and the two come apart the moment anyone
+        // deletes a derivative — which is the obvious thing to do when you
+        // want one rebuilt. The marker survives, this returned true, and the
+        // image never came back on any number of ordinary builds; only
+        // --force or a config change brought it round, and --audit-output was
+        // the only thing that ever said a file was missing.
+        //
+        // Checked first and cheaply: one stat, and if the derivative is gone
+        // no amount of marker archaeology changes the answer.
+        if (!existsSync(entity.destination)) return false
         let result = false
         let revisions = []
         const assetChecksum = `${entity.destination}.${entity.preset.checksum}.md5`

package/src/plugins/files.js

@@ -4,7 +4,7 @@ import { mkdir, symlink, unlink, lstat, realpath } from 'fs/promises'
 import { globby } from 'globby'
 import pMap from 'p-map'
 import { checksumsByCollection } from '../catalog.js'
-import { sweepDeleted } from '../source.js'
+import { gateChecksum, sweepDeleted } from '../source.js'
 
 export function files(options = {}) {
     return ({
@@ -187,23 +187,32 @@ export function files(options = {}) {
 
             const paths = await globby('**/*', { cwd: runtime.options.filesFolder })
             trackProgress('Files import', paths.length)
-            // Bulk-prefetch the catalog's existing (id → checksum) map for
-            // this collection once at scan start, so the gate below reads
-            // from it per-file instead of doing per-file SQL lookups. Same
-            // pattern source.js uses for documents/layouts via useSource.
-            // Without this gate the plugin re-emitted createEntity on every
-            // cycle for every file regardless of changes, inflating the
-            // journal with phantom mutations and triggering downstream
-            // re-dispatch of aggregate layouts whose recorded query deps
-            // matched the collection.
-            // --force (and a wiped catalog) must defeat this gate, the
-            // same way source.js's gateChecksum lets them defeat its own.
-            // This is a second, independent gate: if it ignores them, no
-            // amount of forcing re-derives a file's name / meta.url /
-            // meta.presets, and a catalog holding bad `files` rows has no
-            // repair path short of deleting them.
-            const forced = runtime.options.force || runtime.catalog?.cacheInvalidated
+            // The SHARED gate, not a copy of it.
+            //
+            // Without a gate the plugin re-emitted createEntity on every cycle
+            // for every file regardless of changes, inflating the journal with
+            // phantom mutations and triggering downstream re-dispatch of
+            // aggregate layouts whose recorded query deps matched the
+            // collection. So it grew one — and then it was a SECOND,
+            // independent implementation of the decision source.js already
+            // owns, which is how it silently missed the missing-output bypass
+            // that was added to the original: an image derivative deleted from
+            // the assets folder was never regenerated, because the file it
+            // derives from was gated here as unchanged and never reached the
+            // assets plugin. Green build, missing image, and only
+            // --audit-output said otherwise.
+            //
+            // Every reason to defeat the gate — --force, a wiped catalog, a
+            // recorded output that is gone — now lives in exactly one place,
+            // so the next one cannot be added to that place and missed here.
+            //
+            // priorChecksums is still bulk-prefetched per scan so the gate
+            // reads a map instead of doing per-file SQL, and missingOutputs
+            // alongside it for the same reason; the manifest memoizes the
+            // latter for the cycle, so this shares the walk with useSource's
+            // own scans rather than paying for a second one.
             const priorChecksums = checksumsByCollection(collection)
+            const missingOutputs = runtime.manifest?.missingOutputIds() ?? new Set()
             const scanned = new Set()
             await pMap(paths, async relativePath => {
                 const { source } = await ensureLink(relativePath)
@@ -217,15 +226,13 @@ export function files(options = {}) {
                 // to re-emit; the sweep asks what still EXISTS, and a file
                 // skipped for being unchanged very much exists.
                 scanned.add(id)
-                const newChecksum = await checksum(source)
+                // Returns the checksum to stamp on the entity, or null when
+                // the catalog already has this file unchanged and there is
+                // nothing to emit. Progress ticks either way — a gated file
+                // was still looked at.
+                const newChecksum = await gateChecksum(source, id, { priorChecksums, missingOutputs })
                 updateProgress()
-                // Gate: if the catalog already has this entity with the same
-                // checksum, the file hasn't changed since the last cycle.
-                // Skip emitting a CREATE — the catalog row stays correct,
-                // the journal stays accurate (mutations = actual changes),
-                // and downstream aggregate-layout invalidation isn't fired
-                // spuriously.
-                if (!forced && priorChecksums.get(id) === newChecksum) return
+                if (newChecksum === null) return
                 await createEntity({
                     id,
                     uri,