@vesk/compiler 0.2.42 → 0.2.44

package/dist/ir-generator.js

@@ -400,6 +400,188 @@ function getJSXTagName(nameNode) {
     }
     return 'unknown';
 }
+/** Root identifier of a dotted JSX tag: `NS.Icon` -> `NS`. */
+function jsxTagRootName(nameNode) {
+    let node = nameNode;
+    while (node && node.type === 'JSXMemberExpression')
+        node = node.object;
+    return node && node.type === 'JSXIdentifier' ? node.name : '';
+}
+/** The final property of a dotted JSX tag: `NS.A.B` → `B`. */
+function jsxTagMemberName(nameNode) {
+    let node = nameNode;
+    while (node && node.type === 'JSXMemberExpression') {
+        node = node.property;
+        if (node && node.type === 'JSXIdentifier')
+            return node.name;
+    }
+    return '';
+}
+/** How many member hops a dotted tag has: `NS.A` → 1, `NS.A.B` → 2. */
+function jsxTagDepth(nameNode) {
+    let depth = 0;
+    let node = nameNode;
+    while (node && node.type === 'JSXMemberExpression') {
+        depth++;
+        node = node.object;
+    }
+    return depth;
+}
+// Set for the duration of one `generateIR` call so `processJSXElement` — which
+// is reached from eleven call sites and would otherwise need a context
+// parameter threaded through all of them — can reject `<ns.Tag />` for a
+// `import * as ns from './x.vsk'`.
+let currentVskNamespaceLocals = null;
+let currentSourceFile;
+/**
+ * Local names bound by `import * as ns from './x.vsk'` that are NOT shadowed by
+ * any other binding in the file. A `.vsk` namespace is only special when the
+ * name still refers to the import: if a parameter or a local shadows it, the
+ * tag is an ordinary member expression on a real object and must keep the
+ * `calleeExpr` path. Names the file re-binds are therefore dropped here, which
+ * also keeps the value-position check from rejecting valid shadowed code.
+ */
+function collectVskNamespaceLocals(ast) {
+    const namespaceLocals = new Map();
+    for (const node of (ast.body || [])) {
+        if (node.type !== 'ImportDeclaration')
+            continue;
+        if (typeof node.source?.value !== 'string' || !node.source.value.endsWith('.vsk'))
+            continue;
+        for (const spec of node.specifiers || []) {
+            if (spec.type === 'ImportNamespaceSpecifier' && spec.local?.name) {
+                namespaceLocals.set(spec.local.name, { path: node.source.value, shadowed: false });
+            }
+        }
+    }
+    if (namespaceLocals.size === 0)
+        return new Set();
+    markShadowedBindings(ast, namespaceLocals);
+    return new Set([...namespaceLocals].filter(([, v]) => !v.shadowed).map(([k]) => k));
+}
+/**
+ * Flags every namespace local that the file also binds by some other means.
+ * The namespace import itself is the only declaration that does NOT shadow —
+ * everything else (var/let/const, function and class declarations, any
+ * parameter list, catch bindings) means the name is a plain local from here on.
+ */
+function markShadowedBindings(node, namespaceLocals) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            markShadowedBindings(child, namespaceLocals);
+        return;
+    }
+    if (typeof node.type === 'string') {
+        if (node.type === 'ImportNamespaceSpecifier')
+            return; // the import itself
+        for (const name of declaredBindingNames(node)) {
+            const entry = namespaceLocals.get(name);
+            if (entry)
+                entry.shadowed = true;
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'range' || key === 'start' || key === 'end')
+            continue;
+        markShadowedBindings(node[key], namespaceLocals);
+    }
+}
+/** Names a single binding-bearing node introduces. */
+function declaredBindingNames(node) {
+    const out = [];
+    const pushPattern = (id) => {
+        if (!id)
+            return;
+        if (id.type === 'Identifier') {
+            out.push(id.name);
+            return;
+        }
+        if (id.type === 'ObjectPattern') {
+            for (const prop of id.properties || []) {
+                if (prop.type === 'RestElement')
+                    pushPattern(prop.argument);
+                else
+                    pushPattern(prop.value);
+            }
+            return;
+        }
+        if (id.type === 'ArrayPattern') {
+            for (const el of id.elements || [])
+                if (el)
+                    pushPattern(el.type === 'RestElement' ? el.argument : el);
+            return;
+        }
+        if (id.type === 'AssignmentPattern')
+            pushPattern(id.left);
+        if (id.type === 'RestElement')
+            pushPattern(id.argument);
+    };
+    switch (node.type) {
+        case 'VariableDeclarator':
+            pushPattern(node.id);
+            break;
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+            if (node.id)
+                pushPattern(node.id);
+            for (const param of node.params || [])
+                pushPattern(param);
+            break;
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            if (node.id)
+                pushPattern(node.id);
+            break;
+        case 'CatchClause':
+            pushPattern(node.param);
+            break;
+        default:
+            break;
+    }
+    return out;
+}
+/**
+ * Rejects reading a member off a `.vsk` namespace in *value* position. A
+ * namespace is resolved only for component tags, so `ns.max` in an expression
+ * has nothing bound to it at runtime — say so here instead of failing later
+ * with a bare `ReferenceError: ns is not defined`.
+ */
+function assertNoVskNamespaceValue(source, expr) {
+    if (!currentVskNamespaceLocals || currentVskNamespaceLocals.size === 0)
+        return;
+    const hit = findNamespaceValueUse(expr, currentVskNamespaceLocals);
+    if (!hit)
+        return;
+    const { line, column } = offsetToLineCol(source, hit.start ?? 0);
+    throw VeskError.vskNamespaceMember({ file: currentSourceFile, line, column, code: codeFrame(source, line, column), form: 'value' });
+}
+function findNamespaceValueUse(node, locals) {
+    if (!node || typeof node !== 'object')
+        return null;
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            const hit = findNamespaceValueUse(child, locals);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
+    if (typeof node.type !== 'string')
+        return null;
+    if (node.type === 'MemberExpression' && node.object?.type === 'Identifier' && locals.has(node.object.name))
+        return node;
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'range' || key === 'start' || key === 'end')
+            continue;
+        const hit = findNamespaceValueUse(node[key], locals);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
 function isHTMLTag(name) {
     return name.length > 0 && name[0] === name[0].toLowerCase();
 }
@@ -411,6 +593,7 @@ function isMapCall(expr) {
         expr.arguments[0].type === 'ArrowFunctionExpression');
 }
 function toExpression(source, expr) {
+    assertNoVskNamespaceValue(source, expr);
     return new Expression(getSource(source, expr), [], expr, source);
 }
 function processAttribute(source, attr) {
@@ -887,8 +1070,25 @@ function processJSXElement(source, element) {
     // actual in-scope value instead of `document.createElement("it.icon")` or a
     // registry lookup by dotted string.
     if (nameNode && nameNode.type === 'JSXMemberExpression') {
+        const root = jsxTagRootName(nameNode);
+        const isVskNamespace = !!currentVskNamespaceLocals && currentVskNamespaceLocals.has(root);
+        if (isVskNamespace && jsxTagDepth(nameNode) > 1) {
+            // A `.vsk` module's exports are flat component names, so there is no
+            // nested namespace object to walk into.
+            const { line, column } = offsetToLineCol(source, nameNode.start ?? 0);
+            throw VeskError.vskNamespaceMember({ file: currentSourceFile, line, column, code: codeFrame(source, line, column), form: 'nested' });
+        }
         const { props, spreadProps, slots } = extractProps(source, element);
         const children = selfClosing ? [] : processJSXChildren(source, element.children || []);
+        if (isVskNamespace) {
+            // `<ns.Icon />` after `import * as ns from './lib.vsk'` resolves to the
+            // same registry entry `import { Icon }` would, keyed by the EXPORTED name.
+            // Deliberately carries no `calleeExpr`: both codegen paths must take the
+            // registry branch so `<ns.Icon />` keeps the "component was not found"
+            // guard and hydrates like any other compiled component. The namespace
+            // object itself is never built.
+            return [new ComponentCall(jsxTagMemberName(nameNode), props, [...children, ...slots.map((s) => new PropSlot(s.name, s.nodes))], spreadProps, element.start)];
+        }
         return [new ComponentCall(tagName, props, [...children, ...slots.map((s) => new PropSlot(s.name, s.nodes))], spreadProps, element.start, getSource(source, nameNode))];
     }
     if (!isHTMLTag(tagName) && selfClosing) {
@@ -1411,222 +1611,289 @@ export function generateIR(ast, source, filename) {
     let staticProps = null;
     let loadFn = null;
     const topLevelCode = [];
-    for (const node of ast.body) {
-        if (node.type === 'ImportDeclaration') {
-            const raw = getSource(source, node);
-            let cleaned = stripTypeImport(raw);
-            if (cleaned === null)
-                continue;
-            cleaned = normalizeRuntimeSpecifier(cleaned);
-            imports.push(cleaned);
-            for (const spec of node.specifiers) {
-                if (spec.importKind === 'type')
+    const exportAliases = [];
+    const reexportSources = [];
+    // `export { A }` / `export { A as B }` are stripped by the parser (acorn
+    // rejects a module export that names no top-level binding, and a `.vsk`
+    // component is a registry entry, not a binding). The pairs ride along on the
+    // AST and become registry aliases below.
+    for (const pair of (ast
+        .__vskSpecifierExports) || []) {
+        exportAliases.push({ local: pair.local, exported: pair.exported });
+    }
+    // `import * as ns from './x.vsk'` has no runtime binding: a `.vsk` component
+    // is a registry entry, not a module namespace object. Pre-scan the import
+    // declarations so a `<ns.Tag />` can be reported clearly instead of failing
+    // later as an opaque "ns is not defined".
+    const vskNamespaceLocals = collectVskNamespaceLocals(ast);
+    const prevNamespaceLocals = currentVskNamespaceLocals;
+    const prevSourceFile = currentSourceFile;
+    currentVskNamespaceLocals = vskNamespaceLocals;
+    currentSourceFile = file;
+    try {
+        for (const node of ast.body) {
+            if (node.type === 'ImportDeclaration') {
+                const raw = getSource(source, node);
+                let cleaned = stripTypeImport(raw);
+                if (cleaned === null)
                     continue;
-                if (spec.type === 'ImportSpecifier') {
-                    importedNames.add(spec.local.name);
+                cleaned = normalizeRuntimeSpecifier(cleaned);
+                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;
+            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;
+                }
             }
-        }
-        // `export const standalone = true` / `export let standalone = true` is a
-        // compile-time routing directive (isStandaloneLayoutFile), not runtime
-        // code — drop it so it never reaches emitted JS (client chunks are
-        // IIFE-wrapped where a bare `export` is a syntax error).
-        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-            const decl = node.declaration;
-            if (decl.type === 'VariableDeclaration') {
-                const declName = decl.declarations[0]?.id?.name;
-                if (declName === 'standalone') {
+            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') {
-            const { line, column } = offsetToLineCol(source, inner.start ?? 0);
-            throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
-        }
-        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);
-        // A plain-identifier first parameter receives the whole props object under
-        // its own name (React-style); a destructuring pattern receives the fields.
-        const firstParam = inner.params?.[0];
-        const propsAlias = firstParam && firstParam.type === 'Identifier' ? firstParam.name : null;
-        const propsType = getPropsType(inner.params, source);
-        const bodyStmts = inner.body.body;
-        const isClientComp = !!inner.client;
-        // Slot props are declared at the component boundary (`trigger: Component`),
-        // so content reads of `props.<name>` compile to slot renders instead of
-        // value bindings for THIS component only.
-        const prevSlotProps = __slotProps;
-        __slotProps = slotPropNamesFromType(propsType);
-        __propsParam = propsAlias || null;
-        if (isStatementMode(bodyStmts)) {
-            const raw = processStatementModeBody(source, bodyStmts, file);
-            const { body, css } = extractStyle(raw);
-            validateBlocks(name, isClientComp, body, file, source);
-            const comp = new ComponentIR(name, paramNames, body, { mode: 'statement', exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
-            comp.style = css;
-            components.push(comp);
-            __slotProps = prevSlotProps;
-        }
-        else {
-            const guardClauses = [];
-            let mainReturn = null;
-            const preamble = [];
-            for (const stmt of bodyStmts) {
-                if (stmt.type === 'VeskBlock') {
-                    const innerBody = processStatementModeBody(source, stmt.body, file);
-                    if (stmt.tag === 'server') {
-                        preamble.push(new ServerBlock(innerBody));
-                    }
-                    else if (stmt.tag === 'client') {
-                        preamble.push(new ClientBlock(innerBody));
+            // `export const standalone = true` / `export let standalone = true` is a
+            // compile-time routing directive (isStandaloneLayoutFile), not runtime
+            // code — drop it so it never reaches emitted JS (client chunks are
+            // IIFE-wrapped where a bare `export` is a syntax error).
+            if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+                const decl = node.declaration;
+                if (decl.type === 'VariableDeclaration') {
+                    const declName = decl.declarations[0]?.id?.name;
+                    if (declName === 'standalone') {
+                        continue;
                     }
                 }
-                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') {
-                    const { line, column } = offsetToLineCol(source, stmt.start ?? 0);
-                    throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
+            }
+            if (node.type === 'ExportNamedDeclaration' && !node.declaration) {
+                // A specifier-only export (`export { A }`, `export { A as B }`) or a
+                // re-export (`export { A } from './x.vsk'`, `export { default as A } from …`).
+                // Never emit the raw statement: components are registry entries, not
+                // top-level bindings, so emitting it yields `Export 'A' is not defined`.
+                if (node.source) {
+                    if (typeof node.source.value === 'string')
+                        reexportSources.push(node.source.value);
+                    // `export { A as B } from './x.vsk'`: the target's components merge into
+                    // this file's registry under their own names, so the specifier is the
+                    // same canonical -> alias mapping a same-file export would produce.
+                    for (const spec of node.specifiers || []) {
+                        if (spec.type === 'ExportSpecifier') {
+                            const localName = spec.local && spec.local.name;
+                            const exportedName = spec.exported && spec.exported.name;
+                            if (typeof localName === 'string' && typeof exportedName === 'string') {
+                                exportAliases.push({ local: localName, exported: exportedName });
+                            }
+                        }
+                    }
+                    continue;
                 }
-                else {
-                    const raw = getSource(source, stmt);
-                    if (raw)
-                        preamble.push(new RuntimeStatement(raw, stmt, source));
+                for (const spec of node.specifiers || []) {
+                    if (spec.type === 'ExportSpecifier') {
+                        const localName = spec.local && spec.local.name;
+                        const exportedName = spec.exported && spec.exported.name;
+                        if (typeof localName === 'string' && typeof exportedName === 'string') {
+                            exportAliases.push({ local: localName, exported: exportedName });
+                        }
+                    }
                 }
+                continue;
             }
-            const guardBody = buildGuardChain(source, guardClauses, mainReturn);
-            const { body, css } = extractStyle([...preamble, ...guardBody]);
-            validateBlocks(name, isClientComp, body, file, source);
-            const comp = new ComponentIR(name, paramNames, body, { exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
-            comp.style = css;
-            components.push(comp);
-            __slotProps = prevSlotProps;
-        }
-    }
-    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))
+            if (node.type === 'ExportAllDeclaration') {
+                // `export * from './x.vsk'` / `export * as ns from './x.vsk'`: resolve the
+                // target into this file's component registry instead of emitting a bare
+                // re-export that no bundler can satisfy for `.vsk` modules.
+                if (node.source && typeof node.source.value === 'string')
+                    reexportSources.push(node.source.value);
+                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') {
+                const { line, column } = offsetToLineCol(source, inner.start ?? 0);
+                throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
+            }
+            else if (inner.type === 'TSEnumDeclaration') {
+                const code = processEnum(inner, source, exported);
+                topLevelCode.push(code);
                 continue;
-            const { line, column } = offsetToLineCol(source, start >= 0 ? start : 0);
-            throw VeskError.asyncChildInSyncParent(comp.name, childName, { file, line, column, code: codeFrame(source, 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',
-        'LoadingIndicator', 'useLoadingIndicator',
-        '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',
-        'Show', 'For', 'Switch', 'Match',
-    ];
-    // One walk of the already-parsed tree finds every auto-importable call
-    // target and JSX element name. Every IR raw the old per-fragment scan
-    // re-tokenized ("addUsedFrom" over ~15 text slices) is a subtree of this
-    // very same `ast` — nothing is lost, but the acorn tokenizer is invoked once
-    // per file instead of once per fragment.
-    const called = collectCallAndJsxTargets(ast);
-    const usedFunctions = new Set();
-    for (const fn of autoImportable) {
-        if (called.has(fn))
-            usedFunctions.add(fn);
-    }
-    if (usedFunctions.size > 0) {
-        const existing = new Set();
-        for (const imp of imports) {
-            if (importModuleTarget(imp) !== '@vesk/runtime')
+            }
+            else {
+                topLevelCode.push(getSource(source, node));
                 continue;
-            for (const n of extractImportNames(imp))
-                existing.add(n);
+            }
+            const name = inner.id.name;
+            const paramNames = getParamNames(inner.params, source);
+            // A plain-identifier first parameter receives the whole props object under
+            // its own name (React-style); a destructuring pattern receives the fields.
+            const firstParam = inner.params?.[0];
+            const propsAlias = firstParam && firstParam.type === 'Identifier' ? firstParam.name : null;
+            const propsType = getPropsType(inner.params, source);
+            const bodyStmts = inner.body.body;
+            const isClientComp = !!inner.client;
+            // Slot props are declared at the component boundary (`trigger: Component`),
+            // so content reads of `props.<name>` compile to slot renders instead of
+            // value bindings for THIS component only.
+            const prevSlotProps = __slotProps;
+            __slotProps = slotPropNamesFromType(propsType);
+            __propsParam = propsAlias || null;
+            if (isStatementMode(bodyStmts)) {
+                const raw = processStatementModeBody(source, bodyStmts, file);
+                const { body, css } = extractStyle(raw);
+                validateBlocks(name, isClientComp, body, file, source);
+                const comp = new ComponentIR(name, paramNames, body, { mode: 'statement', exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
+                comp.style = css;
+                components.push(comp);
+                __slotProps = prevSlotProps;
+            }
+            else {
+                const guardClauses = [];
+                let mainReturn = null;
+                const preamble = [];
+                for (const stmt of bodyStmts) {
+                    if (stmt.type === 'VeskBlock') {
+                        const innerBody = processStatementModeBody(source, stmt.body, file);
+                        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') {
+                        const { line, column } = offsetToLineCol(source, stmt.start ?? 0);
+                        throw VeskError.classDecl({ file, line, column, code: codeFrame(source, line, column) });
+                    }
+                    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, file, source);
+                const comp = new ComponentIR(name, paramNames, body, { exported, defaultExport, isClient: inner.client, isAsync: inner.async, ssrAwait: componentUsesFetch(body), propsType, propsAlias });
+                comp.style = css;
+                components.push(comp);
+                __slotProps = prevSlotProps;
+            }
         }
-        // A name already bound by the file's own imports (any target — including a
-        // local module with the same export) wins; never auto-import a duplicate
-        // binding. Mirrors client shadowing so SSR and client agree.
-        const boundLocally = new Set();
-        for (const imp of imports) {
-            for (const pair of importBindingPairs(imp))
-                boundLocally.add(pair.local);
+        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, { file, line, column, code: codeFrame(source, line, column) });
+            }
         }
-        const missing = [...usedFunctions].filter(f => !existing.has(f) && !boundLocally.has(f));
-        if (missing.length > 0) {
-            imports.push(`import { ${missing.join(', ')} } from '@vesk/runtime';`);
+        const autoImportable = [
+            'useFetch', 'useRouter', 'useParams', 'usePathname', 'useSearchParams', 'useNavigate',
+            'defineAction',
+            'Form', 'Field', 'required', 'email', 'minLength', 'maxLength', 'pattern', 'custom',
+            'Link', 'NavLink', 'Outlet', 'Redirect',
+            'Image', 'Portal',
+            'Experiment',
+            'LoadingIndicator', 'useLoadingIndicator',
+            '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',
+            'Show', 'For', 'Switch', 'Match',
+            'primitive', 'leaf',
+        ];
+        // One walk of the already-parsed tree finds every auto-importable call
+        // target and JSX element name. Every IR raw the old per-fragment scan
+        // re-tokenized ("addUsedFrom" over ~15 text slices) is a subtree of this
+        // very same `ast` — nothing is lost, but the acorn tokenizer is invoked once
+        // per file instead of once per fragment.
+        const called = collectCallAndJsxTargets(ast);
+        const usedFunctions = new Set();
+        for (const fn of autoImportable) {
+            if (called.has(fn))
+                usedFunctions.add(fn);
+        }
+        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);
+            }
+            // A name already bound by the file's own imports (any target — including a
+            // local module with the same export) wins; never auto-import a duplicate
+            // binding. Mirrors client shadowing so SSR and client agree.
+            const boundLocally = new Set();
+            for (const imp of imports) {
+                for (const pair of importBindingPairs(imp))
+                    boundLocally.add(pair.local);
+            }
+            const missing = [...usedFunctions].filter(f => !existing.has(f) && !boundLocally.has(f));
+            if (missing.length > 0) {
+                imports.push(`import { ${missing.join(', ')} } from '@vesk/runtime';`);
+            }
         }
+        return new IRRoot(components, imports, importedNames, staticProps, loadFn, topLevelCode, exportAliases, reexportSources);
+    }
+    finally {
+        currentVskNamespaceLocals = prevNamespaceLocals;
+        currentSourceFile = prevSourceFile;
     }
-    return new IRRoot(components, imports, importedNames, staticProps, loadFn, topLevelCode);
 }