@vesk/compiler 0.2.50 → 0.2.51

package/dist/ir-generator.js

@@ -433,6 +433,64 @@ function jsxTagDepth(nameNode) {
 // `import * as ns from './x.vsk'`.
 let currentVskNamespaceLocals = null;
 let currentSourceFile;
+/**
+ * Names bound to a component VALUE in the component's OWN body (a parameter or
+ * a `const`/`let`/`var`/function declared inside it) that a JSX tag may
+ * legally resolve to.
+ *
+ * A JSX tag was historically registry-only: `<Icon />` looked the name up in
+ * the component registry and threw "was not found" when it missed, even though
+ * `const Icon = item.icon` had bound a perfectly good component value one line
+ * above. That made the single most natural way to write a dynamic-icon nav
+ * list (`const Icon = item.icon; <li><Icon size={14} /></li>`) a 500 for the
+ * WHOLE route — and the error text ("declare it with the `component` keyword")
+ * named the one thing the author had already done correctly.
+ *
+ * Such a name is emitted with a `calleeExpr`, routing it through the SAME code
+ * path that already works for `<it.icon />` — the callee is invoked directly
+ * instead of resolved as a name.
+ *
+ * Deliberately EXCLUDES imported names and top-level file values: those
+ * already resolve through the `importedNames` path in both codegens, and
+ * giving them a callee there would take self-claiming runtime components
+ * (`Link`, `Form`, `Md`) off the path that reserves the caller's walker
+ * correctly. Registry resolution also keeps precedence: a name that is a
+ * declared `component` still wins.
+ */
+let currentComponentValues = null;
+/** File-wide name sets backing `isComponentValueName`. */
+let currentFileComponentNames = null;
+let currentFileValueBindings = null;
+let currentImportedNames = null;
+let currentComponentCallHelpers = null;
+/** A helper body expression that is exactly one component call, or null. */
+function unwrapHelperBody(node) {
+    let body = node;
+    if (body?.type === 'ArrowFunctionExpression' || body?.type === 'FunctionExpression')
+        body = body.body;
+    if (body?.type === 'BlockStatement') {
+        const stmts = (body.body || []).filter((s) => s.type !== 'EmptyStatement');
+        if (stmts.length !== 1)
+            return null;
+        body = stmts[0];
+    }
+    if (body?.type === 'ReturnStatement')
+        body = body.argument;
+    if (!body)
+        return null;
+    // Shape check only — deliberately NOT `componentCallInExpression`, which
+    // consults the per-component name sets. Helpers are collected once for the
+    // whole file, before any component's sets are installed, and whether a
+    // callee resolves to a component is settled at the call site instead.
+    if (body.type !== 'CallExpression')
+        return null;
+    if (body.callee?.type !== 'Identifier')
+        return null;
+    const args = body.arguments || [];
+    if (args.length === 0 || args[0]?.type !== 'ObjectExpression')
+        return null;
+    return body;
+}
 /**
  * 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
@@ -489,6 +547,61 @@ function markShadowedBindings(node, namespaceLocals) {
     }
 }
 /** Names a single binding-bearing node introduces. */
+/**
+ * Every top-level VALUE binding in the file (excluding `component`
+ * declarations — those are registry entries, not values, and resolve by name).
+ * Pre-scanned rather than read out of `topLevelCode`, which fills in as the
+ * top-level loop runs and would therefore miss a binding declared after the
+ * component currently being compiled.
+ */
+function collectFileValueBindings(ast) {
+    const names = new Set();
+    for (const node of (ast.body || [])) {
+        if (node.type === 'ComponentDeclaration')
+            continue;
+        if (node.type === 'ImportDeclaration')
+            continue;
+        const target = node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration'
+            ? node.declaration
+            : node;
+        if (!target)
+            continue;
+        if (target.type === 'VariableDeclaration') {
+            for (const d of target.declarations || [])
+                for (const n of declaredBindingNames(d))
+                    names.add(n);
+            continue;
+        }
+        for (const n of declaredBindingNames(target))
+            names.add(n);
+    }
+    return names;
+}
+/**
+ * Every value binding a tag inside one component body could resolve to —
+ * the component's own parameters and body-local declarations only.
+ */
+function collectComponentValueNames(compNode) {
+    const names = new Set();
+    if (!compNode)
+        return names;
+    for (const p of compNode.params || [])
+        for (const n of declaredBindingNames(p))
+            names.add(n);
+    for (const stmt of (compNode.body?.body || [])) {
+        // A body statement is the DECLARATION (`const Icon = …`), and
+        // `declaredBindingNames` reads declarators, so unwrap first.
+        if (stmt.type === 'VariableDeclaration') {
+            for (const d of stmt.declarations || [])
+                for (const n of declaredBindingNames(d))
+                    names.add(n);
+            continue;
+        }
+        for (const n of declaredBindingNames(stmt))
+            names.add(n);
+    }
+    return names;
+}
 function declaredBindingNames(node) {
     const out = [];
     const pushPattern = (id) => {
@@ -582,9 +695,227 @@ function findNamespaceValueUse(node, locals) {
     }
     return null;
 }
+/**
+ * Build the helper table from the file's top-level const/function bindings.
+ * Only single-expression component-call bodies with plain identifier params
+ * are recorded — see `ComponentCallHelper` for why the rest are excluded.
+ */
+function collectComponentCallHelpers(source, ast) {
+    const out = new Map();
+    for (const node of (ast.body || [])) {
+        const decl = node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration'
+            ? node.declaration
+            : node;
+        if (!decl)
+            continue;
+        let name = null;
+        let fn = null;
+        if (decl.type === 'VariableDeclaration' && decl.declarations?.length === 1) {
+            const d = decl.declarations[0];
+            if (d.id?.type === 'Identifier') {
+                name = d.id.name;
+                fn = d.init;
+            }
+        }
+        else if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
+            name = decl.id.name;
+            fn = decl;
+        }
+        if (!name || !fn)
+            continue;
+        if (fn.type !== 'ArrowFunctionExpression' && fn.type !== 'FunctionExpression' && fn.type !== 'FunctionDeclaration')
+            continue;
+        // A rest/default/destructured parameter cannot be substituted by a simple
+        // identifier match, so such helpers are left as ordinary calls.
+        const params = fn.params || [];
+        if (params.some((p) => p.type !== 'Identifier'))
+            continue;
+        const body = unwrapHelperBody(fn);
+        if (body === null)
+            continue;
+        const args = body.arguments || [];
+        const propsObj = args[0];
+        const props = [];
+        const spreadProps = [];
+        const slots = [];
+        for (const prop of (propsObj.properties || [])) {
+            if (prop.type === 'SpreadElement') {
+                spreadProps.push(prop.argument);
+                continue;
+            }
+            const pname = prop.key.type === 'Identifier' ? prop.key.name : prop.key.value;
+            if (prop.value.type === 'JSXElement' || prop.value.type === 'JSXFragment') {
+                slots.push({ name: pname, nodes: exprToIR(source, prop.value) });
+                continue;
+            }
+            props.push({ name: pname, value: prop.value });
+        }
+        const paramNames = params.map((p) => p.name);
+        out.set(name, { props, spreadProps, slots, paramNames, componentName: body.callee.name });
+    }
+    return out;
+}
+/**
+ * Replace every identifier in `node` that matches a helper parameter with the
+ * argument passed at the call site. Identifier-only and AST-level (the compiler
+ * never rewrites source by pattern), and it returns null if the tree holds
+ * anything it cannot prove is a value — e.g. a nested function that closes over
+ * the parameter, where substituting would change what runs.
+ */
+function substituteHelperParams(node, bindings) {
+    if (!node || typeof node !== 'object')
+        return node;
+    if (Array.isArray(node)) {
+        const out = [];
+        for (const child of node) {
+            const next = substituteHelperParams(child, bindings);
+            if (next === null)
+                return null;
+            out.push(next);
+        }
+        return out;
+    }
+    if (typeof node.type !== 'string')
+        return node;
+    // A nested function body runs later and may capture the parameter; leave the
+    // whole helper alone rather than risk changing its meaning.
+    if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression')
+        return null;
+    if (node.type === 'Identifier' && bindings.has(node.name)) {
+        const bound = bindings.get(node.name);
+        return bound === null ? null : bound;
+    }
+    const out = {};
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'range' || key === 'start' || key === 'end') {
+            out[key] = node[key];
+            continue;
+        }
+        const next = substituteHelperParams(node[key], bindings);
+        if (next === null)
+            return null;
+        out[key] = next;
+    }
+    return out;
+}
+/** Lower a call to a `ComponentCallHelper` into a real `ComponentCall`. */
+function helperCallToIR(source, helper, args) {
+    // The rendered component is the one INSIDE the helper, not the helper itself.
+    const compName = helper.componentName;
+    // First argument is the props object INSIDE the helper; the caller's
+    // arguments fill the helper's parameters from index 0.
+    const bindings = new Map();
+    helper.paramNames.forEach((param, i) => bindings.set(param, args[i] ?? null));
+    for (const bound of bindings.values())
+        if (bound === null)
+            return null;
+    const props = [];
+    for (const p of helper.props) {
+        const substituted = substituteHelperParams(p.value, bindings);
+        if (substituted === null)
+            return null;
+        props.push({ name: p.name, value: toExpression(source, substituted) });
+    }
+    const spreadProps = [];
+    for (const sp of helper.spreadProps) {
+        const substituted = substituteHelperParams(sp, bindings);
+        if (substituted === null)
+            return null;
+        spreadProps.push(toExpression(source, substituted));
+    }
+    return [new ComponentCall(compName, props, helper.slots.flatMap((s) => [new PropSlot(s.name, s.nodes)]), spreadProps, -1, componentValueCallee(compName))];
+}
 function isHTMLTag(name) {
     return name.length > 0 && name[0] === name[0].toLowerCase();
 }
+/**
+ * The `calleeExpr` for a bare-identifier JSX tag, or null when the name must
+ * resolve through the component registry.
+ *
+ * Null is the default and the reason every existing tag is untouched: only a
+ * name bound to a value in this component's scope gets a callee, so
+ * `component Icon {}` / imported components keep registry semantics (with
+ * their "not found" diagnostic), while `const Icon = item.icon` — which used to
+ * throw and take the whole route down with it — resolves to the value it is.
+ */
+function componentValueCallee(tagName) {
+    if (!currentComponentValues || !currentComponentValues.has(tagName))
+        return null;
+    return tagName;
+}
+/**
+ * A component invoked as a function in expression position, or null.
+ *
+ * The callee must be a plain identifier that names a component — an import, a
+ * top-level file value, a body-local binding, or a declared `component` — and
+ * the first argument an object literal, the shape `Terminal({ size: 14 })` has.
+ *
+ * This is a WIDER name test than `componentValueCallee`, and deliberately so:
+ * a tag only needs a callee for names nothing else can resolve, but a CALL has
+ * no other lowering at all. The first argument must be an object literal
+ * because that is what distinguishes a component invocation from an ordinary
+ * call on a same-named helper, and the callee must be a known component name
+ * for the same reason — `doThing(x)` on a local helper stays an ordinary call.
+ */
+function componentCallInExpression(expr) {
+    if (!expr || expr.type !== 'CallExpression')
+        return null;
+    const callee = expr.callee;
+    if (!callee || callee.type !== 'Identifier')
+        return null;
+    if (!isComponentValueName(callee.name))
+        return null;
+    const args = expr.arguments || [];
+    if (args.length === 0 || !args[0] || args[0].type !== 'ObjectExpression')
+        return null;
+    return expr;
+}
+/**
+ * Every name in the file that denotes a component: declared `component`s,
+ * imports, top-level file values, and the current component's body-local
+ * bindings. Used only to recognize a component call — never to give a tag a
+ * callee (that is `componentValueCallee`'s narrower job).
+ */
+function isComponentValueName(name) {
+    if (currentFileComponentNames?.has(name))
+        return true;
+    if (currentComponentValues?.has(name))
+        return true;
+    return currentFileValueBindings?.has(name) || currentImportedNames?.has(name) || false;
+}
+/**
+ * Lower `Comp({ a: 1, ...rest })` to a `ComponentCall`. Props/spreads map
+ * straight onto the component-call channels; a slot-shaped value (`children`)
+ * is routed through `PropSlot` so named content keeps working when a component
+ * is invoked as a function rather than used as a tag.
+ */
+function componentCallToIR(source, expr) {
+    const calleeName = expr.callee.name;
+    const args = expr.arguments || [];
+    const propsArg = args[0];
+    const props = [];
+    const spreadProps = [];
+    const slots = [];
+    for (const prop of (propsArg.properties || [])) {
+        if (prop.type === 'SpreadElement') {
+            spreadProps.push(toExpression(source, prop.argument));
+            continue;
+        }
+        const name = prop.key.type === 'Identifier' ? prop.key.name : prop.key.value;
+        if (prop.value.type === 'JSXElement' || prop.value.type === 'JSXFragment') {
+            slots.push(new PropSlot(name, exprToIR(source, prop.value)));
+            continue;
+        }
+        props.push({ name, value: toExpression(source, prop.value) });
+    }
+    // Extra positional arguments are the component ABI (`props`, registry,
+    // walker) that only the compiler emits; a caller's own extra args are not
+    // something to forward, and silently dropping them would hide a mistake.
+    const children = args.length > 1
+        ? [new RuntimeStatement(`/* [vesk] extra arguments to a component call are ignored */ ${getSource(source, args[1])}`)]
+        : [];
+    return [new ComponentCall(calleeName, props, [...children, ...slots], spreadProps, expr.start ?? -1, componentValueCallee(calleeName))];
+}
 function isMapCall(expr) {
     return (expr.type === 'CallExpression' &&
         expr.callee.type === 'MemberExpression' &&
@@ -926,7 +1257,10 @@ function processJSXChildren(source, children) {
                     continue;
                 }
             }
-            result.push(new DynamicBinding(toExpression(source, expr)));
+            // Routed through exprToIR so a component invoked as a function (and a
+            // module-scope helper returning one) becomes a real component render
+            // rather than text that gets escaped into visible markup.
+            result.push(...exprToIR(source, expr));
             i++;
         }
         else if (child.type === 'JSXElement') {
@@ -990,6 +1324,30 @@ function exprToIR(source, expr) {
     }
     if (expr.type === 'ParenthesizedExpression')
         return exprToIR(source, expr.expression);
+    // A component INVOKED as a function in expression position
+    // (`{Terminal({ size: 14 })}`, or any branch of a ternary/`&&`) used to
+    // degrade to a text binding, and the server escaped the component's HTML
+    // string into visible page text — the worst failure mode of the three,
+    // because it looks like content. `{cond ? Terminal({ size: 14 }) : null}`
+    // was worse still: the escaped markup rendered as nothing at all, so a
+    // missing icon shipped silently.
+    //
+    // A component's return value is markup, not text, so the call must be a real
+    // component render. It is lowered to the SAME `ComponentCall` node a `<Tag />`
+    // would produce, which means it inherits the hydration marker, the claim
+    // path, and the fragment flattening that the tag form already relies on —
+    // rather than needing a second, parallel implementation.
+    if (componentCallInExpression(expr) !== null)
+        return componentCallToIR(source, expr);
+    // A module-scope helper that just returns a component call is the same
+    // component render one level removed — inline it (see
+    // `ComponentCallHelper`) rather than let its HTML be escaped into the page.
+    if (expr?.type === 'CallExpression' && currentComponentCallHelpers?.has(expr.callee?.name)) {
+        const helper = currentComponentCallHelpers.get(expr.callee.name);
+        const inlined = helperCallToIR(source, helper, expr.arguments || []);
+        if (inlined !== null)
+            return inlined;
+    }
     // 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.
@@ -1093,12 +1451,12 @@ function processJSXElement(source, element) {
     }
     if (!isHTMLTag(tagName) && selfClosing) {
         const { props, spreadProps, slots } = extractProps(source, element);
-        return [new ComponentCall(tagName, props, slots.map((s) => new PropSlot(s.name, s.nodes)), spreadProps, element.start)];
+        return [new ComponentCall(tagName, props, slots.map((s) => new PropSlot(s.name, s.nodes)), spreadProps, element.start, componentValueCallee(tagName))];
     }
     if (!isHTMLTag(tagName)) {
         const { props, spreadProps, slots } = extractProps(source, element);
         const children = processJSXChildren(source, element.children || []);
-        return [new ComponentCall(tagName, 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, componentValueCallee(tagName))];
     }
     const attributes = element.openingElement.attributes
         .filter((attr) => attr.type !== 'JSXSpreadAttribute')
@@ -1635,6 +1993,20 @@ export function generateIR(ast, source, filename) {
     const vskNamespaceLocals = collectVskNamespaceLocals(ast);
     const prevNamespaceLocals = currentVskNamespaceLocals;
     const prevSourceFile = currentSourceFile;
+    // Pre-scan the two name sets the per-component value resolution needs, so
+    // order in the file does not matter.
+    const fileValueBindings = collectFileValueBindings(ast);
+    currentComponentCallHelpers = collectComponentCallHelpers(source, ast);
+    const prevFileComponentNames = currentFileComponentNames;
+    const prevFileValueBindings = currentFileValueBindings;
+    const prevImportedNames = currentImportedNames;
+    const fileComponentNames = new Set((ast.body || [])
+        .map((n) => (n.type === 'ExportNamedDeclaration' || n.type === 'ExportDefaultDeclaration' ? n.declaration : n))
+        .filter((n) => n?.type === 'ComponentDeclaration')
+        .map((n) => n.id.name));
+    currentFileComponentNames = fileComponentNames;
+    currentFileValueBindings = fileValueBindings;
+    currentImportedNames = importedNames;
     currentVskNamespaceLocals = vskNamespaceLocals;
     currentSourceFile = file;
     try {
@@ -1774,76 +2146,87 @@ export function generateIR(ast, source, filename) {
             }
             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));
+            // Value bindings a tag/call in THIS body may resolve to (see
+            // `currentComponentValues`). Registry components are excluded so a declared
+            // `component Icon` keeps winning over any same-named value binding.
+            const valueNames = collectComponentValueNames(inner);
+            const prevComponentValues = currentComponentValues;
+            currentComponentValues = new Set([...valueNames].filter((n) => !fileComponentNames.has(n)));
+            try {
+                // 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.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));
                         }
                     }
-                    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;
                 }
-                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;
+            }
+            finally {
+                currentComponentValues = prevComponentValues;
             }
         }
         const asyncNames = new Set(components.filter((c) => c.isAsync || c.ssrAwait).map((c) => c.name));
@@ -1915,5 +2298,9 @@ export function generateIR(ast, source, filename) {
     finally {
         currentVskNamespaceLocals = prevNamespaceLocals;
         currentSourceFile = prevSourceFile;
+        currentFileComponentNames = prevFileComponentNames;
+        currentFileValueBindings = prevFileValueBindings;
+        currentImportedNames = prevImportedNames;
+        currentComponentCallHelpers = null;
     }
 }

package/dist/module-imports.d.ts

@@ -1,4 +1,5 @@
 import { parse } from '@vesk/compiler/src/parser';
+import { VeskError } from '@vesk/compiler/src/errors';
 /** True when the import target is owned by the framework (never SSR-loaded). */
 export declare function isCompilerOwnedTarget(target: string): boolean;
 /** True when the target carries no value into the SSR scope. */
@@ -37,10 +38,13 @@ export declare function applyLocalModuleImports(__vesk: Record<string, unknown>,
  * Builtin markers load through Node and are cached separately (never stale).
  */
 export declare function loadSsrModule(absPath: string): Record<string, unknown> | null;
-export declare function readSsrSource(absPath: string): {
+export interface SsrSource {
     raw: string;
     ast: ReturnType<typeof parse> | null;
-} | null;
+    /** Set when `raw` could not be parsed; see `moduleParseFailed`. */
+    parseError?: VeskError;
+}
+export declare function readSsrSource(absPath: string): SsrSource | null;
 /** Nearest `tsconfig.json` at or above `fromDir`, or null. */
 export declare function findTsconfigPath(fromDir: string): string | null;
 /**

package/dist/module-imports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-imports.d.ts","sourceRoot":"","sources":["../src/module-imports.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"module-imports.d.ts","sourceRoot":"","sources":["../src/module-imports.ts"],"names":[],"mappings":"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"}