mikser-io 8.3.0 → 8.3.1

package/README.md

@@ -208,8 +208,8 @@ For a working starter — config with a real plugin set, sample `documents/`, ex
 The shape mikser fits cleanly:
 
 - **Marketing sites with editorial teams** — content authors work in files (via their editor, a Git client, or `mikser-io-decap`), engineers ship features without negotiating with a CMS schema, the site stays portable.
-- **Multilingual publishing platforms** — the `useHref()` / `useAlternates()` pattern in `sdk-vue` decouples logical references from per-locale URLs. One source tree, many language deployments.
-- **Content-heavy product catalogues** — `documents` + `mikser-io-schemas` + `data` plugin + a Vue frontend = typed product listings with live updates, semantic search via `vector`, and static-CDN-friendly JSON snapshots all at once.
+- **Multilingual publishing platforms** — the `useHref()` / `useAlternates()` pattern decouples logical references from per-locale URLs. One source tree, many language deployments.
+- **Content-heavy product catalogues** — `documents` + `mikser-io-schemas` + `data` plugin + a Frontend Framework = typed product listings with live updates, semantic search via `vector`, and static-CDN-friendly JSON snapshots all at once.
 - **AI-augmented media pipelines** — `assets` plugin presets call out to Replicate / OpenAI / local models to upscale images, transcribe audio, transcode video. The pipeline is JS code, so anything Node can do is in scope.
 - **Mixed-output publishing** — the same source document renders to HTML, PDF (via `post-pdf`), MJML email (via `post-mjml`), and JSON snapshots. One catalog, many output formats, all concurrent.
 - **Headless backends for static frontends** — pair the `api` plugin with `sdk-api` for SSE-driven live frontends; pair the `data` plugin output with any static host for pre-rendered consumption.

package/package.json

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

package/src/engine.js

@@ -9,7 +9,7 @@ import { onInitialize, onInitialized, onRender, onCancel, onCancelled, onFinaliz
 import { useJournal, updateEntry } from './journal.js'
 import { globby } from 'globby'
 import { OPERATION, TASKS } from './constants.js'
-import { changeExtension, formatErrorContext, projectMeta } from './utils.js'
+import { changeExtension, formatErrorContext, projectMeta, lookupKeys } from './utils.js'
 import render from './render.js'
 import postprocess, { loadPlugin as loadPostPlugin } from './postprocess.js'
 import map from 'p-map'
@@ -221,8 +221,16 @@ export async function setup(options) {
         // cycle's CREATE/UPDATE/DELETE journal entries — RENDER entries
         // are this cycle's work, not the trigger.
         //
-        // - `mutatedRefs` is a Set of ids (and hrefs) — fast membership
-        //   check for layout/partial/$-ref edges.
+        // - `mutatedRefs` is a Map<key, Set<lang|null>>: the keys are
+        //   the ids / hrefs / id-minus-extension forms a refClosure
+        //   entry might target; the values are the set of languages
+        //   that touched that key this cycle (null for entities with
+        //   no meta.lang). The Map shape preserves the fast `.has(key)`
+        //   membership check the existing skip logic relied on AND
+        //   adds language information so multilingual sites don't
+        //   over-invalidate. When a French author entity changes,
+        //   English posts that reference the same /authors/<name>
+        //   href don't re-render — the lang sets disagree.
         // - `currentHashes` carries the current input hash for each
         //   mutated entity. Cold-start file discovery emits CREATE for
         //   every file even when content didn't change; without the
@@ -231,26 +239,40 @@ export async function setup(options) {
         // - `mutatedEntities` carries the entity payloads themselves so
         //   the query-match check can call `sift(filter)` against each
         //   mutation to decide whether a stored query dep is hit.
-        const mutatedRefs = new Set()
+        const mutatedRefs = new Map()
         const currentHashes = new Map()
         const mutatedEntities = new Map()
         for await (let { entity, operation } of useJournal('Manifest mutations', [OPERATION.CREATE, OPERATION.UPDATE, OPERATION.DELETE])) {
             if (!entity?.id) continue
-            mutatedRefs.add(entity.id)
-            if (entity.meta?.href) mutatedRefs.add(entity.meta.href)
             mutatedEntities.set(entity.id, entity)
+            const hash = operation === OPERATION.DELETE ? null : inputHashOf(entity)
+            const lang = entity.meta?.lang ?? null
+            // Expand the mutated entity into every form a refClosure
+            // entry might target — id, meta.href, AND id-minus-extension
+            // — via lookupKeys. Without the stripped form, a refClosure
+            // recorded against the natural author/blog-post pattern
+            // (`$author: /documents/authors/dick`) would never match
+            // the mutated `/documents/authors/dick.yml` here and
+            // manifest.shouldSkip would silently return true, pinning
+            // the post's output to bytes that reference stale author
+            // data. refs.inverseClosureOf and catalog.findEntity both
+            // use the same extension-tolerant resolution; the manifest
+            // layer has to match.
+            //
+            // Each key carries the language tag of the mutation so
+            // shouldSkip can constrain by language compatibility.
+            //
             // For DELETE we set `null` as the current hash so manifest.
             // shouldSkip can distinguish "target was deleted from the
             // catalog" from "target wasn't in this cycle's mutations
             // at all." Without this distinction, a consumer whose
             // refClosure points at a deleted partial/layout would
-            // silently skip re-rendering — leaving the disk output
-            // pinned to bytes that reference something no longer in
-            // the catalog.
-            currentHashes.set(
-                entity.id,
-                operation === OPERATION.DELETE ? null : inputHashOf(entity),
-            )
+            // silently skip re-rendering.
+            for (const key of lookupKeys(entity)) {
+                if (!mutatedRefs.has(key)) mutatedRefs.set(key, new Set())
+                mutatedRefs.get(key).add(lang)
+                currentHashes.set(key, hash)
+            }
         }
         let skipped = 0
 

package/src/manifest.js

@@ -253,6 +253,7 @@ export function createManifest(db) {
             if (!snapshot?.inputHash) return false
             if (inputHashOf(entity) !== snapshot.inputHash) return false
             if (!snapshot.refClosure?.length) return true
+            const sourceLang = entity?.meta?.lang ?? null
             for (const entry of snapshot.refClosure) {
                 if (entry.kind === 'query') {
                     if (!entry.filter) return false
@@ -264,6 +265,20 @@ export function createManifest(db) {
                     continue
                 }
                 if (!mutatedRefs?.has(entry.target)) continue
+                // Language scope: if the source has a meta.lang AND the
+                // mutation came from a different meta.lang, the ref
+                // doesn't actually depend on what changed. A `null` lang
+                // in the mutation set means a shared (un-localized)
+                // entity touched the same key — that does invalidate
+                // language-specific sources because the shared entity
+                // is the only variant. Sources without a meta.lang are
+                // language-agnostic and accept any mutation lang.
+                if (sourceLang) {
+                    const mutatedLangs = mutatedRefs.get(entry.target)
+                    if (mutatedLangs && !mutatedLangs.has(sourceLang) && !mutatedLangs.has(null)) {
+                        continue
+                    }
+                }
                 if (!entry.hash) return false
                 const currentHash = currentHashes?.get(entry.target)
                 if (currentHash === undefined) continue