From 982bf4f9e4c3073175c587b3dbf9259b5c616533 Mon Sep 17 00:00:00 2001
From: Cosmin Popovici <hellocosmin@gmail.com>
Date: Tue, 9 Jun 2026 14:00:13 +0300
Subject: [PATCH 1/3] fix(build): include plaintext output in files list

---
 src/render/buildTemplate.ts |  1 +
 src/tests/build.test.ts     | 21 +++++++++++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/render/buildTemplate.ts b/src/render/buildTemplate.ts
index 0e11791a..8a2c40fc 100644
--- a/src/render/buildTemplate.ts
+++ b/src/render/buildTemplate.ts
@@ -133,6 +133,7 @@ export async function buildTemplate(
 
       mkdirSync(dirname(ptOutputPath), { recursive: true })
       writeFileSync(ptOutputPath, plaintext)
+      files.push(ptOutputPath)
     }
   } finally {
     _setCurrentTemplate(undefined)
diff --git a/src/tests/build.test.ts b/src/tests/build.test.ts
index 9ef6ab69..4c02d349 100644
--- a/src/tests/build.test.ts
+++ b/src/tests/build.test.ts
@@ -444,7 +444,7 @@ describe('build', () => {
 
       const result = await build({ plaintext: true })
 
-      expect(result.files).toHaveLength(1)
+      expect(result.files).toHaveLength(2)
 
       const txtPath = result.files[0].replace(/\.html$/, '.txt')
       expect(existsSync(txtPath)).toBe(true)
@@ -466,7 +466,7 @@ describe('build', () => {
 
       const result = await build({ plaintext: { destination: customPath } })
 
-      expect(result.files).toHaveLength(1)
+      expect(result.files).toHaveLength(2)
       expect(existsSync(join(customPath, 'test.txt'))).toBe(true)
     })
 
@@ -530,6 +530,23 @@ describe('build', () => {
       expect(txt).not.toContain('<div>')
     })
 
+    it('includes plaintext files in result.files and the afterBuild payload', async () => {
+      writeSfc(tempDir, 'emails/test.vue', `
+        <template>
+          <div>Hello</div>
+        </template>
+      `)
+
+      let afterBuildFiles: string[] = []
+      const result = await build({
+        plaintext: true,
+        afterBuild({ files }) { afterBuildFiles = files },
+      })
+
+      expect(result.files.some(f => f.endsWith('.txt'))).toBe(true)
+      expect(afterBuildFiles.some(f => f.endsWith('.txt'))).toBe(true)
+    })
+
     it('usePlaintext() with custom extension', async () => {
       writeSfc(tempDir, 'emails/test.vue', `
         <script setup>

From b3325df7c7eda14dc2054ea6ec6f020aace429bf Mon Sep 17 00:00:00 2001
From: Cosmin Popovici <hellocosmin@gmail.com>
Date: Tue, 9 Jun 2026 14:03:11 +0300
Subject: [PATCH 2/3] fix(build): deep-clone config per template to isolate
 nested mutations

---
 src/render/buildTemplate.ts |  3 ++-
 src/tests/build.test.ts     | 39 +++++++++++++++++++++++++++++++++++++
 src/utils/cloneConfig.ts    | 20 +++++++++++++++++++
 3 files changed, 61 insertions(+), 1 deletion(-)
 create mode 100644 src/utils/cloneConfig.ts

diff --git a/src/render/buildTemplate.ts b/src/render/buildTemplate.ts
index 8a2c40fc..7b2dcd24 100644
--- a/src/render/buildTemplate.ts
+++ b/src/render/buildTemplate.ts
@@ -5,6 +5,7 @@ import { runTransformers } from '../transformers/index.ts'
 import { createPlaintext } from '../plaintext.ts'
 import { stripForHtml, stripForPlaintext } from '../utils/output-markers.ts'
 import { _setCurrentTemplate } from '../composables/useCurrentTemplate.ts'
+import { cloneConfig } from '../utils/cloneConfig.ts'
 import type { EventManager } from '../events/index.ts'
 import type { Renderer } from './createRenderer.ts'
 import type { MaizzleConfig } from '../types/index.ts'
@@ -57,7 +58,7 @@ export async function buildTemplate(
      * preheader, injecting fetched data, etc.) stay scoped to this template
      * instead of leaking into later ones through the shared config object.
      */
-    const renderConfig = defu({}, config) as MaizzleConfig
+    const renderConfig = cloneConfig(config)
     const originalSource = template.source
 
     await events.fireBeforeRender({ config: renderConfig, template })
diff --git a/src/tests/build.test.ts b/src/tests/build.test.ts
index 4c02d349..2f81640f 100644
--- a/src/tests/build.test.ts
+++ b/src/tests/build.test.ts
@@ -210,6 +210,45 @@ describe('build', () => {
     expect(bHtml).toContain('none')
   })
 
+  it('scopes nested beforeRender config mutations per template', async () => {
+    writeSfc(tempDir, 'emails/a.vue', `
+      <script setup>
+        const config = useConfig()
+      </script>
+      <template>
+        <div>{{ config.custom.val }}</div>
+      </template>
+    `)
+
+    writeSfc(tempDir, 'emails/b.vue', `
+      <script setup>
+        const config = useConfig()
+      </script>
+      <template>
+        <div>{{ config.custom.val }}</div>
+      </template>
+    `)
+
+    writeFileSync(join(tempDir, 'maizzle.config.js'), `
+      export default {
+        custom: { val: 'base' },
+        beforeRender({ template, config }) {
+          if (template.path.name === 'a') config.custom.val = 'AAA'
+        }
+      }
+    `)
+
+    const result = await build()
+    const aHtml = readFileSync(result.files.find(f => f.includes('a.html'))!, 'utf-8')
+    const bHtml = readFileSync(result.files.find(f => f.includes('b.html'))!, 'utf-8')
+
+    // 'a' sees its own nested mutation
+    expect(aHtml).toContain('AAA')
+    // 'b' must NOT inherit 'a's nested mutation (deep per-template clone)
+    expect(bHtml).not.toContain('AAA')
+    expect(bHtml).toContain('base')
+  })
+
   it('fires afterRender event and uses modified HTML', async () => {
     writeSfc(tempDir, 'emails/test.vue', `
       <template>
diff --git a/src/utils/cloneConfig.ts b/src/utils/cloneConfig.ts
new file mode 100644
index 00000000..e6270d70
--- /dev/null
+++ b/src/utils/cloneConfig.ts
@@ -0,0 +1,20 @@
+/**
+ * Deep-clone plain objects so per-template config mutations stay isolated.
+ *
+ * Arrays, functions, and class instances (Date, RegExp, Vite plugins, …) pass
+ * through by reference — only nested plain-object props are copied, which is
+ * what `beforeRender` mutations (`config.url.base`, `config.css.inline`, …)
+ * touch. Sharing arrays by reference matches the parallel worker's merge.
+ */
+export function cloneConfig<T>(value: T): T {
+  if (value === null || typeof value !== 'object') return value
+  if (Array.isArray(value)) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value
+
+  const out: Record<string, unknown> = {}
+  for (const key of Object.keys(value as object)) {
+    out[key] = cloneConfig((value as Record<string, unknown>)[key])
+  }
+
+  return out as T
+}

From 32dec6cf37a75484c60e74670cc98fe57f97d1c5 Mon Sep 17 00:00:00 2001
From: Cosmin Popovici <hellocosmin@gmail.com>
Date: Tue, 9 Jun 2026 14:05:58 +0300
Subject: [PATCH 3/3] fix(inline-css): reset juice code blocks per call to
 prevent cross-template leak

---
 src/tests/transformers/inlineCss.test.ts | 13 +++++++++++++
 src/transformers/inlineCss.ts            |  7 ++++++-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/tests/transformers/inlineCss.test.ts b/src/tests/transformers/inlineCss.test.ts
index b00eef3b..60bea7b2 100644
--- a/src/tests/transformers/inlineCss.test.ts
+++ b/src/tests/transformers/inlineCss.test.ts
@@ -128,6 +128,19 @@ describe('inlineCss', () => {
       // Incomplete definition is ignored; normal inlining still happens.
       expect(result).toContain('color: red')
     })
+
+    it('does not leak custom code blocks into a later call', async () => {
+      const juice = (await import('juice')).default
+
+      run('<style>.red { color: {{% v %}}; }</style><p class="red">x</p>', {
+        codeBlocks: { Twig: { start: '{{%', end: '%}}' } },
+      })
+      expect(juice.codeBlocks).toHaveProperty('Twig')
+
+      // A subsequent call without codeBlocks must reset juice's global state.
+      run('<p>x</p>')
+      expect(juice.codeBlocks).not.toHaveProperty('Twig')
+    })
   })
 
   describe('embedded styles', () => {
diff --git a/src/transformers/inlineCss.ts b/src/transformers/inlineCss.ts
index 782c542b..0d7af3c4 100644
--- a/src/transformers/inlineCss.ts
+++ b/src/transformers/inlineCss.ts
@@ -1,5 +1,8 @@
 import juice from 'juice'
 import { walk, parse, serialize } from '../utils/ast/index.ts'
+
+/** Juice's built-in code blocks, captured before any per-call mutation. */
+const DEFAULT_CODE_BLOCKS = { ...juice.codeBlocks }
 import type { ChildNode, Element } from 'domhandler'
 type JuiceOptions = NonNullable<Parameters<typeof juice>[1]>
 
@@ -99,7 +102,9 @@ export function inlineCssDom(dom: ChildNode[], options: InlineCssOptions = {}):
   juice.widthElements = (widthElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]
   juice.heightElements = (heightElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]
 
-  // Add custom code blocks
+  // Reset to defaults each call so a previous template's custom code blocks
+  // don't accumulate on juice's module-global state, then add this call's.
+  juice.codeBlocks = { ...DEFAULT_CODE_BLOCKS }
   if (codeBlocks && typeof codeBlocks === 'object') {
     Object.entries(codeBlocks).forEach(([key, value]) => {
       if (value.start && value.end) {