@vesk/compiler 0.0.1

package/dist/ir-generator.js

@@ -0,0 +1,1062 @@
+import { IRRoot, ComponentIR, StaticNode, TextNode, DynamicBinding, OpaqueDynamicRegion, MapRegion, WhileLoop, SwitchBlock, TryCatch, RuntimeStatement, ForLoop, TrackDecl, ComponentRef, ComponentCall, ServerBlock, ClientBlock, HeadBlock, Expression, SlotNode, } from '@vesk/compiler/src/ir';
+import { VeskError } from '@vesk/compiler/src/errors';
+import { createBaseParser } from '@vesk/compiler/src/parser';
+import { skipWhitespace, findBalancedEnd, splitTopLevel, startsWithIdentifier, stripDeclKeyword, isWhitespaceChar, collapseNewlineWhitespace } from '@vesk/compiler/src/scan';
+import { stripCodeTypes } from '@vesk/compiler/src/strip-ts';
+import { stripTypeImport } from '@vesk/compiler/src/vsk-imports';
+import { collectCalledIdentifiers, extractImportNames, importModuleTarget } from '@vesk/compiler/src/tokens';
+let __vskAnnotations = [];
+function parseExprNode(text) {
+    try {
+        const ParserClass = createBaseParser();
+        const ast = ParserClass.parse(`(${text})`, { ecmaVersion: 'latest', sourceType: 'module' });
+        return ast.body[0]?.expression ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function getForClauseAnnotation(forStart) {
+    let keyRange;
+    let indexName;
+    let clauseStart = -1;
+    let clauseEnd = -1;
+    for (const ann of __vskAnnotations) {
+        if (ann.kind !== 'for-clause' || ann.forStart !== forStart)
+            continue;
+        if (ann.keyRange)
+            keyRange = ann.keyRange;
+        if (ann.indexName)
+            indexName = ann.indexName;
+        clauseStart = ann.clauseStart;
+        clauseEnd = ann.clauseEnd;
+    }
+    if (clauseStart === -1)
+        return null;
+    return { kind: 'for-clause', forStart, clauseStart, clauseEnd, ...(keyRange ? { keyRange } : {}), ...(indexName !== undefined ? { indexName } : {}) };
+}
+function getSource(source, node) {
+    return source.slice(node.start, node.end);
+}
+function collectComponentCalls(nodes, out) {
+    for (const n of nodes) {
+        if (n instanceof ComponentCall) {
+            out.set(n.componentName, n.start);
+            collectComponentCalls(n.children, out);
+        }
+        else if (n instanceof StaticNode || n instanceof ServerBlock || n instanceof ClientBlock || n instanceof HeadBlock) {
+            collectComponentCalls(n.children, out);
+        }
+        else if (n instanceof MapRegion) {
+            collectComponentCalls(n.bodyTemplate, out);
+            collectComponentCalls(n.alternateNodes, out);
+        }
+        else if (n instanceof OpaqueDynamicRegion) {
+            collectComponentCalls(n.consequentNodes, out);
+            collectComponentCalls(n.alternateNodes, out);
+        }
+        else if (n instanceof WhileLoop || n instanceof ForLoop) {
+            collectComponentCalls(n.bodyTemplate, out);
+        }
+        else if (n instanceof TryCatch) {
+            collectComponentCalls(n.bodyTemplate, out);
+            collectComponentCalls(n.catchBody, out);
+        }
+        else if (n instanceof SwitchBlock) {
+            for (const c of n.cases)
+                collectComponentCalls(c.body, out);
+        }
+    }
+}
+function offsetToLineCol(source, offset) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < offset && i < source.length; i++) {
+        if (source.charCodeAt(i) === 10) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+}
+function componentUsesFetch(nodes) {
+    for (const node of nodes) {
+        if (node instanceof ServerBlock || node instanceof ClientBlock) {
+            if (componentUsesFetch(node.children))
+                return true;
+        }
+        else if (node instanceof RuntimeStatement) {
+            if (node.raw.includes('useFetch('))
+                return true;
+        }
+        else if (node instanceof DynamicBinding) {
+            if (node.expression.raw.includes('useFetch('))
+                return true;
+        }
+        else if (node instanceof MapRegion) {
+            if (componentUsesFetch(node.bodyTemplate))
+                return true;
+            if (componentUsesFetch(node.alternateNodes))
+                return true;
+        }
+        else if (node instanceof OpaqueDynamicRegion) {
+            if (componentUsesFetch(node.consequentNodes) || componentUsesFetch(node.alternateNodes))
+                return true;
+        }
+        else if (node instanceof WhileLoop) {
+            if (componentUsesFetch(node.bodyTemplate))
+                return true;
+        }
+        else if (node instanceof ForLoop) {
+            if (componentUsesFetch(node.bodyTemplate))
+                return true;
+        }
+        else if (node instanceof TryCatch) {
+            if (componentUsesFetch(node.bodyTemplate) || componentUsesFetch(node.catchBody))
+                return true;
+        }
+        else if (node instanceof SwitchBlock) {
+            for (const c of node.cases) {
+                if (componentUsesFetch(c.body))
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function extractKeyExpr(nodes) {
+    for (const n of nodes) {
+        if (n instanceof StaticNode && n.keyExpr)
+            return n.keyExpr;
+    }
+    return null;
+}
+function isTrackDeclaration(decl) {
+    return (decl.type === 'VariableDeclaration' &&
+        decl.declarations.length === 1 &&
+        decl.declarations[0].id.type === 'ArrayPattern' &&
+        decl.declarations[0].id.lazy === true);
+}
+function getParamNames(params, source) {
+    return params.map((p) => {
+        if (p.type === 'Identifier')
+            return [p.name];
+        if (p.type === 'ObjectPattern')
+            return p.properties.map((prop) => {
+                const name = prop.key.name || prop.key.value;
+                if (prop.value.type === 'AssignmentPattern') {
+                    const defaultSrc = source.slice(prop.value.right.start, prop.value.right.end);
+                    return `${name} = ${defaultSrc}`;
+                }
+                return name;
+            });
+        if (p.type === 'ArrayPattern')
+            return p.elements.map((el) => el?.name ?? '_');
+        return ['_'];
+    }).flat();
+}
+export function getPropsType(params, source) {
+    if (!params || params.length === 0)
+        return null;
+    if (params.length === 1) {
+        const p = params[0];
+        const inner = p.typeAnnotation?.typeAnnotation;
+        if (inner)
+            return source.slice(inner.start, inner.end).trim();
+        const left = p.type === 'AssignmentPattern' ? p.left : null;
+        const innerLeft = left?.typeAnnotation?.typeAnnotation;
+        if (innerLeft)
+            return source.slice(innerLeft.start, innerLeft.end).trim();
+        return null;
+    }
+    const members = [];
+    for (const p of params) {
+        let name = null;
+        let optional = false;
+        let type = 'any';
+        if (p.type === 'Identifier') {
+            name = p.name ?? null;
+            const inner = p.typeAnnotation?.typeAnnotation;
+            if (inner)
+                type = source.slice(inner.start, inner.end).trim();
+        }
+        else if (p.type === 'AssignmentPattern') {
+            optional = true;
+            name = p.left?.name ?? null;
+            const inner = p.left?.typeAnnotation?.typeAnnotation;
+            if (inner)
+                type = source.slice(inner.start, inner.end).trim();
+        }
+        else if (p.type === 'ObjectPattern') {
+            const inner = p.typeAnnotation?.typeAnnotation;
+            if (inner)
+                return source.slice(inner.start, inner.end).trim();
+            continue;
+        }
+        if (name)
+            members.push(`${JSON.stringify(name)}${optional ? '?' : ''}: ${type}`);
+    }
+    if (members.length === 0)
+        return null;
+    return `{ ${members.join('; ')} }`;
+}
+function getJSXTagName(nameNode) {
+    if (nameNode.type === 'JSXIdentifier')
+        return nameNode.name;
+    if (nameNode.type === 'JSXMemberExpression') {
+        return getJSXTagName(nameNode.object) + '.' + getJSXTagName(nameNode.property);
+    }
+    return 'unknown';
+}
+function isHTMLTag(name) {
+    return name.length > 0 && name[0] === name[0].toLowerCase();
+}
+function isMapCall(expr) {
+    return (expr.type === 'CallExpression' &&
+        expr.callee.type === 'MemberExpression' &&
+        expr.callee.property.name === 'map' &&
+        expr.arguments.length === 1 &&
+        expr.arguments[0].type === 'ArrowFunctionExpression');
+}
+function toExpression(source, expr) {
+    return new Expression(getSource(source, expr), [], expr, source);
+}
+function processAttribute(source, attr) {
+    const name = attr.name.type === 'JSXIdentifier' ? attr.name.name : getSource(source, attr.name);
+    if (attr.value === null)
+        return { name, value: '' };
+    if (attr.value.type === 'Literal')
+        return { name, value: String(attr.value.value) };
+    if (attr.value.type === 'JSXExpressionContainer') {
+        const expr = attr.value.expression;
+        if (expr.type === 'Literal')
+            return { name, value: String(expr.value) };
+        return { name, value: toExpression(source, expr) };
+    }
+    return { name, value: '' };
+}
+function extractForHeader(text) {
+    if (!startsWithIdentifier(text, 'for'))
+        return null;
+    let i = skipWhitespace(text, 3);
+    if (text[i] !== '(')
+        return null;
+    const end = findBalancedEnd(text, i);
+    return text.slice(i + 1, end);
+}
+/**
+ * Returns the offset of the `for` keyword in a JSXText value (ignoring
+ * leading whitespace), or -1 when the value does not begin with a `for`.
+ */
+function hasForPrefix(text) {
+    if (!startsWithIdentifier(text, 'for'))
+        return -1;
+    let i = 0;
+    while (i < text.length && isWhitespaceChar(text[i]))
+        i++;
+    return i;
+}
+function processJSXChildren(source, children) {
+    const result = [];
+    let i = 0;
+    while (i < children.length) {
+        const child = children[i];
+        if (child.type === 'JSXText') {
+            const text = collapseNewlineWhitespace(child.value);
+            const trimmed = text.trim();
+            if (!trimmed || trimmed.startsWith('//')) {
+                i++;
+                continue;
+            }
+            const forDecl = extractForHeader(trimmed);
+            const nextChild = children[i + 1];
+            if (forDecl !== null && nextChild !== undefined && (nextChild.type === 'JSXExpressionContainer' ||
+                nextChild.type === 'JSXElement' ||
+                nextChild.type === 'JSXFragment')) {
+                const decl = forDecl;
+                let bodyNodes;
+                if (nextChild.type === 'JSXExpressionContainer') {
+                    const exprNode = nextChild.expression;
+                    if (exprNode.type === 'JSXEmptyExpression') {
+                        result.push(new TextNode(text));
+                        i++;
+                        continue;
+                    }
+                    if (exprNode.type === 'JSXFragment') {
+                        bodyNodes = [];
+                        for (const c of exprNode.children)
+                            bodyNodes.push(...processJSXChildren(source, [c]));
+                    }
+                    else if (exprNode.type === 'JSXElement') {
+                        bodyNodes = processJSXElement(source, exprNode);
+                    }
+                    else {
+                        bodyNodes = exprToIR(source, exprNode);
+                    }
+                }
+                else if (nextChild.type === 'JSXFragment') {
+                    bodyNodes = [];
+                    for (const c of nextChild.children)
+                        bodyNodes.push(...processJSXChildren(source, [c]));
+                }
+                else {
+                    bodyNodes = processJSXElement(source, nextChild);
+                }
+                const ofParts = splitTopLevel(decl, 'of');
+                if (ofParts.length === 2) {
+                    const itemVar = stripDeclKeyword(ofParts[0]).trim();
+                    const exprText = ofParts[1].trim();
+                    const arrExpr = new Expression(exprText, [], parseExprNode(exprText), null);
+                    const rawFor = hasForPrefix(child.value);
+                    const ann = rawFor ? getForClauseAnnotation(child.start + rawFor) : null;
+                    const keyExpr = ann?.keyRange ? new Expression(source.slice(ann.keyRange[0], ann.keyRange[1])) : null;
+                    const indexVar = ann?.indexName ?? null;
+                    let alternate = [];
+                    let consumed = 2;
+                    const emptyText = children[i + 2];
+                    const emptyContainer = children[i + 3];
+                    if (emptyText && emptyText.type === 'JSXText' && ['#empty', 'empty'].includes(emptyText.value.trim()) &&
+                        emptyContainer && emptyContainer.type === 'JSXExpressionContainer' &&
+                        emptyContainer.expression.type !== 'JSXEmptyExpression') {
+                        alternate = exprToIR(source, emptyContainer.expression);
+                        consumed = 4;
+                    }
+                    result.push(new MapRegion(arrExpr, itemVar, bodyNodes, keyExpr, indexVar, alternate));
+                    i += consumed;
+                    continue;
+                }
+                const inParts = splitTopLevel(decl, 'in');
+                if (inParts.length === 2) {
+                    const itemVar = inParts[0].trim();
+                    const arrExpr = new Expression(inParts[1].trim());
+                    result.push(new ForLoop(itemVar, arrExpr, '', bodyNodes, 'for-in'));
+                    i += 2;
+                    continue;
+                }
+            }
+            result.push(new TextNode(text));
+            i++;
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            const expr = child.expression;
+            if (expr.type === 'JSXEmptyExpression') {
+                i++;
+                continue;
+            }
+            if (isMapCall(expr)) {
+                const arrowFn = expr.arguments[0];
+                const itemVar = arrowFn.params[0]?.name ?? 'item';
+                const indexVar = arrowFn.params[1]?.name ?? null;
+                const bodyNodes = processJSXCallbackBody(source, arrowFn.body);
+                const arrayExpr = toExpression(source, expr.callee.object);
+                const keyExpr = extractKeyExpr(bodyNodes);
+                result.push(new MapRegion(arrayExpr, itemVar, bodyNodes, keyExpr, indexVar));
+                i++;
+                continue;
+            }
+            if (expr.type === 'LogicalExpression' && expr.operator === '&&') {
+                const condExpr = toExpression(source, expr.left);
+                const consequent = exprToIR(source, expr.right);
+                result.push(new OpaqueDynamicRegion(condExpr, consequent));
+                i++;
+                continue;
+            }
+            if (expr.type === 'ConditionalExpression') {
+                const condExpr = toExpression(source, expr.test);
+                const consequent = exprToIR(source, expr.consequent);
+                const alternate = exprToIR(source, expr.alternate);
+                result.push(new OpaqueDynamicRegion(condExpr, consequent, alternate));
+                i++;
+                continue;
+            }
+            if ((expr.type === 'MemberExpression' && !expr.computed &&
+                expr.object.type === 'Identifier' && expr.object.name === 'props' &&
+                expr.property.type === 'Identifier' && expr.property.name === 'children')
+                || (expr.type === 'Identifier' && expr.name === 'children')) {
+                result.push(new SlotNode());
+                i++;
+                continue;
+            }
+            result.push(new DynamicBinding(toExpression(source, expr)));
+            i++;
+        }
+        else if (child.type === 'JSXElement') {
+            result.push(...processJSXElement(source, child));
+            i++;
+        }
+        else if (child.type === 'JSXFragment') {
+            for (const c of child.children)
+                result.push(...processJSXChildren(source, [c]));
+            i++;
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}
+function exprToIR(source, expr) {
+    if (expr.type === 'JSXElement')
+        return processJSXElement(source, expr);
+    if (expr.type === 'JSXFragment') {
+        const nodes = [];
+        for (const c of expr.children)
+            nodes.push(...processJSXChildren(source, [c]));
+        return nodes;
+    }
+    if (isMapCall(expr)) {
+        const arrowFn = expr.arguments[0];
+        const itemVar = arrowFn.params[0]?.name ?? 'item';
+        const indexVar = arrowFn.params[1]?.name ?? null;
+        const bodyNodes = processJSXCallbackBody(source, arrowFn.body);
+        const arrayExpr = toExpression(source, expr.callee.object);
+        const keyExpr = extractKeyExpr(bodyNodes);
+        return [new MapRegion(arrayExpr, itemVar, bodyNodes, keyExpr, indexVar)];
+    }
+    if (expr.type === 'ParenthesizedExpression')
+        return exprToIR(source, expr.expression);
+    // Nested conditionals/`&&` with JSX branches become nested dynamic regions
+    // so `a ? <X/> : b ? <Y/> : <Z/>` compiles recursively instead of degrading
+    // to a raw text binding.
+    if (expr.type === 'ConditionalExpression') {
+        const condExpr = toExpression(source, expr.test);
+        const consequent = exprToIR(source, expr.consequent);
+        const alternate = exprToIR(source, expr.alternate);
+        return [new OpaqueDynamicRegion(condExpr, consequent, alternate)];
+    }
+    if (expr.type === 'LogicalExpression' && expr.operator === '&&') {
+        const condExpr = toExpression(source, expr.left);
+        const consequent = exprToIR(source, expr.right);
+        return [new OpaqueDynamicRegion(condExpr, consequent)];
+    }
+    return [new DynamicBinding(toExpression(source, expr))];
+}
+function processJSXCallbackBody(source, body) {
+    if (body.type === 'JSXElement')
+        return processJSXElement(source, body);
+    if (body.type === 'JSXFragment') {
+        const nodes = [];
+        for (const c of body.children)
+            nodes.push(...processJSXChildren(source, [c]));
+        return nodes;
+    }
+    if (body.type === 'ParenthesizedExpression')
+        return exprToIR(source, body.expression);
+    return exprToIR(source, body);
+}
+function processJSXElement(source, element) {
+    const tagName = getJSXTagName(element.openingElement.name);
+    const selfClosing = element.openingElement.selfClosing;
+    if (tagName === 'Head') {
+        const children = selfClosing ? [] : processJSXChildren(source, element.children || []);
+        return [new HeadBlock(children)];
+    }
+    if (!isHTMLTag(tagName) && selfClosing) {
+        const { props, spreadProps } = extractProps(source, element);
+        return [new ComponentCall(tagName, props, [], spreadProps, element.start)];
+    }
+    if (!isHTMLTag(tagName)) {
+        const { props, spreadProps } = extractProps(source, element);
+        const children = processJSXChildren(source, element.children || []);
+        return [new ComponentCall(tagName, props, children, spreadProps, element.start)];
+    }
+    const attributes = element.openingElement.attributes
+        .filter((attr) => attr.type !== 'JSXSpreadAttribute')
+        .map((attr) => processAttribute(source, attr));
+    const staticAttrs = [];
+    const attrBindings = [];
+    let keyExpr = null;
+    for (const attr of attributes) {
+        if (attr.name === 'key') {
+            keyExpr = typeof attr.value === 'string' ? new Expression(JSON.stringify(attr.value)) : attr.value;
+            continue;
+        }
+        if (attr.name === 'ref') {
+            attrBindings.push(new DynamicBinding(attr.value, 'attribute', attr.name));
+            continue;
+        }
+        if (typeof attr.value === 'string') {
+            staticAttrs.push({ name: attr.name, value: attr.value });
+        }
+        else {
+            staticAttrs.push({ name: attr.name, value: '' });
+            attrBindings.push(new DynamicBinding(attr.value, 'attribute', attr.name));
+        }
+    }
+    const children = selfClosing ? [] : processJSXChildren(source, element.children || []);
+    const node = new StaticNode(tagName, staticAttrs, [...attrBindings, ...children], keyExpr);
+    node.selfClosing = selfClosing;
+    return [node];
+}
+function extractProps(source, element) {
+    const props = [];
+    const spreadProps = [];
+    for (const attr of element.openingElement.attributes) {
+        if (attr.type === 'JSXSpreadAttribute') {
+            spreadProps.push(toExpression(source, attr.argument));
+        }
+        else {
+            props.push({
+                name: attr.name.type === 'JSXIdentifier' ? attr.name.name : getSource(source, attr.name),
+                value: attr.value === null
+                    ? new Expression('true')
+                    : attr.value.type === 'JSXExpressionContainer'
+                        ? toExpression(source, attr.value.expression)
+                        : new Expression(JSON.stringify(attr.value.value)),
+            });
+        }
+    }
+    return { props, spreadProps };
+}
+function buildGuardChain(source, guardClauses, mainReturn) {
+    const mainBody = [];
+    if (mainReturn && mainReturn.argument) {
+        if (mainReturn.argument.type === 'JSXElement') {
+            mainBody.push(...processJSXElement(source, mainReturn.argument));
+        }
+        else if (mainReturn.argument.type === 'JSXFragment') {
+            for (const c of mainReturn.argument.children) {
+                mainBody.push(...processJSXChildren(source, [c]));
+            }
+        }
+        else {
+            mainBody.push(new DynamicBinding(toExpression(source, mainReturn.argument)));
+        }
+    }
+    let currentAlternate = mainBody;
+    for (let i = guardClauses.length - 1; i >= 0; i--) {
+        const guard = guardClauses[i];
+        const condExpr = toExpression(source, guard.test);
+        const consequent = [];
+        if (guard.consequent.type === 'ReturnStatement' && guard.consequent.argument) {
+            if (guard.consequent.argument.type === 'JSXElement') {
+                consequent.push(...processJSXElement(source, guard.consequent.argument));
+            }
+            else {
+                consequent.push(new DynamicBinding(toExpression(source, guard.consequent.argument)));
+            }
+        }
+        currentAlternate = [new OpaqueDynamicRegion(condExpr, consequent, currentAlternate)];
+    }
+    return currentAlternate;
+}
+function getComponentRefName(decl) {
+    if (!isTrackDeclaration(decl))
+        return null;
+    const pattern = decl.declarations[0].id;
+    if (pattern.type === 'ArrayPattern' && pattern.elements.length === 1) {
+        const name = pattern.elements[0]?.name;
+        if (name && name[0] === name[0].toUpperCase())
+            return name;
+    }
+    return null;
+}
+function hasJSXInSubtree(node) {
+    if (!node)
+        return false;
+    if (node.type === 'JSXElement' || node.type === 'JSXExpressionContainer' || node.type === 'JSXFragment')
+        return true;
+    if (node.type === 'BlockStatement')
+        return node.body.some(hasJSXInSubtree);
+    if (node.type === 'IfStatement')
+        return hasJSXInSubtree(node.consequent) || hasJSXInSubtree(node.alternate);
+    if (node.type === 'ForStatement' || node.type === 'ForInStatement' || node.type === 'ForOfStatement')
+        return hasJSXInSubtree(node.body);
+    if (node.type === 'WhileStatement' || node.type === 'DoWhileStatement')
+        return hasJSXInSubtree(node.body);
+    if (node.type === 'SwitchStatement')
+        return node.cases.some((c) => c.consequent?.some(hasJSXInSubtree));
+    if (node.type === 'TryStatement')
+        return hasJSXInSubtree(node.block) || hasJSXInSubtree(node.handler) || hasJSXInSubtree(node.finalizer);
+    if (node.type === 'CatchClause')
+        return hasJSXInSubtree(node.body);
+    if (node.type === 'LabeledStatement')
+        return hasJSXInSubtree(node.body);
+    if (node.type === 'ReturnStatement')
+        return hasJSXInSubtree(node.argument);
+    return false;
+}
+function isGuardClause(node) {
+    return node.type === 'IfStatement' && node.consequent.type === 'ReturnStatement' && hasJSXInSubtree(node.consequent);
+}
+function isStatementMode(bodyStmts) {
+    if (bodyStmts.some((s) => s.type === 'JSXElement' || s.type === 'JSXExpressionContainer' || s.type === 'JSXFragment'))
+        return true;
+    for (const stmt of bodyStmts) {
+        if (stmt.type === 'IfStatement' && !isGuardClause(stmt) && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'ForOfStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'ForStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'ForInStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'WhileStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'DoWhileStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'SwitchStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'TryStatement' && hasJSXInSubtree(stmt))
+            return true;
+        if (stmt.type === 'LabeledStatement' && hasJSXInSubtree(stmt))
+            return true;
+    }
+    return false;
+}
+function processBlockBody(source, block) {
+    if (block.type === 'BlockStatement')
+        return processStatementModeBody(source, block.body);
+    if (block.type === 'JSXElement')
+        return processJSXElement(source, block);
+    if (block.type === 'JSXFragment') {
+        const nodes = [];
+        for (const c of block.children)
+            nodes.push(...processJSXChildren(source, [c]));
+        return nodes;
+    }
+    if (block.type === 'IfStatement')
+        return processIfStatement(source, block);
+    if (block.type === 'JSXExpressionContainer') {
+        return exprToIR(source, block.expression);
+    }
+    const raw = getSource(source, block);
+    if (raw)
+        return [new RuntimeStatement(raw, block, source)];
+    return [];
+}
+function processIfStatement(source, stmt) {
+    const condExpr = toExpression(source, stmt.test);
+    const consequent = processBlockBody(source, stmt.consequent);
+    const alternate = stmt.alternate ? processBlockBody(source, stmt.alternate) : [];
+    return [new OpaqueDynamicRegion(condExpr, consequent, alternate)];
+}
+function processForStatement(source, stmt, alternate = []) {
+    if (stmt.type === 'ForOfStatement') {
+        const left = stmt.left;
+        const itemVar = left.type === 'VariableDeclaration'
+            ? left.declarations[0]?.id?.name ?? 'item'
+            : left.name ?? 'item';
+        const arrayExpr = toExpression(source, stmt.right);
+        const bodyTemplate = processBlockBody(source, stmt.body);
+        const ann = getForClauseAnnotation(stmt.start);
+        const keyExpr = ann?.keyRange ? new Expression(source.slice(ann.keyRange[0], ann.keyRange[1])) : null;
+        const indexVar = ann?.indexName ?? null;
+        return [new MapRegion(arrayExpr, itemVar, bodyTemplate, keyExpr, indexVar, alternate)];
+    }
+    if (stmt.type === 'ForInStatement') {
+        const left = getSource(source, stmt.left);
+        const objExpr = toExpression(source, stmt.right);
+        const bodyTemplate = processBlockBody(source, stmt.body);
+        return [new ForLoop(left, objExpr, '', bodyTemplate, 'for-in')];
+    }
+    if (stmt.type === 'ForStatement') {
+        const init = stmt.init ? getSource(source, stmt.init) : '';
+        const test = stmt.test ? toExpression(source, stmt.test) : new Expression('true');
+        const update = stmt.update ? getSource(source, stmt.update) : '';
+        const bodyTemplate = processBlockBody(source, stmt.body);
+        return [new ForLoop(init, test, update, bodyTemplate, 'for')];
+    }
+    return [];
+}
+function processWhileStatement(source, stmt) {
+    const condition = toExpression(source, stmt.test);
+    const bodyTemplate = processBlockBody(source, stmt.body);
+    const isDoWhile = stmt.type === 'DoWhileStatement';
+    return [new WhileLoop(condition, bodyTemplate, isDoWhile)];
+}
+function processSwitchStatement(source, stmt) {
+    const discriminant = toExpression(source, stmt.discriminant);
+    const cases = stmt.cases.map((c) => ({
+        test: c.test ? toExpression(source, c.test) : null,
+        body: processStatementModeBody(source, c.consequent),
+    }));
+    return [new SwitchBlock(discriminant, cases)];
+}
+function processTryStatement(source, stmt) {
+    const bodyTemplate = processBlockBody(source, stmt.block);
+    const catchBody = stmt.handler ? processBlockBody(source, stmt.handler.body) : [];
+    const catchParamName = stmt.handler?.param?.name ?? null;
+    return [new TryCatch(bodyTemplate, catchBody, catchParamName)];
+}
+function processStatementModeBody(source, bodyStmts) {
+    const nodes = [];
+    for (let i = 0; i < bodyStmts.length; i++) {
+        const stmt = bodyStmts[i];
+        if (stmt.type === 'JSXElement') {
+            nodes.push(...processJSXElement(source, stmt));
+        }
+        else if (stmt.type === 'JSXExpressionContainer') {
+            if (stmt.expression.type === 'JSXEmptyExpression')
+                continue;
+            if (isMapCall(stmt.expression)) {
+                const arrowFn = stmt.expression.arguments[0];
+                const itemVar = arrowFn.params[0]?.name ?? 'item';
+                const bodyNodes = processJSXCallbackBody(source, arrowFn.body);
+                const arrayExpr = toExpression(source, stmt.expression.callee.object);
+                const keyExpr = extractKeyExpr(bodyNodes);
+                nodes.push(new MapRegion(arrayExpr, itemVar, bodyNodes, keyExpr));
+                continue;
+            }
+            nodes.push(...exprToIR(source, stmt.expression));
+        }
+        else if (stmt.type === 'JSXFragment') {
+            for (const c of stmt.children) {
+                nodes.push(...processJSXChildren(source, [c]));
+            }
+        }
+        else if (stmt.type === 'VeskBlock') {
+            if (stmt.tag === 'empty')
+                continue;
+            const inner = processStatementModeBody(source, stmt.body);
+            if (stmt.tag === 'server') {
+                nodes.push(new ServerBlock(inner));
+            }
+            else if (stmt.tag === 'client') {
+                nodes.push(new ClientBlock(inner));
+            }
+        }
+        else if (isTrackDeclaration(stmt)) {
+            const elements = stmt.declarations[0].id.elements;
+            const name = elements[0]?.name;
+            const rawName = elements.length > 1 ? elements[1]?.name : null;
+            const init = getSource(source, stmt.declarations[0].init);
+            if (name)
+                nodes.push(new TrackDecl(name, init, rawName));
+            const refName = getComponentRefName(stmt);
+            if (refName)
+                nodes.push(new ComponentRef(refName));
+        }
+        else if (stmt.type === 'IfStatement') {
+            nodes.push(...processIfStatement(source, stmt));
+        }
+        else if (stmt.type === 'ForOfStatement') {
+            let alternate = [];
+            let consumed = 1;
+            const next = bodyStmts[i + 1];
+            if (next && next.type === 'VeskBlock' && next.tag === 'empty') {
+                alternate = processStatementModeBody(source, next.body);
+                consumed = 2;
+            }
+            nodes.push(...processForStatement(source, stmt, alternate));
+            i += consumed - 1;
+        }
+        else if (stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {
+            nodes.push(...processWhileStatement(source, stmt));
+        }
+        else if (stmt.type === 'SwitchStatement') {
+            nodes.push(...processSwitchStatement(source, stmt));
+        }
+        else if (stmt.type === 'TryStatement') {
+            nodes.push(...processTryStatement(source, stmt));
+        }
+        else if (stmt.type === 'ReturnStatement') {
+            if (stmt.argument) {
+                nodes.push(...exprToIR(source, stmt.argument));
+            }
+        }
+        else if (stmt.type === 'LabeledStatement') {
+            nodes.push(...processBlockBody(source, stmt.body));
+        }
+        else if (stmt.type === 'ForInStatement') {
+            nodes.push(...processForStatement(source, stmt));
+        }
+        else if (stmt.type === 'ForStatement') {
+            nodes.push(...processForStatement(source, stmt));
+        }
+        else if (stmt.type === 'ClassDeclaration') {
+            throw VeskError.classDecl();
+        }
+        else {
+            const raw = getSource(source, stmt);
+            if (raw)
+                nodes.push(new RuntimeStatement(raw, stmt, source));
+        }
+    }
+    return nodes;
+}
+function extractStyle(body) {
+    const cssParts = [];
+    const filtered = [];
+    for (const node of body) {
+        if (node instanceof StaticNode && node.tag === 'style') {
+            for (const child of node.children) {
+                if (child instanceof TextNode) {
+                    cssParts.push(child.value);
+                }
+            }
+        }
+        else {
+            filtered.push(node);
+        }
+    }
+    return { body: filtered, css: cssParts.join('\n') || null };
+}
+function validateBlocks(compName, isClient, body) {
+    for (const node of body) {
+        if (isClient) {
+            if (node instanceof ServerBlock) {
+                throw VeskError.serverBlockInClient(compName);
+            }
+        }
+        else {
+            if (node instanceof ClientBlock) {
+                throw VeskError.clientBlockInServer(compName);
+            }
+        }
+        if (node instanceof StaticNode || node instanceof ServerBlock || node instanceof ClientBlock) {
+            validateBlocks(compName, isClient, node.children || []);
+        }
+    }
+}
+function processEnum(node, source, exported) {
+    const name = node.id.name;
+    const pairs = [];
+    const reversePairs = [];
+    let autoVal = 0;
+    for (const member of node.members) {
+        const key = member.id.name;
+        let val;
+        if (member.initializer) {
+            val = getSource(source, member.initializer);
+        }
+        else {
+            val = String(autoVal);
+        }
+        pairs.push(`${JSON.stringify(key)}: ${val}`);
+        reversePairs.push(`${val}: ${JSON.stringify(key)}`);
+        if (!member.initializer)
+            autoVal++;
+    }
+    const allPairs = [...reversePairs, ...pairs].join(', ');
+    const prefix = exported ? `export const ${name}` : `const ${name}`;
+    return `${prefix} = { ${allPairs} };`;
+}
+export function generateIR(ast, source) {
+    __vskAnnotations = ast.__vskAnnotations ?? [];
+    const components = [];
+    const imports = [];
+    const importedNames = new Set();
+    let staticProps = null;
+    let loadFn = null;
+    const topLevelCode = [];
+    for (const node of ast.body) {
+        if (node.type === 'ImportDeclaration') {
+            const raw = getSource(source, node);
+            const cleaned = stripTypeImport(raw);
+            if (cleaned === null)
+                continue;
+            imports.push(cleaned);
+            for (const spec of node.specifiers) {
+                if (spec.importKind === 'type')
+                    continue;
+                if (spec.type === 'ImportSpecifier') {
+                    importedNames.add(spec.local.name);
+                }
+            }
+            continue;
+        }
+        if (node.type === 'ExportNamedDeclaration' && node.declaration && !staticProps) {
+            const decl = node.declaration;
+            const fnName = decl.type === 'FunctionDeclaration'
+                ? decl.id?.name
+                : decl.type === 'VariableDeclaration'
+                    ? decl.declarations[0]?.id?.name
+                    : null;
+            if (fnName === 'getStaticProps') {
+                staticProps = stripCodeTypes(getSource(source, decl));
+                continue;
+            }
+        }
+        if (node.type === 'ExportNamedDeclaration' && node.declaration && !loadFn) {
+            const decl = node.declaration;
+            const fnName = decl.type === 'FunctionDeclaration'
+                ? decl.id?.name
+                : decl.type === 'VariableDeclaration'
+                    ? decl.declarations[0]?.id?.name
+                    : null;
+            if (fnName === 'load') {
+                loadFn = stripCodeTypes(getSource(source, decl));
+                continue;
+            }
+        }
+        let inner = node;
+        let exported = false;
+        let defaultExport = false;
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+            inner = node.declaration;
+            exported = true;
+        }
+        else if (node.type === 'ExportDefaultDeclaration' && node.declaration) {
+            inner = node.declaration;
+            exported = true;
+            defaultExport = true;
+        }
+        if (inner.type === 'ComponentDeclaration') {
+            // handled below
+        }
+        else if (inner.type === 'ClassDeclaration') {
+            throw VeskError.classDecl();
+        }
+        else if (inner.type === 'TSEnumDeclaration') {
+            const code = processEnum(inner, source, exported);
+            topLevelCode.push(code);
+            continue;
+        }
+        else {
+            topLevelCode.push(getSource(source, node));
+            continue;
+        }
+        const name = inner.id.name;
+        const paramNames = getParamNames(inner.params, source);
+        const propsType = getPropsType(inner.params, source);
+        const bodyStmts = inner.body.body;
+        const isClientComp = !!inner.client;
+        if (isStatementMode(bodyStmts)) {
+            const raw = processStatementModeBody(source, bodyStmts);
+            const { body, css } = extractStyle(raw);
+            validateBlocks(name, isClientComp, body);
+            const comp = new ComponentIR(name, paramNames, body, { mode: 'statement', exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType });
+            comp.style = css;
+            components.push(comp);
+        }
+        else {
+            const guardClauses = [];
+            let mainReturn = null;
+            const preamble = [];
+            for (const stmt of bodyStmts) {
+                if (stmt.type === 'VeskBlock') {
+                    const innerBody = processStatementModeBody(source, stmt.body);
+                    if (stmt.tag === 'server') {
+                        preamble.push(new ServerBlock(innerBody));
+                    }
+                    else if (stmt.tag === 'client') {
+                        preamble.push(new ClientBlock(innerBody));
+                    }
+                }
+                else if (stmt.type === 'ReturnStatement') {
+                    mainReturn = stmt;
+                }
+                else if (isTrackDeclaration(stmt)) {
+                    const elements = stmt.declarations[0].id.elements;
+                    const trackName = elements[0]?.name;
+                    const rawName = elements.length > 1 ? elements[1]?.name : null;
+                    const init = getSource(source, stmt.declarations[0].init);
+                    if (trackName)
+                        preamble.push(new TrackDecl(trackName, init, rawName));
+                    const refName = getComponentRefName(stmt);
+                    if (refName)
+                        preamble.push(new ComponentRef(refName));
+                }
+                else if (stmt.type === 'IfStatement' && !mainReturn && stmt.consequent.type !== 'ThrowStatement') {
+                    guardClauses.push(stmt);
+                }
+                else if (stmt.type === 'ClassDeclaration') {
+                    throw VeskError.classDecl();
+                }
+                else {
+                    const raw = getSource(source, stmt);
+                    if (raw)
+                        preamble.push(new RuntimeStatement(raw, stmt, source));
+                }
+            }
+            const guardBody = buildGuardChain(source, guardClauses, mainReturn);
+            const { body, css } = extractStyle([...preamble, ...guardBody]);
+            validateBlocks(name, isClientComp, body);
+            const comp = new ComponentIR(name, paramNames, body, { exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType });
+            comp.style = css;
+            components.push(comp);
+        }
+    }
+    const asyncNames = new Set(components.filter((c) => c.isAsync || c.ssrAwait).map((c) => c.name));
+    for (const comp of components) {
+        if (asyncNames.has(comp.name))
+            continue;
+        const called = new Map();
+        collectComponentCalls(comp.body, called);
+        for (const [childName, start] of called) {
+            if (!asyncNames.has(childName))
+                continue;
+            const { line, column } = offsetToLineCol(source, start >= 0 ? start : 0);
+            throw VeskError.asyncChildInSyncParent(comp.name, childName, { line, column });
+        }
+    }
+    const autoImportable = [
+        'useFetch', 'useRouter', 'useParams', 'usePathname', 'useSearchParams', 'useNavigate',
+        'defineAction',
+        'Form', 'Field', 'required', 'email', 'minLength', 'maxLength', 'pattern', 'custom',
+        'Link', 'NavLink', 'Outlet', 'Redirect',
+        'Image', 'Portal',
+        'Experiment',
+        'JsonLd', 'ArticleSchema', 'ProductSchema', 'FAQPageSchema', 'BreadcrumbListSchema',
+        'OrganizationSchema', 'LocalBusinessSchema', 'VideoSchema',
+        'effect', 'derived', 'untrack', 'peek', 'tick', 'flushSync', 'on_destroy',
+        'createContext',
+        'redirect', 'permanentRedirect', 'notFound', 'NotFoundError',
+        'createResource', 'getAction', 'validateActionInput', 'issuesToFieldMap', 'isFormAction',
+    ];
+    const usedFunctions = new Set();
+    const addUsedFrom = (code) => {
+        const called = collectCalledIdentifiers(code);
+        for (const fn of autoImportable) {
+            if (called.has(fn))
+                usedFunctions.add(fn);
+        }
+    };
+    for (const code of topLevelCode)
+        addUsedFrom(code);
+    for (const code of [loadFn, staticProps]) {
+        if (code)
+            addUsedFrom(code);
+    }
+    function scanForAutoImport(nodes) {
+        for (const node of nodes) {
+            if (node instanceof RuntimeStatement && node.raw) {
+                addUsedFrom(node.raw);
+            }
+            if (node instanceof ComponentCall) {
+                if (autoImportable.includes(node.componentName)) {
+                    usedFunctions.add(node.componentName);
+                }
+                for (const prop of node.props) {
+                    if (prop.value && prop.value.raw) {
+                        addUsedFrom(prop.value.raw);
+                    }
+                }
+                scanForAutoImport(node.children);
+            }
+            if (node instanceof MapRegion) {
+                scanForAutoImport(node.bodyTemplate);
+                scanForAutoImport(node.alternateNodes);
+            }
+            if (node instanceof OpaqueDynamicRegion) {
+                scanForAutoImport(node.consequentNodes);
+                scanForAutoImport(node.alternateNodes);
+            }
+            if (node instanceof DynamicBinding && node.expression && node.expression.raw) {
+                addUsedFrom(node.expression.raw);
+            }
+            if (node instanceof StaticNode || node instanceof ServerBlock || node instanceof ClientBlock || node instanceof HeadBlock) {
+                scanForAutoImport(node.children);
+            }
+        }
+    }
+    scanForAutoImport(components.flatMap(c => c.body));
+    if (usedFunctions.size > 0) {
+        const existing = new Set();
+        for (const imp of imports) {
+            if (importModuleTarget(imp) !== '@vesk/runtime')
+                continue;
+            for (const n of extractImportNames(imp))
+                existing.add(n);
+        }
+        const missing = [...usedFunctions].filter(f => !existing.has(f));
+        if (missing.length > 0) {
+            imports.push(`import { ${missing.join(', ')} } from '@vesk/runtime';`);
+        }
+    }
+    return new IRRoot(components, imports, importedNames, staticProps, loadFn, topLevelCode);
+}