@chilts/weave 0.6.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;
@@ -14,43 +14,119 @@ export class CodegenError extends Error {
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+// Appends a compiler-supplied argument (`attrs`, `blocks`, ...) to a
+// captured argument or parameter list. A multi-line list may already end in
+// a trailing comma, and when its ')' sat on a line of its own the extra goes
+// 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.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 indent = /^ */.exec(lastLine)[0];
+        return concat(head, body.endsWith(',') ? '' : ',', `\n${indent}`, extra, `,${tail}`);
+    }
+    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
+// spans lines, so every newline is safe to indent after.
+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;
     }
@@ -63,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) {
@@ -110,9 +182,10 @@ class CodeGenerator {
             case 'MixinDefinition':
                 return this.genMixinDefinition(node, indent);
             case 'MixinCall':
-                return this.genMixinCall(node);
+                return this.genMixinCall(node, indent);
             case 'Include':
-                return this.genInclude(node);
+                // Hoisted: generate() emits the import once it knows the names.
+                return null;
             case 'Block':
                 return this.genBlock(node, indent);
             case 'Extends':
@@ -125,53 +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 code = `${iterable}.map(${param} =>\n${bi}${bodyChunk.code}\n${pi})`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1),
-        ];
-        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) {
-        const ofIndex = params.indexOf(' of ');
-        if (ofIndex === -1) {
-            throw new CodegenError(`Invalid for params: only "for...of" is supported, got "${params}"`, loc.line, loc.col);
-        }
-        const binding = params.slice(0, ofIndex).trim();
-        const iterable = params.slice(ofIndex + 4).trim();
-        const variable = binding.replace(/^(const|let)\s+/, '');
+        // A multi-line header may put `of` at the start or end of a line.
+        const of = /\s+of\s+/.exec(params.text);
+        if (of === null) {
+            throw new CodegenError(`Invalid for params: only "for...of" is supported, got "${params.text}"`, loc.line, loc.col);
+        }
+        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 ---
@@ -194,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) {
@@ -210,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 = [];
@@ -243,42 +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) {
-        if (value.startsWith('`')) {
-            return `\`${prefix} ${value.slice(1)}`;
-        }
-        if (value.startsWith('"')) {
-            return `"${prefix} ${value.slice(1)}`;
-        }
-        return `\`${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 chunk(`"${prefix}"`);
+        }
+        if (value.startsWith('`') || value.startsWith('"') || value.startsWith("'")) {
+            return concat(verbatim(sliceCaptured(captured, 0, 1)), `${prefix} `, verbatim(sliceCaptured(captured, 1)));
+        }
+        return concat(`mergeClass("${prefix}", `, verbatim(captured), ')');
     }
     attrKey(name) {
         if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
@@ -287,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');
@@ -321,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)
-                ? `${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),
-            ];
-            return { code, mappings };
-        }
-        // Check if body tree contains BlockNodes (layout template)
-        const hasBlocks = templateHasBlocks(node);
-        const params = hasBlocks
-            ? `${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('//'));
@@ -363,104 +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 + 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 = node.params
-            ? `${node.params}, attrs: Attrs = {}`
-            : '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),
-        ];
-        return { code, mappings };
-    }
-    genMixinCall(node) {
-        const argParts = [];
-        if (node.args) {
-            argParts.push(node.args);
-        }
-        if (node.attrs.length > 0) {
-            argParts.push(this.genCallAttrs(node.attrs));
-        }
-        return chunk(`${node.name}(${argParts.join(', ')})`, node.loc);
+        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 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) : '';
+        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 code = `${node.target}(${node.args}, {\n${joinedBlocks.code}\n${pi}})`;
-        const mappings = [
-            mapping(node.loc),
-            ...offsetMappings(joinedBlocks.mappings, 1),
-        ];
-        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) {
-        const segments = node.path.split('/');
-        const name = segments[segments.length - 1];
-        return chunk(`import { ${name} } from '${node.path}.js'`, node.loc);
+    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);
@@ -470,12 +539,21 @@ class CodeGenerator {
 function countEffective(nodes) {
     return nodes.filter(n => n.type !== 'Comment' && n.type !== 'PassthroughComment').length;
 }
+/** True when shorthand classes merge with a `class=` value that is not a string literal. */
+function needsRuntimeClassMerge(node) {
+    const explicitClass = node.attrs.find(a => a.name === 'class' && !a.spread);
+    if (!explicitClass || explicitClass.value === null)
+        return false;
+    return !/^["'`]/.test(explicitClass.value);
+}
 function scanUsedHelpers(node) {
     const helpers = new Set();
     function walk(n) {
         switch (n.type) {
             case 'Element':
                 helpers.add('h');
+                if (n.classes.length > 0 && needsRuntimeClassMerge(n))
+                    helpers.add('mergeClass');
                 if (n.rawBlock)
                     helpers.add('raw');
                 for (const c of n.children)
@@ -512,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
@@ -540,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;
@@ -561,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);
@@ -570,6 +666,125 @@ function scanUsedHelpers(node) {
     walk(node);
     return helpers;
 }
+// --- Include resolution ---
+/** Names of the mixins a document defines at top level. */
+export function definedMixins(doc) {
+    return doc.children.flatMap(c => (c.type === 'MixinDefinition' ? [c.name] : []));
+}
+/** Every mixin call in the document, first call of each name, in source order. */
+function collectMixinCalls(doc) {
+    const calls = new Map();
+    function walkAll(nodes) {
+        for (const n of nodes)
+            walk(n);
+    }
+    function walk(n) {
+        switch (n.type) {
+            case 'MixinCall':
+                if (!calls.has(n.name))
+                    calls.set(n.name, n);
+                walkAll(n.block);
+                break;
+            case 'Element':
+                walkAll(n.children);
+                break;
+            case 'Conditional':
+                walkAll(n.consequent);
+                for (const alt of n.alternates)
+                    walkAll(alt.body);
+                if (n.fallback)
+                    walkAll(n.fallback);
+                break;
+            case 'Iteration':
+                walkAll(n.body);
+                if (n.fallback)
+                    walkAll(n.fallback);
+                break;
+            case 'Template':
+            case 'MixinDefinition':
+                walkAll(n.body);
+                break;
+            case 'Block':
+                walkAll(n.children);
+                break;
+            case 'Extends':
+                for (const block of n.blocks)
+                    walkAll(block.children);
+                break;
+        }
+    }
+    walkAll(doc.children);
+    return calls;
+}
+/**
+ * Value bindings a pass-through `import` statement introduces. A loose read,
+ * not a TS parse: it only needs to spot a mixin imported by hand.
+ */
+function importedBindings(statement) {
+    if (/^import\s+type\b/.test(statement))
+        return [];
+    const clause = /^import\s+([\s\S]*?)\s+from\b/.exec(statement)?.[1];
+    if (!clause)
+        return [];
+    const names = [];
+    const defaultName = /^([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
+    if (defaultName)
+        names.push(defaultName);
+    const namespace = /\*\s*as\s+([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
+    if (namespace)
+        names.push(namespace);
+    const named = /\{([^}]*)\}/.exec(clause)?.[1];
+    if (named) {
+        for (const spec of named.split(',')) {
+            const s = spec.trim();
+            if (s === '' || /^type\s/.test(s))
+                continue;
+            names.push(s.split(/\s+as\s+/).pop().trim());
+        }
+    }
+    return names;
+}
+/** Which called mixins each include must import, in first-call order. */
+function resolveIncludes(doc, resolveInclude) {
+    const includes = doc.children.filter((c) => c.type === 'Include');
+    const picks = new Map(includes.map(inc => [inc, []]));
+    if (includes.length === 0)
+        return picks;
+    const provided = new Set(definedMixins(doc));
+    for (const child of doc.children) {
+        if (child.type === 'Import') {
+            for (const name of importedBindings(child.statement))
+                provided.add(name);
+        }
+    }
+    const needed = [...collectMixinCalls(doc).values()].filter(call => !provided.has(call.name));
+    if (!resolveInclude) {
+        if (includes.length > 1 && needed.length > 0) {
+            const inc = includes[1];
+            throw new CodegenError(`Cannot tell which include defines mixin "${needed[0].name}" without an include resolver`, inc.loc.line, inc.loc.col);
+        }
+        picks.set(includes[0], needed.map(call => call.name));
+        return picks;
+    }
+    const available = new Map();
+    for (const inc of includes) {
+        try {
+            available.set(inc, new Set(resolveInclude(inc.path)));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new CodegenError(`Cannot include ${inc.path}: ${msg}`, inc.loc.line, inc.loc.col);
+        }
+    }
+    for (const call of needed) {
+        const inc = includes.find(i => available.get(i).has(call.name));
+        if (!inc) {
+            throw new CodegenError(`Mixin "${call.name}" is not defined in this file or any include`, call.loc.line, call.loc.col);
+        }
+        picks.get(inc).push(call.name);
+    }
+    return picks;
+}
 // --- Public API ---
 /** Generate a TypeScript expression from a single AST node. */
 export function generateExpr(node) {
@@ -580,14 +795,14 @@ export function generateExpr(node) {
     return result.code;
 }
 /** Generate TypeScript source from a DocumentNode. */
-export function generate(doc) {
+export function generate(doc, options = {}) {
     const gen = new CodeGenerator(true);
     const parts = [];
     // Scan for used runtime helpers
     const helpers = scanUsedHelpers(doc);
     // Emit runtime import (canonical order)
     if (helpers.size > 0) {
-        const order = ['h', 'doctype', 'Fragment', 'raw'];
+        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"`));
     }
@@ -596,33 +811,16 @@ export function generate(doc) {
     if (hasMixinDefs) {
         parts.push(chunk('import type { Attrs } from "@chilts/weave"'));
     }
-    // Pre-scan: find layout templates that need blocks type augmentation
-    let blocksTypeName = null;
+    // Emit user imports
     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)
-    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
-    for (const child of doc.children) {
-        if (child.type === 'Include') {
-            const result = gen.genNode(child, 0);
-            if (result !== null)
-                parts.push(result);
-        }
+    // Emit include imports: only the mixins this file calls, so an include
+    // that provides nothing used emits nothing.
+    for (const [include, names] of resolveIncludes(doc, options.resolveInclude)) {
+        if (names.length > 0)
+            parts.push(gen.genInclude(include, names));
     }
     // Emit extends imports (auto-import layout function)
     for (const child of doc.children) {
@@ -647,16 +845,16 @@ export function generate(doc) {
     return { code: final.code + '\n', mappings: final.mappings };
 }
 /** Full pipeline: source string → TypeScript source. */
-export function compile(source) {
+export function compile(source, options = {}) {
     const tokens = lex(source);
     const doc = parse(tokens);
-    return generate(doc).code;
+    return generate(doc, options).code;
 }
 /** Full pipeline with source map generation. */
 export function compileWithSourceMap(source, opts) {
     const tokens = lex(source);
     const doc = parse(tokens);
-    const result = generate(doc);
+    const result = generate(doc, opts);
     const sourceMap = buildSourceMap(result.mappings, opts.file, opts.sourceFile);
     return { code: result.code, sourceMap };
 }