mikser-io 9.74.0 → 9.76.0

package/package.json

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

package/src/engine.js

@@ -668,6 +668,15 @@ export async function setup(options) {
                     // A postprocessor consumes the intermediate rendered
                     // file, so skipping would leave its input missing.
                     ? { skip: false, reason: 'postprocessor' }
+                    // Scheduled BECAUSE the thing that renders it moved. The
+                    // manifest cannot see that: an asset's input hash is its
+                    // own source, and a preset's revision is not part of it,
+                    // so the skip was correct about the entity and wrong about
+                    // the render. Bumping a preset's `revision` — the
+                    // documented way to force a rebuild — therefore deleted
+                    // the stale marker and left the derivative untouched.
+                    : options.rendererChanged
+                    ? { skip: false, reason: 'renderer-changed' }
                     : runtime.manifest?.skipDecision(entity, mutatedRefs, currentHashes, mutatedEntities)
                         ?? { skip: false, reason: 'no-manifest' }
                 if (decision.skip) {

package/src/manifest.js

@@ -1289,7 +1289,36 @@ onFinalize(async () => {
     // That made "resolve the collision by deleting the stub" delete the
     // homepage, which is the opposite of what the operator asked for and the
     // exact operation the new collision reporting invites.
+    // Destinations THIS cycle's surviving renders just wrote.
+    //
+    // Their snapshot rows are not inserted until 3c below, so the
+    // by-destination query cannot see them — the same blind spot 2a already
+    // compensates for in the other direction ("recorded snapshots only
+    // describe PRIOR cycles").
+    //
+    // Without this, renaming a source's extension unlinks the output the new
+    // entity just wrote. `index.md` → `index.yml` keeps the entity NAME and
+    // the destination but changes the id, so one cycle carries a DELETE for
+    // the old id and a RENDER for the new one. The render writes the page,
+    // the delete stages the same destination, nothing surviving claims it
+    // yet, and the file goes — with `Rendered: 1`, a green build and no
+    // warning. A second build does not fix it (nothing changed), nor does
+    // touch (the input hash is the same); only a real content edit re-renders
+    // it. Only --verify ever said so, and renaming an extension is the most
+    // common action there is during a migration.
+    const claimedByThisCycle = new Set()
+    for (const { entity } of renderedEntries) {
+        if (deleted.has(entity.id) || (entity.parent && deleted.has(entity.parent))) continue
+        if (entity.destination) claimedByThisCycle.add(entity.destination)
+    }
+
     for (const { destination, reason } of filesToUnlink) {
+        // Written this cycle by an entity that is staying. Keep it, and say
+        // nothing: the snapshot recorded at 3c is this render's own, so there
+        // is no staleness to report — unlike the surviving-snapshot case
+        // below, where the bytes belong to the entity that went away.
+        if (claimedByThisCycle.has(destination)) continue
+
         // "Still claimed" means by something that SURVIVES this pass. The
         // ids going away here are not just the deleted entities: pagination
         // children staged above are removed too, and counting a child's own

package/src/plugins/assets.js

@@ -81,6 +81,7 @@ export function assets(options = {}) {
         onSync,
         onFinalize,
         findEntity,
+        iterateEntities,
         matchEntity,
         changeExtension,
         constants: { ACTION, OPERATION },
@@ -223,7 +224,7 @@ export function assets(options = {}) {
         return result
     }
 
-    async function renderPresets(entities) {
+    async function renderPresets(entities, { rendererChanged = new Set() } = {}) {
         const { presets, assetsMap } = runtime.state.assets
 
         const tasks = []
@@ -257,6 +258,10 @@ export function assets(options = {}) {
                         ...entity.preset.options,    // module defaults
                         ...configOptions,             // config overrides
                         renderer: 'preset',
+                        // The preset itself moved this cycle, so the manifest's
+                        // "its source is unchanged" is true and beside the
+                        // point. See the skip decision in engine.js.
+                        rendererChanged: rendererChanged.has(entityToRender.id),
                         ignore
                     }
                 })
@@ -453,16 +458,41 @@ export function assets(options = {}) {
         }
 
         const entitiesToRender = new Map()
+        // Entities scheduled because their PRESET changed, not their source.
+        const presetMoved = new Set()
         await map(useJournal('Assets provision', [OPERATION.CREATE, OPERATION.UPDATE], signal), async ({ entity }) => {
             if (entity.collection == collection) {
-                for (let entityId in assetsMap) {
-                    if (assetsMap[entityId].find(preset => preset == entity.name)) {
-                        const entityToRender = await findEntity({
-                            id: entityId
-                        })
-                        if (!entitiesToRender.has(entityToRender.id)) {
-                            entitiesToRender.set(entityToRender.id, entityToRender)
-                        }
+                // A preset moved — its `revision` was bumped, or its module
+                // changed. Everything that uses it has to re-render.
+                //
+                // Asked of the CATALOG, not of assetsMap. That map is built
+                // from this cycle's journal, so on a build where only the
+                // preset moved it is empty and this fan-out reached nothing:
+                // no asset was scheduled, the reuse check that would have
+                // said "the marker is too old" was never consulted, and the
+                // startup sweep deleted the old markers anyway because it
+                // walks the folder rather than the entities.
+                //
+                // The result was the worst available shape. Bumping `revision`
+                // — the documented way to force a rebuild — removed the marker
+                // and left the derivative at its old bytes. It looked like it
+                // had worked, nothing in the report said otherwise, and where
+                // the derived folder is gitignored the deployment served stale
+                // images until someone deleted the folder by hand.
+                //
+                // getEntityPresets is the same matcher the per-entity path
+                // uses, so there is one implementation of "does this entity
+                // use this preset" rather than a second one here that can
+                // drift.
+                for await (const candidate of iterateEntities({ collection: { $ne: collection } })) {
+                    const candidatePresets = await getEntityPresets(candidate)
+                    if (!candidatePresets.includes(entity.name)) continue
+                    // renderPresets reads the presets to render off this map,
+                    // and on a preset-only build nothing else populated it.
+                    assetsMap[candidate.id] ??= candidatePresets
+                    presetMoved.add(candidate.id)
+                    if (!entitiesToRender.has(candidate.id)) {
+                        entitiesToRender.set(candidate.id, candidate)
                     }
                 }
             } else {
@@ -472,7 +502,7 @@ export function assets(options = {}) {
             }
         }, { concurrency: 10, signal })
 
-        await renderPresets(entitiesToRender.values())
+        await renderPresets(entitiesToRender.values(), { rendererChanged: presetMoved })
     })
 
     onComplete(async ({ entity, options }) => {

package/src/server.js

@@ -220,13 +220,42 @@ export function setupServer() {
                    .sendFile(faviconFile)
             })
 
-            await new Promise(resolve => {
-                const httpServer = runtime.options.app.listen(runtime.options.port, () => {
+            // Why this needs an error handler AND an address() check, rather
+            // than trusting the callback:
+            //
+            // `app.listen(port, cb)` invokes cb even when the bind FAILED —
+            // observed with a squatter on the port, cb running with
+            // `address() === null` and EADDRINUSE arriving on the error event
+            // afterwards. With no error handler, the process logged
+            // "Server listening: http://localhost:3779", printed a LAN
+            // address, completed the build green, and answered nothing: every
+            // request went to whoever actually held the port, which on a dev
+            // machine is another project's site. The operator opens the
+            // address, sees somebody else's pages, and the log insists they
+            // are their own.
+            //
+            // A server that cannot bind is not a server. --server asks to
+            // BECOME the instance, which is exactly the request that cannot be
+            // satisfied by carrying on — the same reasoning that makes a second
+            // server exit 1 rather than forward.
+            await new Promise((resolve, reject) => {
+                const httpServer = runtime.options.app.listen(runtime.options.port, function onListening() {
                     // Public URL wins for operator-clickable log lines —
                     // a reverse-proxy/tunnel/ngrok setup binds locally but
                     // is reached externally at runtime.options.url. Fall
                     // back to the bind URL when no public origin is set.
-                    const externalUrl = runtime.options.url ?? `http://localhost:${runtime.options.port}`
+                    // The bind is the authority on which port answers, not
+                    // the port that was asked for. A null address means the
+                    // listen failed and the error handler below owns it — say
+                    // nothing here, or the log claims a port it does not have.
+                    // `this`, not the const above: EventEmitter calls a
+                    // listener with the emitter, and a synchronous listen
+                    // reaches here while `httpServer` is still in its
+                    // temporal dead zone.
+                    const bound = this?.address?.()
+                    if (!bound) return
+
+                    const externalUrl = runtime.options.url ?? `http://localhost:${bound.port}`
                     logger.info('Server listening: %s', externalUrl)
 
                     // The addresses that are NOT localhost.
@@ -246,13 +275,25 @@ export function setupServer() {
                         const lan = localAddresses()
                         if (lan.length) {
                             logger.info('Also on: %s', lan
-                                .map(address => `http://${address}:${runtime.options.port}`)
+                                .map(address => `http://${address}:${bound.port}`)
                                 .join('  '))
                         }
                     }
                     resolve()
                 })
 
+                httpServer.on('error', (err) => {
+                    if (err.code === 'EADDRINUSE') {
+                        reject(new Error(
+                            `port ${runtime.options.port} is already in use — something else is listening there, `
+                            + `and requests to it will reach that instead of this build. `
+                            + `Stop it, or pass --server <other port>.`))
+                        return
+                    }
+                    reject(new Error(
+                        `could not listen on port ${runtime.options.port} — ${err.code ?? err.message}`))
+                })
+
                 // Node caps a single request at 5 minutes (requestTimeout,
                 // default 300_000ms), which is not a timeout in the usual
                 // sense here — it is an upload size limit expressed in