@chilts/weave 0.7.0 → 0.8.0

package/dist/codegen/index.js

@@ -1,6 +1,6 @@
 import { lex } from '../lexer/index.js';
 import { parse } from '../parser/index.js';
-import { chunk, joinChunks, offsetMappings, lineCount, buildSourceMap } from './sourcemap.js';
+import { chunk, concat, joinChunks, mark, offsetMappings, lineCount, buildSourceMap, sliceCaptured, verbatim, } from './sourcemap.js';
 export class CodegenError extends Error {
     line;
     col;
@@ -20,16 +20,22 @@ function capitalize(s) {
 // on its own line too, so the output keeps the shape the source was written in.
 // `ownLine` is false for an extra that opens a multi-line literal of its own.
 function appendArg(args, extra, ownLine = true) {
-    if (args === '')
-        return extra;
-    const body = args.trimEnd();
-    const tail = args.slice(body.length);
+    if (args.code === '')
+        return concat(extra);
+    const body = args.code.trimEnd();
+    const tail = args.code.slice(body.length);
+    // Mappings past the body would sit in the trailing space, which moves.
+    const bodyLines = lineCount(body);
+    const lastLine = body.slice(body.lastIndexOf('\n') + 1);
+    const head = {
+        code: body,
+        mappings: args.mappings.filter(m => m.genLine < bodyLines || (m.genLine === bodyLines && m.genCol < lastLine.length)),
+    };
     if (ownLine && tail.includes('\n')) {
-        const lastLine = body.slice(body.lastIndexOf('\n') + 1);
         const indent = /^ */.exec(lastLine)[0];
-        return `${body}${body.endsWith(',') ? '' : ','}\n${indent}${extra},${tail}`;
+        return concat(head, body.endsWith(',') ? '' : ',', `\n${indent}`, extra, `,${tail}`);
     }
-    return `${body}${body.endsWith(',') ? ' ' : ', '}${extra}`;
+    return concat(head, body.endsWith(',') ? ' ' : ', ', extra);
 }
 // Indents the continuation lines of a multi-line captured expression to sit
 // under the output line it starts on. Captured text never holds a string that
@@ -37,43 +43,90 @@ function appendArg(args, extra, ownLine = true) {
 function reindent(text, prefix) {
     return prefix === '' ? text : text.replace(/\n(?!\n|$)/g, `\n${prefix}`);
 }
+// `reindent` for a chunk: mappings on an indented line move right with it.
+function reindentChunk(c, prefix) {
+    if (prefix === '')
+        return c;
+    const lines = c.code.split('\n');
+    const shifted = (line) => line > 0 && lines[line] !== '';
+    return {
+        code: reindent(c.code, prefix),
+        mappings: c.mappings.map(m => shifted(m.genLine) ? { ...m, genCol: m.genCol + prefix.length } : m),
+    };
+}
+// Wraps generated code around child chunks, mapping the wrapper — at the start
+// and after each child — to the node, so only the children's own text maps
+// elsewhere.
+function within(loc, ...parts) {
+    return concat(mark(loc), ...parts.flatMap((p) => (typeof p === 'string' ? [p] : [p, mark(loc)])));
+}
 function camelToKebab(name) {
     return name.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
 }
-function templateHasBlocks(node) {
+// Every `block` in `nodes`, in source order. Mixin definitions are not
+// descended into: their blocks belong to the mixin, not the caller.
+function collectBlocks(nodes) {
+    const found = [];
     function walk(n) {
-        if (n.type === 'Block')
-            return true;
+        if (n.type === 'Block') {
+            found.push(n);
+            n.children.forEach(walk);
+        }
         if (n.type === 'Element')
-            return n.children.some(walk);
+            n.children.forEach(walk);
+        if (n.type === 'MixinCall')
+            n.block.forEach(walk);
         if (n.type === 'Conditional') {
-            if (n.consequent.some(walk))
-                return true;
-            for (const alt of n.alternates) {
-                if (alt.body.some(walk))
-                    return true;
-            }
-            if (n.fallback?.some(walk))
-                return true;
+            n.consequent.forEach(walk);
+            for (const alt of n.alternates)
+                alt.body.forEach(walk);
+            n.fallback?.forEach(walk);
+        }
+        if (n.type === 'Iteration') {
+            n.body.forEach(walk);
+            n.fallback?.forEach(walk);
         }
-        if (n.type === 'Iteration')
-            return n.body.some(walk);
         if (n.type === 'Extends') {
             // The entries in `blocks` are fills (the slots this template fills in
             // its parent), not slots of its own. A mid-layer template defines its
             // own slots by nesting `block` nodes inside that fill content — those
             // are what require a `blocks` parameter on this function.
-            return n.blocks.some(fill => fill.children.some(walk));
+            for (const fill of n.blocks)
+                fill.children.forEach(walk);
         }
-        return false;
     }
-    return node.body.some(walk);
+    nodes.forEach(walk);
+    return found;
+}
+/** The named slots a template defines, first of each name, in source order. */
+function templateSlots(node) {
+    const slots = new Map();
+    for (const b of collectBlocks(node.body)) {
+        if (b.name !== '' && !slots.has(b.name))
+            slots.set(b.name, b);
+    }
+    return [...slots.values()];
+}
+/** True when a mixin renders its call-site content with a bare `block`. */
+function mixinHasBlock(node) {
+    return collectBlocks(node.body).some(b => b.name === '');
+}
+// The `<Name>Blocks` interface for a template's slots. Each slot is optional
+// (an unfilled slot renders nothing, or its default) and typed like a mixin's
+// call-site content. Each member maps back to the `block` that defines it.
+function blocksInterface(node, slots) {
+    const members = slots.map(b => `    ${b.name}?: () => unknown`);
+    const code = `export interface ${capitalize(node.name)}Blocks {\n${members.join('\n')}\n}`;
+    const mappings = [mapping(node.loc), ...slots.map((b, i) => mapping(b.loc, i + 1))];
+    return { code, mappings };
 }
 function mapping(loc, genLine = 0) {
     return { genLine, genCol: 0, srcLine: loc.line - 1, srcCol: loc.col - 1 };
 }
 class CodeGenerator {
     formatted;
+    // Set while generating a mixin body, where `block` means call-site content.
+    inMixin = false;
     constructor(formatted = false) {
         this.formatted = formatted;
     }
@@ -86,23 +139,19 @@ class CodeGenerator {
      * Non-comment expressions get trailing commas only if more non-comment expressions follow.
      */
     joinWithCommentChunks(chunks, indent) {
-        const allMappings = [];
-        const lines = [];
-        let currentLine = 0;
+        const parts = [];
         for (let i = 0; i < chunks.length; i++) {
             const c = chunks[i];
-            const isComment = c.code.startsWith('//');
-            if (isComment) {
-                lines.push(`${indent}${c.code}`);
-            }
-            else {
+            if (i > 0)
+                parts.push('\n');
+            parts.push(indent, c);
+            if (!c.code.startsWith('//')) {
                 const hasMore = chunks.slice(i + 1).some(e => !e.code.startsWith('//'));
-                lines.push(hasMore ? `${indent}${c.code},` : `${indent}${c.code}`);
+                if (hasMore)
+                    parts.push(',');
             }
-            allMappings.push(...offsetMappings(c.mappings, currentLine));
-            currentLine += lineCount(c.code) + 1;
         }
-        return { code: lines.join('\n'), mappings: allMappings };
+        return concat(...parts);
     }
     genNode(node, indent = 0) {
         switch (node.type) {
@@ -149,55 +198,53 @@ class CodeGenerator {
     genConditional(node, indent) {
         const bi = this.formatted ? this.ind(indent + 1) : '    ';
         const consequentChunk = this.genFragment(node.consequent, indent + 1);
-        let code = `${node.condition}\n${bi}? ${consequentChunk.code}`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(consequentChunk.mappings, 1),
+        const condition = verbatim({ text: node.condition, loc: node.conditionLoc });
+        const parts = [
+            node.negated ? concat('!(', condition, ')') : condition,
+            `\n${bi}? `, consequentChunk,
         ];
         for (const alt of node.alternates) {
             const altBodyChunk = this.genFragment(alt.body, indent + 1);
-            const prevLines = lineCount(code);
-            code += `\n${bi}: ${alt.condition}\n${bi}? ${altBodyChunk.code}`;
-            mappings.push(...offsetMappings(altBodyChunk.mappings, prevLines + 2));
+            parts.push(`\n${bi}: `, verbatim({ text: alt.condition, loc: alt.conditionLoc }), `\n${bi}? `, altBodyChunk);
         }
         if (node.fallback !== null) {
-            const fallbackChunk = this.genFragment(node.fallback, indent + 1);
-            const prevLines = lineCount(code);
-            code += `\n${bi}: ${fallbackChunk.code}`;
-            mappings.push(...offsetMappings(fallbackChunk.mappings, prevLines + 1));
+            parts.push(`\n${bi}: `, this.genFragment(node.fallback, indent + 1));
         }
         else {
-            code += `\n${bi}: null`;
+            parts.push(`\n${bi}: null`);
         }
-        return { code, mappings };
+        return concat(mark(node.loc), ...parts);
     }
     // --- Iteration generation ---
     genIteration(node, indent) {
-        const { variable, iterable } = this.parseForParams(node.params, node.loc);
+        const { variable, iterable } = this.parseForParams({ text: node.params, loc: node.paramsLoc }, node.loc);
         const bodyChunk = this.genFragment(node.body, indent + 1);
         // Wrap destructured variables in parens for arrow function
-        const param = variable.startsWith('{') || variable.startsWith('[')
-            ? `(${variable})`
-            : variable;
+        const param = variable.text.startsWith('{') || variable.text.startsWith('[')
+            ? concat('(', verbatim(variable), ')')
+            : verbatim(variable);
         const bi = this.formatted ? this.ind(indent + 1) : '    ';
         const pi = this.formatted ? this.ind(indent) : '';
-        const head = reindent(`${iterable}.map(${param} =>`, this.formatted ? this.ind(indent) : '');
-        const code = `${head}\n${bi}${bodyChunk.code}\n${pi})`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(head)),
-        ];
-        return { code, mappings };
+        // `each()` rather than `.map()`, so any iterable works (Set, Map,
+        // generators, `xs.entries()`) and an `else` can render when it's empty.
+        const head = reindentChunk(concat('each(', verbatim(iterable), ', ', param, ' =>'), this.formatted ? this.ind(indent) : '');
+        const parts = [mark(node.loc), head, `\n${bi}`, bodyChunk];
+        if (node.fallback) {
+            parts.push(`\n${pi}, () =>\n${bi}`, this.genFragment(node.fallback, indent + 1));
+        }
+        parts.push(`\n${pi})`);
+        return concat(...parts);
     }
     parseForParams(params, loc) {
         // A multi-line header may put `of` at the start or end of a line.
-        const of = /\s+of\s+/.exec(params);
+        const of = /\s+of\s+/.exec(params.text);
         if (of === null) {
-            throw new CodegenError(`Invalid for params: only "for...of" is supported, got "${params}"`, loc.line, loc.col);
+            throw new CodegenError(`Invalid for params: only "for...of" is supported, got "${params.text}"`, loc.line, loc.col);
         }
-        const binding = params.slice(0, of.index).trim();
-        const iterable = params.slice(of.index + of[0].length).trim();
-        const variable = binding.replace(/^(const|let)\s+/, '');
+        const binding = sliceCaptured(params, 0, of.index);
+        const iterable = sliceCaptured(params, of.index + of[0].length);
+        const keyword = /^(const|let)\s+/.exec(binding.text);
+        const variable = keyword ? sliceCaptured(binding, keyword[0].length) : binding;
         return { variable, iterable };
     }
     // --- Fragment helper ---
@@ -220,14 +267,12 @@ class CodeGenerator {
             .filter((e) => e !== null);
         if (!this.formatted) {
             const inner = this.joinWithCommentChunks(chunks, '    ');
-            const code = `h(Fragment, {},\n${inner.code}\n)`;
-            return { code, mappings: offsetMappings(inner.mappings, 1) };
+            return concat('h(Fragment, {},\n', inner, '\n)');
         }
         const ci = this.ind(indent + 1);
         const pi = this.ind(indent);
         const inner = this.joinWithCommentChunks(chunks, ci);
-        const code = `h(Fragment, {},\n${inner.code}\n${pi})`;
-        return { code, mappings: offsetMappings(inner.mappings, 1) };
+        return concat('h(Fragment, {},\n', inner, `\n${pi})`);
     }
     // --- Element generation ---
     genElement(node, indent) {
@@ -236,31 +281,23 @@ class CodeGenerator {
             .map(c => this.genNode(c, indent + 1))
             .filter((e) => e !== null);
         if (children.length === 0) {
-            return chunk(`h("${node.tag}", ${attrs})`, node.loc);
+            return within(node.loc, `h("${node.tag}", `, attrs, ')');
         }
         const hasComments = children.some(c => c.code.startsWith('//'));
-        if (!this.formatted && !hasComments) {
-            const childrenStr = children.map(c => c.code).join(', ');
-            return chunk(`h("${node.tag}", ${attrs}, ${childrenStr})`, node.loc);
-        }
+        const inline = () => within(node.loc, `h("${node.tag}", `, attrs, ...children.flatMap(c => [', ', c]), ')');
+        if (!this.formatted && !hasComments)
+            return inline();
         // Keep inline when all children are leaf nodes (text, expressions) and no comments
         const leafTypes = new Set(['Text', 'BufferedCode', 'Pipe']);
         const allLeaf = !hasComments && node.children
             .filter(c => c.type !== 'Comment' && c.type !== 'PassthroughComment')
             .every(c => leafTypes.has(c.type));
-        if (allLeaf) {
-            const childrenStr = children.map(c => c.code).join(', ');
-            return chunk(`h("${node.tag}", ${attrs}, ${childrenStr})`, node.loc);
-        }
+        if (allLeaf)
+            return inline();
         const ci = this.ind(indent + 1);
         const pi = this.ind(indent);
         const inner = this.joinWithCommentChunks(children, ci);
-        const code = `h("${node.tag}", ${attrs},\n${inner.code}\n${pi})`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(inner.mappings, 1),
-        ];
-        return { code, mappings };
+        return within(node.loc, `h("${node.tag}", `, attrs, ',\n', inner, `\n${pi})`);
     }
     genAttrs(node) {
         const parts = [];
@@ -269,45 +306,59 @@ class CodeGenerator {
         // Classes: merge shorthand + explicit into one
         if (node.classes.length > 0 && explicitClass && explicitClass.value !== null) {
             const prefix = node.classes.join(' ');
-            parts.push(`class: ${this.mergeClassValue(prefix, explicitClass.value)}`);
+            parts.push(concat(this.attrName(explicitClass), ': ', this.mergeClassValue(prefix, explicitClass)));
         }
         else if (node.classes.length > 0) {
-            parts.push(`class: "${node.classes.join(' ')}"`);
+            parts.push(chunk(`class: "${node.classes.join(' ')}"`));
         }
         // ID from shorthand
         if (node.id !== null) {
-            parts.push(`id: "${node.id}"`);
+            parts.push(chunk(`id: "${node.id}"`));
         }
         // Explicit attributes (skip class if already merged)
         for (const attr of node.attrs) {
             if (attr === explicitClass && node.classes.length > 0)
                 continue;
-            if (attr.spread) {
-                parts.push(`...${attr.name}`);
-            }
-            else {
-                // Every non-spread attribute carries a value (the parser rejects
-                // valueless attributes); booleans arrive as the verbatim
-                // expression `true` / `false`.
-                const key = this.attrKey(attr.name);
-                parts.push(`${key}: ${attr.value}`);
-            }
+            parts.push(this.genAttr(attr));
         }
-        if (parts.length === 0)
-            return '{}';
-        return `{ ${parts.join(', ')} }`;
+        return this.attrObject(parts);
     }
-    mergeClassValue(prefix, value) {
+    // `{ a, b }` from attribute entries, or `{}` for none.
+    attrObject(parts) {
+        if (parts.length === 0)
+            return chunk('{}');
+        return concat('{ ', ...parts.flatMap((p, i) => (i === 0 ? [p] : [', ', p])), ' }');
+    }
+    genAttr(attr) {
+        if (attr.spread)
+            return chunk(`...${attr.name}`);
+        // Every non-spread attribute carries a value (the parser rejects
+        // valueless attributes); booleans arrive as the verbatim
+        // expression `true` / `false`.
+        return concat(this.attrName(attr), ': ', verbatim({ text: attr.value, loc: attr.valueLoc }));
+    }
+    // The object key for an attribute, mapped to its name: written `name=value`
+    // with nothing between, the name ends just before the value.
+    attrName(attr) {
+        const key = this.attrKey(attr.name);
+        const valueStart = attr.valueLoc?.[0];
+        if (!valueStart)
+            return chunk(key);
+        return chunk(key, { line: valueStart.line, col: valueStart.col - attr.name.length - 1 });
+    }
+    mergeClassValue(prefix, attr) {
+        const value = attr.value;
+        const captured = { text: value, loc: attr.valueLoc };
         // String and template literals are always strings, so merge them now.
         // Anything else may be undefined/null/false at render time, which must
         // add nothing rather than stringify into the class list.
         if (value === '""' || value === "''" || value === '``') {
-            return `"${prefix}"`;
+            return chunk(`"${prefix}"`);
         }
         if (value.startsWith('`') || value.startsWith('"') || value.startsWith("'")) {
-            return `${value[0]}${prefix} ${value.slice(1)}`;
+            return concat(verbatim(sliceCaptured(captured, 0, 1)), `${prefix} `, verbatim(sliceCaptured(captured, 1)));
         }
-        return `mergeClass("${prefix}", ${value})`;
+        return concat(`mergeClass("${prefix}", `, verbatim(captured), ')');
     }
     attrKey(name) {
         if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
@@ -316,29 +367,31 @@ class CodeGenerator {
     }
     // --- Text generation ---
     genText(node) {
-        return chunk(this.genSegments(node.segments), node.loc);
+        return concat(mark(node.loc), this.genSegments(node.segments));
     }
     genPipe(node) {
         if (node.segments.length === 0) {
             return chunk('" "', node.loc);
         }
-        return chunk(this.genSegments(node.segments), node.loc);
+        return concat(mark(node.loc), this.genSegments(node.segments));
     }
     genSegments(segments) {
         if (segments.length === 1 && segments[0].type === 'text') {
-            return `"${this.escapeString(segments[0].value)}"`;
+            return chunk(`"${this.escapeString(segments[0].value)}"`);
         }
-        let result = '`';
+        // Tagged, so each value renders as an element child would: `raw()`
+        // and mixin output stay unescaped and null/undefined render nothing.
+        const parts = ['interpolate`'];
         for (const seg of segments) {
             if (seg.type === 'text') {
-                result += this.escapeTemplateLiteral(seg.value);
+                parts.push(this.escapeTemplateLiteral(seg.value));
             }
             else {
-                result += `\${${seg.expression}}`;
+                parts.push('${', verbatim({ text: seg.expression, loc: seg.loc ? [seg.loc] : undefined }), '}');
             }
         }
-        result += '`';
-        return result;
+        parts.push('`');
+        return concat(...parts);
     }
     escapeString(s) {
         return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
@@ -350,34 +403,38 @@ class CodeGenerator {
     genImport(node) {
         return chunk(node.statement, node.loc);
     }
+    // A template with slots (a layout, or a mid-layer template that both fills
+    // its parent's slots and exposes its own) is preceded by the interface its
+    // `blocks` parameter is typed with.
     genTemplate(node, indent) {
+        const slots = templateSlots(node);
+        const fn = this.genTemplateFunction(node, slots.length > 0, indent);
+        if (slots.length === 0)
+            return fn;
+        const iface = blocksInterface(node, slots);
+        return {
+            code: `${iface.code}\n\n${fn.code}`,
+            mappings: [...iface.mappings, ...offsetMappings(fn.mappings, lineCount(iface.code) + 2)],
+        };
+    }
+    genTemplateFunction(node, hasBlocks, indent) {
         const i1 = this.ind(indent + 1);
+        const declared = verbatim({ text: node.params, loc: node.paramsLoc });
+        const params = hasBlocks
+            ? appendArg(declared, `blocks: ${capitalize(node.name)}Blocks = {}`)
+            : declared;
+        const signature = concat(mark(node.loc), `export function ${node.name}(`, params, ') {\n');
         // Check if body contains an ExtendsNode (page template)
         const extendsNode = node.body.find((c) => c.type === 'Extends');
         if (extendsNode) {
             const extendsChunk = this.genExtends(extendsNode, indent + 1);
-            // A mid-layer template both fills its parent's slots and exposes its
-            // own (nested `block` nodes), so it needs a `blocks` parameter too.
-            const params = templateHasBlocks(node)
-                ? appendArg(node.params, `blocks: ${capitalize(node.name)}Blocks = {}`)
-                : node.params;
-            const code = `export function ${node.name}(${params}) {\n${i1}return ${extendsChunk.code}\n}`;
-            const mappings = [
-                mapping(node.loc),
-                ...offsetMappings(extendsChunk.mappings, 1 + lineCount(params)),
-            ];
-            return { code, mappings };
-        }
-        // Check if body tree contains BlockNodes (layout template)
-        const hasBlocks = templateHasBlocks(node);
-        const params = hasBlocks
-            ? appendArg(node.params, `blocks: ${capitalize(node.name)}Blocks = {}`)
-            : node.params;
+            return concat(signature, `${i1}return `, extendsChunk, '\n}');
+        }
         const bodyChunks = node.body
-            .map(child => this.genNode(child, indent + 2))
+            .map(child => this.genNode(child, indent + 1))
             .filter((e) => e !== null);
         if (bodyChunks.length === 0) {
-            return chunk(`export function ${node.name}(${params}) {\n${i1}return ''\n}`, node.loc);
+            return concat(signature, `${i1}return ''\n}`);
         }
         // Separate comments from code chunks
         const commentChunks = bodyChunks.filter(c => c.code.startsWith('//'));
@@ -392,99 +449,87 @@ class CodeGenerator {
         else {
             bodyChunk = this.genFragment(node.body, indent + 1);
         }
-        // Prepend comments before the return statement
-        const commentPrefix = commentChunks.length > 0
-            ? commentChunks.map(c => `${i1}${c.code}`).join('\n') + '\n'
-            : '';
-        const commentLines = commentChunks.length;
-        const code = `export function ${node.name}(${params}) {\n${commentPrefix}${i1}return ${bodyChunk.code}\n}`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(params) + commentLines), // body starts after fn sig + comments
-        ];
-        return { code, mappings };
+        // Comments go before the return statement
+        const comments = commentChunks.flatMap(c => [i1, c, '\n']);
+        return concat(signature, ...comments, `${i1}return `, bodyChunk, '\n}');
     }
     // --- Mixin generation ---
     genMixinDefinition(node, indent) {
         const i1 = this.ind(indent + 1);
-        const params = appendArg(node.params, 'attrs: Attrs = {}');
-        const bodyChunks = node.body
-            .map(child => this.genNode(child, indent + 1))
-            .filter((e) => e !== null);
-        const bodyChunk = this.genFragment(bodyChunks.length > 0 ? node.body : [], indent + 1);
-        const code = `export function ${node.name}(${params}) {\n${i1}return ${bodyChunk.code}\n}`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(params)),
-        ];
-        return { code, mappings };
+        this.inMixin = true;
+        let bodyChunk;
+        try {
+            const bodyChunks = node.body
+                .map(child => this.genNode(child, indent + 1))
+                .filter((e) => e !== null);
+            bodyChunk = this.genFragment(bodyChunks.length > 0 ? node.body : [], indent + 1);
+        }
+        finally {
+            this.inMixin = false;
+        }
+        // `attrs` is always accepted so every call site can pass extra
+        // attributes, but a body that never mentions it would trip
+        // `noUnusedParameters`; the `_` prefix silences that. We can't parse the
+        // TS in the body, so this is a textual check: a stray match (e.g. the
+        // word in a string) just keeps the plain name, which is harmless.
+        const attrsParam = /\battrs\b/.test(bodyChunk.code) ? 'attrs' : '_attrs';
+        let params = appendArg(verbatim({ text: node.params, loc: node.paramsLoc }), `${attrsParam}: Attrs = {}`);
+        // A bare `block` renders whatever is indented under the call site,
+        // passed as a callback after `attrs` (which callers then always pass).
+        if (mixinHasBlock(node))
+            params = appendArg(params, 'block?: () => unknown');
+        return concat(mark(node.loc), `export function ${node.name}(`, params, `) {\n${i1}return `, bodyChunk, '\n}');
     }
     genMixinCall(node, indent = 0) {
-        const args = node.attrs.length > 0
-            ? appendArg(node.args, this.genCallAttrs(node.attrs))
-            : node.args;
+        const hasBlock = countEffective(node.block) > 0;
+        const given = verbatim({ text: node.args, loc: node.argsLoc });
+        // Call-site content follows `attrs`, so `{}` holds its place when none are given.
+        const args = node.attrs.length > 0 || hasBlock
+            ? appendArg(given, this.genCallAttrs(node.attrs))
+            : given;
         const prefix = this.formatted ? this.ind(indent) : '';
-        return chunk(reindent(`${node.name}(${args})`, prefix), node.loc);
+        if (!hasBlock)
+            return reindentChunk(within(node.loc, `${node.name}(`, args, ')'), prefix);
+        const head = concat(`${node.name}(`, reindentChunk(args, prefix));
+        const blockChunk = this.genFragment(node.block, indent);
+        return within(node.loc, appendArg(head, concat('() => ', blockChunk), false), ')');
     }
     genCallAttrs(attrs) {
-        const parts = [];
-        for (const attr of attrs) {
-            if (attr.spread) {
-                parts.push(`...${attr.name}`);
-            }
-            else {
-                // Every non-spread attribute carries a value (the parser rejects
-                // valueless attributes); booleans arrive as the verbatim
-                // expression `true` / `false`.
-                const key = this.attrKey(attr.name);
-                parts.push(`${key}: ${attr.value}`);
-            }
-        }
-        return `{ ${parts.join(', ')} }`;
+        return this.attrObject(attrs.map(attr => this.genAttr(attr)));
     }
     // --- Block and extends generation ---
     genBlock(node, indent) {
+        if (node.name === '' && !this.inMixin) {
+            throw new CodegenError('A bare "block" is only allowed inside a mixin; name the block', node.loc.line, node.loc.col);
+        }
+        if (node.name !== '' && this.inMixin) {
+            throw new CodegenError(`Named block "${node.name}" is not allowed inside a mixin; use a bare "block" for call-site content`, node.loc.line, node.loc.col);
+        }
+        // A layout slot lives on the `blocks` parameter; a mixin's call-site
+        // content is its `block` parameter.
+        const ref = node.name === '' ? 'block' : `blocks.${node.name}`;
         if (node.children.length === 0) {
-            return chunk(`blocks.${node.name}?.()`, node.loc);
+            return chunk(`${ref}?.()`, node.loc);
         }
         const bi = this.formatted ? this.ind(indent + 1) : '    ';
         const defaultContentChunk = this.genFragment(node.children, indent + 1);
-        const code = `blocks.${node.name}\n${bi}? blocks.${node.name}()\n${bi}: ${defaultContentChunk.code}`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(defaultContentChunk.mappings, 2),
-        ];
-        return { code, mappings };
+        return concat(mark(node.loc), `${ref}\n${bi}? ${ref}()\n${bi}: `, defaultContentChunk);
     }
     genExtends(node, indent) {
         const bi = this.formatted ? this.ind(indent + 1) : '    ';
         const pi = this.formatted ? this.ind(indent) : '';
-        const blockChunks = [];
-        for (const block of node.blocks) {
-            const bodyChunk = this.genFragment(block.children, indent + 1);
-            const blockCode = `${bi}${block.name}: () => ${bodyChunk.code}`;
-            const blockMappings = [
-                mapping(block.loc),
-                ...offsetMappings(bodyChunk.mappings, 0),
-            ];
-            blockChunks.push({ code: blockCode, mappings: blockMappings });
-        }
+        const blockChunks = node.blocks.map(block => concat(mark(block.loc), `${bi}${block.name}: () => `, this.genFragment(block.children, indent + 1)));
         const joinedBlocks = joinChunks(blockChunks, ',\n');
-        const args = reindent(node.args, pi);
-        const head = `${node.target}(${appendArg(args, '{', false)}`;
-        const code = `${head}\n${joinedBlocks.code}\n${pi}})`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(joinedBlocks.mappings, 1 + lineCount(head)),
-        ];
-        return { code, mappings };
+        const args = reindentChunk(verbatim({ text: node.args, loc: node.argsLoc }), pi);
+        const head = concat(`${node.target}(`, appendArg(args, '{', false));
+        return concat(mark(node.loc), head, '\n', joinedBlocks, `\n${pi}})`);
     }
     genInclude(node, names) {
         return chunk(`import { ${names.join(', ')} } from '${node.path}.js'`, node.loc);
     }
     // --- Simple generators ---
     genBufferedCode(node) {
-        return chunk(node.expression, node.loc);
+        return concat(mark(node.loc), verbatim({ text: node.expression, loc: node.expressionLoc }));
     }
     genDoctype(node) {
         return chunk('doctype()', node.loc);
@@ -545,12 +590,21 @@ function scanUsedHelpers(node) {
                 }
                 break;
             case 'Iteration':
+                helpers.add('each');
                 if (countEffective(n.body) > 1) {
                     helpers.add('h');
                     helpers.add('Fragment');
                 }
                 for (const c of n.body)
                     walk(c);
+                if (n.fallback) {
+                    if (countEffective(n.fallback) > 1) {
+                        helpers.add('h');
+                        helpers.add('Fragment');
+                    }
+                    for (const c of n.fallback)
+                        walk(c);
+                }
                 break;
             case 'Template': {
                 // Template body wraps in a Fragment when it has more than one
@@ -573,6 +627,10 @@ function scanUsedHelpers(node) {
                     walk(c);
                 break;
             case 'MixinCall':
+                if (countEffective(n.block) > 1) {
+                    helpers.add('h');
+                    helpers.add('Fragment');
+                }
                 for (const c of n.block)
                     walk(c);
                 break;
@@ -594,6 +652,11 @@ function scanUsedHelpers(node) {
                         walk(c);
                 }
                 break;
+            case 'Text':
+            case 'Pipe':
+                if (n.segments.some(s => s.type === 'interpolation'))
+                    helpers.add('interpolate');
+                break;
             case 'Document':
                 for (const c of n.children)
                     walk(c);
@@ -633,6 +696,10 @@ function collectMixinCalls(doc) {
                     walkAll(n.fallback);
                 break;
             case 'Iteration':
+                walkAll(n.body);
+                if (n.fallback)
+                    walkAll(n.fallback);
+                break;
             case 'Template':
             case 'MixinDefinition':
                 walkAll(n.body);
@@ -735,7 +802,7 @@ export function generate(doc, options = {}) {
     const helpers = scanUsedHelpers(doc);
     // Emit runtime import (canonical order)
     if (helpers.size > 0) {
-        const order = ['h', 'doctype', 'Fragment', 'raw', 'mergeClass'];
+        const order = ['h', 'doctype', 'Fragment', 'raw', 'mergeClass', 'each', 'interpolate'];
         const used = order.filter(h => helpers.has(h));
         parts.push(chunk(`import { ${used.join(', ')} } from "@chilts/weave"`));
     }
@@ -744,25 +811,10 @@ export function generate(doc, options = {}) {
     if (hasMixinDefs) {
         parts.push(chunk('import type { Attrs } from "@chilts/weave"'));
     }
-    // Pre-scan: find layout templates that need blocks type augmentation
-    let blocksTypeName = null;
-    for (const child of doc.children) {
-        if (child.type === 'Template' && templateHasBlocks(child)) {
-            blocksTypeName = capitalize(child.name) + 'Blocks';
-        }
-    }
-    // Emit user imports (augmented with blocks type if needed)
+    // Emit user imports
     for (const child of doc.children) {
-        if (child.type === 'Import') {
-            let statement = child.statement;
-            if (blocksTypeName && statement.includes('import type')) {
-                const idx = statement.indexOf(' }');
-                if (idx !== -1) {
-                    statement = statement.slice(0, idx) + `, ${blocksTypeName}` + statement.slice(idx);
-                }
-            }
-            parts.push(chunk(statement, child.loc));
-        }
+        if (child.type === 'Import')
+            parts.push(gen.genImport(child));
     }
     // Emit include imports: only the mixins this file calls, so an include
     // that provides nothing used emits nothing.