@vmz/core 0.3.14 → 0.3.15

package/dist/browser/direct-api.types.d.ts

@@ -127,6 +127,10 @@ export type DirectApi = {
     el: (tag: string) => Element;
     text: (value?: unknown) => Text;
     frag: () => DocumentFragment;
+    /** Multi-root `<template v-for>` row fragment (scoped on resume by key). */
+    fragRow: (key?: unknown) => DocumentFragment;
+    /** Closes the row scope opened by `fragRow`. */
+    rowEnd: () => void;
     comment: (value?: string) => Comment;
     attr: (el: Element, name: string, value: unknown) => void;
     mergeClass: (...parts: unknown[]) => string;
@@ -140,6 +144,7 @@ export type DirectApi = {
     onMethod: (el: Element, type: string, method: string) => void;
     onComponentEvent: (el: Element, type: string, method: string) => void;
     adoptEnter: (node: Element) => boolean;
+    adoptEnterSlot: (hostEl: Element, name: string) => boolean;
     adoptLeave: () => void;
     projectDefaultSlot: (hostEl: HTMLElement, node: Node) => void;
     projectNamedSlot: (hostEl: HTMLElement, name: string, node: Node) => void;

package/dist/browser/direct-host-box.d.ts

@@ -9,3 +9,14 @@ export declare function resolveDirectHostBox(name: string, Ctor: ComponentCtor |
 export declare function applyDirectHostBox(host: HTMLElement, name: string, Ctor: ComponentCtor | null | undefined): void;
 /** SSR attrs fragment for host box (only when contents). */
 export declare function directHostBoxStyleAttr(name: string, Ctor: ComponentCtor | null | undefined): string | null;
+/**
+ * Host element tag (`div` vs `span`).
+ *
+ * `display: contents` chips are phrasing content, so a `<div>` host is invalid
+ * HTML inside `<p>`. The browser parser then closes the `<p>` early and moves
+ * the host (and its trailing text) out of it, which desynchronizes the SSR tree
+ * from the client tree and makes resume rebuild those nodes. Emitting a `<span>`
+ * host keeps the SSR markup parse-stable: the parsed tree matches the tree the
+ * client `__vmzCreate` builds.
+ */
+export declare function resolveDirectHostTag(name: string, Ctor: ComponentCtor | null | undefined): 'div' | 'span';

package/dist/browser/direct-host-box.js

@@ -23,3 +23,16 @@ export function applyDirectHostBox(host, name, Ctor) {
 export function directHostBoxStyleAttr(name, Ctor) {
     return resolveDirectHostBox(name, Ctor) === 'contents' ? 'display:contents' : null;
 }
+/**
+ * Host element tag (`div` vs `span`).
+ *
+ * `display: contents` chips are phrasing content, so a `<div>` host is invalid
+ * HTML inside `<p>`. The browser parser then closes the `<p>` early and moves
+ * the host (and its trailing text) out of it, which desynchronizes the SSR tree
+ * from the client tree and makes resume rebuild those nodes. Emitting a `<span>`
+ * host keeps the SSR markup parse-stable: the parsed tree matches the tree the
+ * client `__vmzCreate` builds.
+ */
+export function resolveDirectHostTag(name, Ctor) {
+    return resolveDirectHostBox(name, Ctor) === 'contents' ? 'span' : 'div';
+}

package/dist/browser/dom/direct-api.d.ts

@@ -25,8 +25,16 @@ export declare const directApi: {
     nsScopeDepth(): number;
     rewindNsScope(depth: any): void;
     adoptEnter(node: any): boolean;
+    adoptEnterSlot(hostEl: any, name: any): boolean;
     adoptLeave(): void;
     frag(): DocumentFragment;
+    /**
+     * Multi-root `<template v-for>` row. Resume narrows adoption to the SSR
+     * marker pair for this key; a key with no pair gets an empty scope so a new
+     * row can never steal nodes that belong to another key.
+     */
+    fragRow(key?: any): DocumentFragment;
+    rowEnd(): void;
     comment(value: any): Comment;
     insertBefore(parent: any, node: any, ref: any): void;
     removeNode(node: any): void;

package/dist/browser/dom/direct-api.js

@@ -1,6 +1,6 @@
 import { mergeClassParts, mergeStyleParts } from '../../shared/dom-attr-normalize.js';
 import { HTML_HASH_ATTR, htmlDigest } from '../../shared/html-digest.js';
-import { applyDirectHostBox } from '../direct-host-box.js';
+import { applyDirectHostBox, resolveDirectHostTag } from '../direct-host-box.js';
 import { createUnknownComponentElement } from '../unknown-component.js';
 import { applyDomAttr, eventPropHandlerName } from './attributes.js';
 import { createInstance, destroy, disposeDomTree, findOwnedDefaultSlotTarget, findOwnedNamedSlot, insertProjectedSlotNode, parkSlotNode, runDirectCreate, slotAnchorFor, stripFns, } from './component.js';
@@ -192,15 +192,41 @@ export const directApi = {
      * new payload and refreshes the marker for later identical runs.
      */
     html(el, value) {
-        const next = value == null ? '' : String(value);
+        let next;
+        if (value == null) {
+            // `null` is "this create has no payload yet", not "the payload is
+            // empty": a resumed host may still own the SSR payload, so hand the
+            // parked subtree back instead of clearing the server's markup. After
+            // the resume pass ends `_resumeAdopt` is gone and a null patch
+            // clears the host like Vue's `v-html` does.
+            const adopt = directApi._resumeAdopt;
+            if (adopt && typeof adopt.keepHtml === 'function' && adopt.keepHtml(el))
+                return;
+            // Already holding the SSR payload from an earlier null create: the
+            // create and its tracked patch both pass null, and only a real payload
+            // (or a host without one) may release the server's markup.
+            if (el.__vmzHtmlKeep)
+                return;
+            next = '';
+        }
+        else {
+            el.__vmzHtmlKeep = false;
+            next = String(value);
+        }
         const digest = htmlDigest(next);
         const adopt = directApi._resumeAdopt;
         if (adopt && typeof adopt.reclaimHtml === 'function' && adopt.reclaimHtml(el, digest))
             return;
-        const marker = typeof el.getAttribute === 'function' ? el.getAttribute(HTML_HASH_ATTR) : null;
+        // The browser serializer expands self-closing tags (`<path/>` becomes
+        // `<path></path>`), so `innerHTML` never equals the generated string for
+        // SVG payloads. Compare the payload digest instead: an equal stamp means
+        // this host already holds exactly this payload, so a repeated patch must
+        // keep the live nodes (identity, focus, and `ResizeObserver` targets).
+        if (typeof el.getAttribute === 'function' && el.getAttribute(HTML_HASH_ATTR) === digest)
+            return;
         if (el.innerHTML !== next)
             el.innerHTML = next;
-        if (marker != null)
+        if (typeof el.setAttribute === 'function')
             el.setAttribute(HTML_HASH_ATTR, digest);
     },
     nsScopeDepth() {
@@ -222,6 +248,17 @@ export const directApi = {
         }
         return false;
     },
+    adoptEnterSlot(hostEl, name) {
+        nsStack.push(isSvgNode(hostEl));
+        const adopt = directApi._resumeAdopt;
+        if (adopt && typeof adopt.enterSlot === 'function') {
+            const ok = adopt.enterSlot(hostEl, name);
+            if (ok)
+                adopt._enterBalance = (adopt._enterBalance || 0) + 1;
+            return ok;
+        }
+        return false;
+    },
     adoptLeave() {
         nsStack.pop();
         const adopt = directApi._resumeAdopt;
@@ -239,6 +276,22 @@ export const directApi = {
         noteDomCreate();
         return document.createDocumentFragment();
     },
+    /**
+     * Multi-root `<template v-for>` row. Resume narrows adoption to the SSR
+     * marker pair for this key; a key with no pair gets an empty scope so a new
+     * row can never steal nodes that belong to another key.
+     */
+    fragRow(key) {
+        const adopt = directApi._resumeAdopt;
+        if (adopt && typeof adopt.rowStart === 'function')
+            adopt.rowStart(key);
+        return directApi.frag();
+    },
+    rowEnd() {
+        const adopt = directApi._resumeAdopt;
+        if (adopt && typeof adopt.rowEnd === 'function')
+            adopt.rowEnd();
+    },
     comment(value) {
         noteDomCreate();
         return document.createComment(value == null ? '' : String(value));
@@ -307,6 +360,15 @@ export const directApi = {
         disposeDomTree(root);
     },
     attr(el, name, value) {
+        // `v-pre`: the authored pair goes out untouched — no `className` → `class`
+        // rewrite, no class/style merge, no property special-casing.
+        if (el.__vmzVerbatim) {
+            if (value == null || value === false)
+                el.removeAttribute(name);
+            else
+                el.setAttribute(name, value === true ? '' : String(value));
+            return;
+        }
         applyDomAttr(el, name, value);
     },
     mergeClass(...parts) {
@@ -481,9 +543,11 @@ export const directApi = {
                 raw = get.call(inst);
             }
             catch {
-                raw = '';
+                raw = null;
             }
-            el.innerHTML = raw == null ? '' : String(raw);
+            // Same payload contract as the emitted `v-html` call: digest
+            // matching and resume adoption must not be bypassed here.
+            directApi.html(el, raw);
         }, bindingId);
     },
     /**
@@ -513,7 +577,7 @@ export const directApi = {
         }
         if (!host) {
             noteDomCreate();
-            host = document.createElement('div');
+            host = document.createElement(resolveDirectHostTag(name, nameOrCtor));
             host.setAttribute('data-vmz', name);
         }
         if (key != null)
@@ -543,7 +607,7 @@ export const directApi = {
         }
         if (!host) {
             noteDomCreate();
-            host = document.createElement('div');
+            host = document.createElement(resolveDirectHostTag(name, initial));
             host.setAttribute('data-vmz', name);
         }
         if (key != null)

package/dist/browser/dom-core.types.d.ts

@@ -7,6 +7,8 @@ export type ComponentCtor = ComponentCtorLike & {
     [key: string]: unknown;
 };
 export type VmzDomElement = Element & {
+    /** `v-pre` subtree: attributes are written exactly as authored. */
+    __vmzVerbatim?: boolean;
     __vmzEvt?: Record<string, EventListener>;
     __vmzObjEvt?: Record<string, {
         types: Record<string, {
@@ -80,12 +82,19 @@ export type ResumeAdoptCtx = {
     text: (value?: unknown) => Text;
     componentHost?: (name: string, key?: unknown) => HTMLElement | null;
     enter?: (node: Element) => boolean;
+    /** Open a named `<slot name="…">` projection scope inside a component host. */
+    enterSlot?: (hostEl: Element, name: string) => boolean;
     leave?: () => void;
     scopeDepth?: () => number;
     rewindScope?: (depth: number) => void;
     beginBranchScope?: () => () => void;
+    /** Open a multi-root `<template v-for>` row scope (claim the SSR marker pair). */
+    rowStart?: (key: unknown) => boolean;
+    rowEnd?: () => void;
     /** Keep the parked SSR subtree when its SSR payload digest equals `digest`. */
     reclaimHtml?: (el: Element, digest: string) => boolean;
+    /** Keep the parked SSR subtree when this create has no payload yet. */
+    keepHtml?: (el: Element) => boolean;
     _enterBalance?: number;
     inst?: DirectInstance;
 };

package/dist/browser/resume/adopt.js

@@ -1,5 +1,6 @@
-import { directApi, findOwnedDefaultSlot, noteDomCreate, runDirectCreate, } from '../dom-core.js';
+import { directApi, findOwnedDefaultSlot, findOwnedNamedSlot, noteDomCreate, runDirectCreate, } from '../dom-core.js';
 import { HTML_HASH_ATTR } from '../../shared/html-digest.js';
+import { ROW_END_MARKER_PREFIX, ROW_MARKER_PREFIX, rowEndMarker, rowMarker } from '../../shared/row-key.js';
 const SVG_NS = 'http://www.w3.org/2000/svg';
 function createResumeAdopt(pool, rootEl) {
     const used = new WeakSet();
@@ -33,6 +34,13 @@ function createResumeAdopt(pool, rootEl) {
         n.__vmzResumePool = childPool;
         return n;
     };
+    /**
+     * Component hosts are claimed only by `componentHost`, never by plain element
+     * adoption. Hosts may be `<span>` (phrasing inline chips) or `<div>` (block
+     * surfaces), so tag matching alone would let a page `<span>` steal a chip host
+     * and force a rebuild.
+     */
+    const isComponentHost = (el) => typeof el.getAttribute === 'function' && el.getAttribute('data-vmz') != null;
     function* elementCandidates() {
         const scope = currentScope();
         if (scope === pool && rootEl && !used.has(rootEl))
@@ -80,7 +88,7 @@ function createResumeAdopt(pool, rootEl) {
             return fresh;
         }
         for (const el of elementCandidates()) {
-            if (String(el.tagName).toLowerCase() === want)
+            if (String(el.tagName).toLowerCase() === want && !isComponentHost(el))
                 return markElement(el);
         }
         noteDomCreate();
@@ -153,8 +161,6 @@ function createResumeAdopt(pool, rootEl) {
         const want = String(name || '');
         const wanted = key == null ? null : String(key);
         for (const el of elementCandidates()) {
-            if (String(el.tagName).toLowerCase() !== 'div')
-                continue;
             if (el.getAttribute('data-vmz') !== want)
                 continue;
             if (wanted != null && el.getAttribute('data-vmz-key') !== wanted)
@@ -187,9 +193,42 @@ function createResumeAdopt(pool, rootEl) {
                 return true;
             }
         }
-        if (!node.__vmzResumePool)
+        // Emitted `adoptEnter` is always paired with `adoptLeave`, but a node that
+        // has no SSR counterpart (fresh element or fresh component host) has no
+        // parked pool. Returning without pushing made that paired leave pop the
+        // caller's scope instead, so each rebuilt node drifted the stack one level
+        // up and later projection siblings (slot roots 2..n) lost their pool.
+        // Push an isolated empty scope: the rebuilt subtree has no SSR counterpart
+        // to reclaim, and its children must not steal the enclosing siblings.
+        scopeStack.push(node.__vmzResumePool || document.createDocumentFragment());
+        return true;
+    };
+    /**
+     * Push the parked pool of an owned named `<slot name="…">` outlet.
+     *
+     * SSR inlines named projections exactly like the default outlet, so the nodes
+     * a page projects into `#header` sit under the named outlet and stay
+     * unreachable from the default pool that `enter(host)` pushes. Without this
+     * scope the named projection is rebuilt on every load while the default
+     * projection is reclaimed. A host without that outlet (fresh component or a
+     * name the component never declares) gets an isolated empty scope so the
+     * emitted enter/leave pair always stays balanced.
+     */
+    const enterSlot = (hostEl, name) => {
+        if (!hostEl)
             return false;
-        scopeStack.push(node.__vmzResumePool);
+        const wanted = name == null ? '' : String(name);
+        if (!wanted || wanted === 'default')
+            return enter(hostEl);
+        const owner = hostEl.__vmzInst;
+        const root = (owner && owner.__vmzDomRoot) || hostEl;
+        const slot = root && root.nodeType === 1 ? findOwnedNamedSlot(root, wanted) : null;
+        const slotPool = slot && slot.__vmzResumePool;
+        if (slotPool && hasUnusedNode(slotPool)) {
+            scopeStack.push(slotPool);
+            return true;
+        }
+        scopeStack.push(document.createDocumentFragment());
         return true;
     };
     const leave = () => {
@@ -251,18 +290,117 @@ function createResumeAdopt(pool, rootEl) {
                 el.appendChild(childPool.firstChild);
         return true;
     };
+    /**
+     * `v-html` create with no payload yet (e.g. an async highlighter that has
+     * not produced one). The host may still own the SSR payload: hand the parked
+     * subtree back and leave the SSR stamp untouched so a later authoritative
+     * patch can still match it. The host keeps that payload until a real payload
+     * lands; once one does, a null patch clears it like `v-html` always has.
+     */
+    const keepHtml = (el) => {
+        if (!used.has(el))
+            return false;
+        // The emitted `v-html` create and its tracked patch both run with a null
+        // payload (the patch applies once right after create), so the hold must
+        // outlive the resume pass: one restore is enough until a payload lands.
+        if (el.__vmzHtmlKeep)
+            return true;
+        const childPool = el.__vmzResumePool;
+        if (!childPool || !childPool.firstChild)
+            return false;
+        while (childPool.firstChild)
+            el.appendChild(childPool.firstChild);
+        el.__vmzResumePool = null;
+        el.__vmzHtmlKeep = true;
+        return true;
+    };
+    /**
+     * Scope adoption to one multi-root `<template v-for>` row.
+     *
+     * The row has no element root to carry `data-vmz-key`, so SSR wrote a
+     * `<!--vmz-row:KEY-->…<!--vmz-row-end:KEY-->` pair around its nodes. Claim
+     * exactly that pair, move its inner nodes into a private scope, and drop the
+     * markers so the resumed DOM matches a client-created row. A missing or
+     * unbalanced pair means "this row is not in SSR": push an empty scope so the
+     * row is built fresh instead of stealing a sibling row's nodes.
+     */
+    const rowStart = (key) => {
+        const scope = currentScope();
+        const rowPool = document.createDocumentFragment();
+        let claimed = false;
+        if (key != null) {
+            const wanted = rowMarker(key);
+            const wantedEnd = rowEndMarker(key);
+            const nodes = [...scope.childNodes];
+            let start = -1;
+            for (let i = 0; i < nodes.length; i++) {
+                const n = nodes[i];
+                if (n.nodeType !== 8)
+                    continue;
+                if (String(n.nodeValue || '') === wanted) {
+                    start = i;
+                    break;
+                }
+            }
+            let end = -1;
+            if (start >= 0) {
+                // Nested rows directly inside this row contribute their own pair at
+                // the same sibling level, so pairing is depth-counted.
+                let depth = 0;
+                for (let i = start + 1; i < nodes.length; i++) {
+                    const n = nodes[i];
+                    if (n.nodeType !== 8)
+                        continue;
+                    const data = String(n.nodeValue || '');
+                    if (data.startsWith(ROW_MARKER_PREFIX)) {
+                        depth += 1;
+                    }
+                    else if (data.startsWith(ROW_END_MARKER_PREFIX)) {
+                        if (depth === 0) {
+                            if (data === wantedEnd)
+                                end = i;
+                            break;
+                        }
+                        depth -= 1;
+                    }
+                }
+            }
+            if (end > start) {
+                const startMarker = nodes[start];
+                const endMarker = nodes[end];
+                for (let i = start + 1; i < end; i++)
+                    rowPool.appendChild(nodes[i]);
+                if (startMarker.parentNode === scope)
+                    scope.removeChild(startMarker);
+                if (endMarker.parentNode === scope)
+                    scope.removeChild(endMarker);
+                claimed = true;
+            }
+        }
+        scopeStack.push(rowPool);
+        return claimed;
+    };
+    const rowEnd = () => {
+        if (scopeStack.length <= 1)
+            return;
+        scopeStack.pop();
+    };
     return {
         el: adoptElement,
         elNS: adoptElementNS,
         claimKeyed,
+        rowStart,
+        rowEnd,
         text: adoptText,
         componentHost,
         enter,
+        enterSlot,
         leave,
         scopeDepth,
         rewindScope,
         beginBranchScope,
         reclaimHtml,
+        keepHtml,
     };
 }
 export function runDirectResume(Component, inst, container) {

package/dist/shared/row-key.d.ts

@@ -0,0 +1,13 @@
+/** SSR row identity for multi-root `<template v-for>` rows. */
+export declare const ROW_MARKER_PREFIX = "vmz-row:";
+export declare const ROW_END_MARKER_PREFIX = "vmz-row-end:";
+/**
+ * Comment-safe row key token.
+ *
+ * Row identity travels inside HTML comments, where `--` is illegal. Encode the
+ * key once (both SSR writer and resume reader use this same function) and strip
+ * the remaining hyphens so no key can ever close the comment early.
+ */
+export declare function rowKeyToken(key: unknown): string;
+export declare function rowMarker(key: unknown): string;
+export declare function rowEndMarker(key: unknown): string;

package/dist/shared/row-key.js

@@ -0,0 +1,19 @@
+/** SSR row identity for multi-root `<template v-for>` rows. */
+export const ROW_MARKER_PREFIX = 'vmz-row:';
+export const ROW_END_MARKER_PREFIX = 'vmz-row-end:';
+/**
+ * Comment-safe row key token.
+ *
+ * Row identity travels inside HTML comments, where `--` is illegal. Encode the
+ * key once (both SSR writer and resume reader use this same function) and strip
+ * the remaining hyphens so no key can ever close the comment early.
+ */
+export function rowKeyToken(key) {
+    return encodeURIComponent(String(key)).replace(/-/g, '%2D');
+}
+export function rowMarker(key) {
+    return `${ROW_MARKER_PREFIX}${rowKeyToken(key)}`;
+}
+export function rowEndMarker(key) {
+    return `${ROW_END_MARKER_PREFIX}${rowKeyToken(key)}`;
+}

package/dist/ssr/serialize.js

@@ -1,8 +1,9 @@
-import { directHostBoxStyleAttr } from '../browser/direct-host-box.js';
+import { directHostBoxStyleAttr, resolveDirectHostTag } from '../browser/direct-host-box.js';
 import { BOOLEAN_HTML_ATTRS, createInstance, eventPropHandlerName, getRegisteredComponent, isEventEntryStrategy, mergeClassParts, mergeStyleParts, snapshotInstanceState, stripFns, } from '../browser/dom-core.js';
 import { serializeUnknownComponentNode } from '../browser/unknown-component.js';
 import { splitStyleDeclarations } from '../shared/dom-attr-normalize.js';
 import { HTML_HASH_ATTR, htmlDigest } from '../shared/html-digest.js';
+import { rowEndMarker, rowMarker } from '../shared/row-key.js';
 import { _ssrDocumentLastError, ensureSsrDocument } from './document.js';
 import { awaitSsrOnMount, ssrComponentName, ssrOnMountContext } from './onmount.js';
 function runDirectSerializeTree(Component, inst) {
@@ -141,26 +142,33 @@ function serializeStyleAttr(node) {
 function serializeOpenTag(node) {
     const tag = node.tag || 'div';
     const lowerTag = String(tag).toLowerCase();
+    // `v-pre`: the authored attribute names are the output. Skipping the four
+    // special branches here is what keeps `className` / `style` / `value` /
+    // `data-vmz-html-hash` literal inside a verbatim subtree.
+    const verbatim = node.__vmzVerbatim === true;
     let attrs = '';
     for (const [k, v] of Object.entries(node.attrs || {})) {
         if (v == null || v === false)
             continue;
-        // `textarea` value renders as text content and `select` value as a
-        // selected option, so the raw attribute must not be emitted.
-        if (k === 'value' && (lowerTag === 'textarea' || lowerTag === 'select'))
-            continue;
-        if (k === 'style')
-            continue;
-        // Always replaced by the digest of the payload written below, so an
-        // author-supplied marker can never mask a different payload.
-        if (k === HTML_HASH_ATTR)
-            continue;
-        if (k === 'className')
-            attrs += ` class="${escapeHtml(v)}"`;
-        else
-            attrs += ` ${k}="${escapeHtml(v)}"`;
+        if (!verbatim) {
+            // `textarea` value renders as text content and `select` value as a
+            // selected option, so the raw attribute must not be emitted.
+            if (k === 'value' && (lowerTag === 'textarea' || lowerTag === 'select'))
+                continue;
+            if (k === 'style')
+                continue;
+            // Always replaced by the digest of the payload written below, so an
+            // author-supplied marker can never mask a different payload.
+            if (k === HTML_HASH_ATTR)
+                continue;
+            if (k === 'className') {
+                attrs += ` class="${escapeHtml(v)}"`;
+                continue;
+            }
+        }
+        attrs += ` ${k}="${escapeHtml(v)}"`;
     }
-    const style = serializeStyleAttr(node);
+    const style = verbatim ? '' : serializeStyleAttr(node);
     if (style)
         attrs += ` style="${escapeHtml(style)}"`;
     // `v-html` hosts carry the digest of the exact string SSR wrote, so the
@@ -182,7 +190,14 @@ export function flattenSerializeNode(node) {
     if (node.__kind === 'frag') {
         if (node.__rawHtml != null)
             return String(node.__rawHtml);
-        return (node.children || []).map(flattenSerializeNode).join('');
+        const inner = (node.children || []).map(flattenSerializeNode).join('');
+        // Multi-root `<template v-for>` rows have no element root to carry
+        // `data-vmz-key`, so their identity travels as a marker pair around the
+        // row's nodes. Resume reads the same pair and scopes adoption to it.
+        if (node.__vmzRowKey != null) {
+            return `<!--${rowMarker(node.__vmzRowKey)}-->${inner}<!--${rowEndMarker(node.__vmzRowKey)}-->`;
+        }
+        return inner;
     }
     if (node.__kind === 'el') {
         const tag = node.tag || 'div';
@@ -232,6 +247,13 @@ export function* streamSerializeChunks(node) {
             yield String(node.__rawHtml);
             return;
         }
+        if (node.__vmzRowKey != null) {
+            yield `<!--${rowMarker(node.__vmzRowKey)}-->`;
+            for (const c of node.children || [])
+                yield* streamSerializeChunks(c);
+            yield `<!--${rowEndMarker(node.__vmzRowKey)}-->`;
+            return;
+        }
         for (const c of node.children || [])
             yield* streamSerializeChunks(c);
         return;
@@ -578,6 +600,16 @@ const serializeApi = {
             },
         };
     },
+    /** Multi-root `<template v-for>` row fragment; serializes its marker pair. */
+    fragRow(key) {
+        const frag = serializeApi.frag();
+        if (key != null)
+            frag.__vmzRowKey = String(key);
+        return frag;
+    },
+    rowEnd() {
+        /* SSR rows are one-shot: the marker pair closes at serialization. */
+    },
     insertBefore(parent, node, ref) {
         virtualInsertBefore(parent, node, ref);
     },
@@ -627,6 +659,15 @@ const serializeApi = {
     attr(el, name, value) {
         if (!el || el.__kind !== 'el')
             return;
+        // `v-pre`: keep the authored name and value — no `className` → `class`
+        // rewrite, no class/style merge, no boolean-attribute normalization.
+        if (el.__vmzVerbatim) {
+            if (value == null || value === false)
+                delete el.attrs[name];
+            else
+                el.attrs[name] = value === true ? '' : String(value);
+            return;
+        }
         applySerializeAttr(el, name, value);
     },
     mergeClass(...parts) {
@@ -644,6 +685,9 @@ const serializeApi = {
     adoptEnter() {
         return false;
     },
+    adoptEnterSlot() {
+        return false;
+    },
     adoptLeave() {
         /* resume scope only */
     },
@@ -893,7 +937,7 @@ const serializeApi = {
             }
             return {
                 __kind: 'el',
-                tag: 'div',
+                tag: resolveDirectHostTag(name, Ctor),
                 attrs,
                 children: body ? [body] : [],
                 appendChild(c) {
@@ -923,7 +967,7 @@ const serializeApi = {
                     attrs['data-vmz-key'] = String(key);
                 return {
                     __kind: 'el',
-                    tag: 'div',
+                    tag: resolveDirectHostTag(name, Ctor),
                     attrs,
                     children: node ? [node] : [],
                     appendChild(c) {

package/package.json

@@ -68,12 +68,12 @@
   "main": "./dist/faces/server.js",
   "name": "@vmz/core",
   "optionalDependencies": {
-    "@vmz/vmz-darwin-arm64": "0.3.14",
-    "@vmz/vmz-darwin-x64": "0.3.14",
-    "@vmz/vmz-linux-arm64": "0.3.14",
-    "@vmz/vmz-linux-x64": "0.3.14",
-    "@vmz/vmz-win32-arm64": "0.3.14",
-    "@vmz/vmz-win32-x64": "0.3.14"
+    "@vmz/vmz-darwin-arm64": "0.3.15",
+    "@vmz/vmz-darwin-x64": "0.3.15",
+    "@vmz/vmz-linux-arm64": "0.3.15",
+    "@vmz/vmz-linux-x64": "0.3.15",
+    "@vmz/vmz-win32-arm64": "0.3.15",
+    "@vmz/vmz-win32-x64": "0.3.15"
   },
   "publishConfig": {
     "access": "public"
@@ -88,5 +88,5 @@
   },
   "type": "module",
   "types": "./dist/faces/index.d.ts",
-  "version": "0.3.14"
+  "version": "0.3.15"
 }