mikser-io 9.40.1 → 9.40.3

package/docs/diagnostics.md

@@ -563,6 +563,18 @@ cannot model is how the entity's own frontmatter would change — that is
 parsed during import, so an edit that moves `meta.layout` moves the
 destination too, and this does not see it.
 
+**Layout sidecars are the one entity answered by a different route.** A
+sidecar never renders, nothing points at it by ref, and no query matches
+it, so all three candidate walks come back empty — yet editing one
+re-renders the whole site. Its dependency is the layout's *input digest*,
+not an edge: `mikser-io-layouts` folds every sidecar script under the
+folder into a single `sharedDigest` carried by every layout's checksum, so
+one sidecar edit moves every layout. `affectedBy` therefore reports every
+destination that rendered through any layout, each attributed to the
+layout it went through. Entities with no layout — a copied asset, a
+`files()` passthrough — stay out, or the answer would be "everything,
+always", which is the same non-answer as "nothing" with the sign flipped.
+
 ### `runtime.provenance`
 
 Where a value was **written** — source file, field path, line and column.

package/package.json

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

package/src/explain.js

@@ -228,6 +228,16 @@ export async function explain(reference) {
                     : 'unknown',
             outputHash: snap.outputHash ?? null,
             parent: snap.parent ?? null,
+            // Which keys of its OWN meta the render read, and which keys it
+            // read off OTHER entities.
+            //
+            // refClosure answers "what would re-render this". These answer
+            // "what does it actually use", which is the question behind a
+            // document that renders to a hole: a key the layout never touches
+            // is either a typo or dead weight, and nothing else on this report
+            // distinguishes them. Empty when the catalog predates the record.
+            metaReads: snap.metaReads ?? [],
+            consumedReads: (snap.consumedReads ?? []).map(([id, keys]) => ({ entity: id, keys })),
             refClosure: (snap.refClosure ?? []).map(entry =>
                 entry.kind === 'query'
                     ? {
@@ -383,6 +393,22 @@ export function formatExplain(report) {
             const gone = e.gone?.length ? '  [TARGET DELETED SINCE]' : ''
             out.push(`  ${e.kind.padEnd(10)} ${e.target}${bound}${e.hash ? `  ${e.hash}` : ''}${gone}`)
         }
+
+        // What the render actually READ, as against what would re-render it.
+        // Capped, because a large page reads a lot and a wall of keys buries
+        // the rest of the report — the full list is in --json.
+        const SHOWN = 12
+        const shown = (keys) => keys.length > SHOWN
+            ? `${keys.slice(0, SHOWN).join(', ')} … +${keys.length - SHOWN} more`
+            : keys.join(', ')
+        if (r.metaReads?.length) {
+            row('metaReads', `${r.metaReads.length} key${r.metaReads.length === 1 ? '' : 's'} of its own meta`)
+            out.push(`             ${shown(r.metaReads)}`)
+        }
+        for (const c of r.consumedReads ?? []) {
+            row('consumed', `${c.entity}  (${c.keys.length})`)
+            out.push(`             ${shown(c.keys)}`)
+        }
     }
 
     out.push('')

package/src/manifest.js

@@ -484,6 +484,25 @@ export function createManifest(db) {
         WHERE refClosure LIKE '%"kind":"query"%'
     `)
 
+    // Everything that rendered through a layout — the blast radius of a change
+    // to a layout SIDECAR.
+    //
+    // A sidecar is reachable by none of the three routes affectedBy otherwise
+    // walks: it never renders, so it has no snapshots; nothing points at it by
+    // ref; and no query matches it. Its dependency is the layout's input
+    // digest, which is not an edge. So the preview answered "nothing would be
+    // affected" for a change that re-renders the entire site — the one
+    // direction of wrong that matters, since it says a site-wide edit is safe.
+    //
+    // The blast radius really is everything: the layouts plugin folds every
+    // OTHER sidecar under the folder into each layout's `shared` digest, so any
+    // sidecar edit moves every layout's checksum, and every page renders
+    // through some layout.
+    const stmtSnapshotsWithLayout = db.prepare(`
+        SELECT id, destination, refClosure FROM mikser_snapshots
+        WHERE refClosure LIKE '%"kind":"layout"%'
+    `)
+
     // Snapshots holding a non-query edge that names any of the given keys,
     // by the name asked for OR by the entity it bound to. Both, for the same
     // reason skipDecision reads both — a name survives a rename only through
@@ -572,6 +591,28 @@ export function createManifest(db) {
             }
 
             const affected = []
+
+            // Sidecars take the route above rather than the candidate walk:
+            // skipDecision compares against the edges a snapshot recorded, and
+            // no snapshot records an edge to a sidecar — it would answer "skip"
+            // for every page and hide the whole radius.
+            if (entity.type === 'sidecar') {
+                for (const row of stmtSnapshotsWithLayout.iterate()) {
+                    let layoutEdge = null
+                    try {
+                        layoutEdge = JSON.parse(row.refClosure ?? '[]').find(e => e.kind === 'layout') ?? null
+                    } catch { /* unreadable closure — still affected, just unattributed */ }
+                    affected.push({
+                        id: row.id,
+                        destination: row.destination,
+                        reason: 'ref-changed',
+                        ...(layoutEdge?.target ? { dependency: layoutEdge.target } : {}),
+                        why: 'a layout sidecar feeds every layout through its shared digest',
+                    })
+                }
+                return affected
+            }
+
             for (const { id, destination } of candidates.values()) {
                 // Its own renders: the premise of the question is that this
                 // entity changed, so asking skipDecision — which compares the