@lithia-js/native 1.0.0-canary.2

package/src/builder/compiler.rs

@@ -0,0 +1,493 @@
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+use swc_atoms::Wtf8Atom;
+use swc_common::{
+    comments::SingleThreadedComments,
+    errors::{EmitterWriter, Handler},
+    source_map::SourceMapGenConfig,
+    sync::Lrc,
+    BytePos, FileName, Globals, LineCol, Mark, SourceMap, GLOBALS,
+};
+use swc_ecma_codegen::{text_writer::JsWriter, Emitter as CodegenEmitter};
+use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax, TsSyntax};
+use swc_ecma_transforms_base::{fixer::fixer, hygiene::hygiene, resolver};
+use swc_ecma_transforms_module::{common_js, path::Resolver as PathResolverEnum};
+use swc_ecma_transforms_typescript::strip;
+
+use swc_ecma_ast::{CallExpr, Callee, Expr, ExprOrSpread, Lit, Module, ModuleDecl, ModuleItem};
+use swc_ecma_visit::{VisitMut, VisitMutWith};
+
+use crate::builder::sourcemap::write_sourcemap_and_code;
+
+use super::tsconfig::TsConfigOptions;
+
+/// Simple, thread-safe buffer used to capture diagnostics emitted by SWC.
+///
+/// The `ErrorBuffer` implements `std::io::Write` and stores emitted bytes
+/// in a shared `Arc<Mutex<Vec<u8>>>`. The native builder uses this buffer to
+/// capture human-readable error output from SWC and return it to the host
+/// instead of writing directly to stderr.
+#[derive(Clone)]
+struct ErrorBuffer {
+    buffer: std::sync::Arc<std::sync::Mutex<Vec<u8>>>,
+}
+
+impl ErrorBuffer {
+    fn new() -> Self {
+        Self {
+            buffer: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+        }
+    }
+
+    fn get_content(&self) -> String {
+        self.buffer
+            .lock()
+            .ok()
+            .and_then(|buf| String::from_utf8(buf.clone()).ok())
+            .unwrap_or_default()
+    }
+}
+
+impl Write for ErrorBuffer {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.buffer
+            .lock()
+            .map_err(|_| std::io::Error::other("Lock failed"))?
+            .write(buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.buffer
+            .lock()
+            .map_err(|_| std::io::Error::other("Lock failed"))?
+            .flush()
+    }
+}
+
+/// Small `SourceMapGenConfig` implementation used when emitting source maps.
+///
+/// It provides basic filename resolution and enables inlining the original
+/// sources content into the generated `.map` file. Keeping the original
+/// content in `sourcesContent` simplifies debugging in the runtime where the
+/// physical source files may not be available.
+struct SourceMapConfigImpl;
+
+impl SourceMapGenConfig for SourceMapConfigImpl {
+    fn file_name_to_source(&self, f: &FileName) -> String {
+        f.to_string()
+    }
+
+    fn inline_sources_content(&self, _: &FileName) -> bool {
+        true
+    }
+}
+
+/// Visitor that rewrites import/require/import() specifiers according to
+/// base_url + paths mapping (simple implementation).
+struct PathsRewriter {
+    base_url: PathBuf,
+    // Vec of (from_pattern, to_targets)
+    paths: Vec<(String, Vec<String>)>,
+    // directory of current file being compiled (for generating relative specifiers)
+    file_dir: PathBuf,
+}
+
+impl PathsRewriter {
+    fn resolve_using_paths(&self, spec: &str) -> Option<String> {
+        // If spec is relative or absolute, don't touch
+        if spec.starts_with('.') || spec.starts_with('/') {
+            return None;
+        }
+
+        // Try each mapping
+        for (from, to_list) in &self.paths {
+            if from.contains('*') {
+                // wildcard pattern
+                // support exactly one '*' (like the real resolver)
+                if from.as_bytes().iter().filter(|&&c| c == b'*').count() != 1 {
+                    continue;
+                }
+                let pos = from.find('*').unwrap();
+                let prefix = &from[..pos];
+                if !spec.starts_with(prefix) {
+                    continue;
+                }
+                let extra = &spec[prefix.len()..];
+
+                for target in to_list {
+                    let replaced = target.replace('*', extra);
+                    // Candidate paths to check on disk
+                    // 1) base_url / replaced
+                    // 2) base_url / ./replaced
+                    // Also try common extensions
+                    if let Some(abs_found) = try_find_file_on_disk(&self.base_url.join(&replaced)) {
+                        // produce a path relative from file_dir to abs_found
+                        let rel = make_relative_or_prefixed(&self.file_dir, &abs_found);
+                        return Some(rel);
+                    }
+
+                    if let Some(abs_found) =
+                        try_find_file_on_disk(&self.base_url.join(format!("./{}", replaced)))
+                    {
+                        let rel = make_relative_or_prefixed(&self.file_dir, &abs_found);
+                        return Some(rel);
+                    }
+
+                    // As fallback, if single target and prefix not empty, mimic SWC's behavior:
+                    // return "./replaced" even if file not found (matches JS tests expectation).
+                    if to_list.len() == 1 && !prefix.is_empty() {
+                        let mut replaced_for_import = replaced.clone();
+                        if !replaced_for_import.starts_with("./")
+                            && !replaced_for_import.starts_with('/')
+                        {
+                            replaced_for_import = format!("./{}", replaced_for_import);
+                        }
+                        return Some(replaced_for_import);
+                    }
+                }
+            } else {
+                // exact match
+                if spec != from {
+                    continue;
+                }
+                // to_list must have exactly one entry (TypeScript rule)
+                let target = &to_list[0];
+                let tp = Path::new(target);
+                if tp.is_absolute() {
+                    if let Some(abs_found) = try_find_file_on_disk(tp) {
+                        let rel = make_relative_or_prefixed(&self.file_dir, &abs_found);
+                        return Some(rel);
+                    }
+                    // absolute but not found, still return as-is
+                    return Some(target.clone());
+                }
+
+                // relative to base_url
+                if let Some(abs_found) = try_find_file_on_disk(&self.base_url.join(target)) {
+                    let rel = make_relative_or_prefixed(&self.file_dir, &abs_found);
+                    return Some(rel);
+                }
+
+                // fallback: return "./target"
+                let mut replaced_for_import = target.clone();
+                if !replaced_for_import.starts_with("./") && !replaced_for_import.starts_with('/') {
+                    replaced_for_import = format!("./{}", replaced_for_import);
+                }
+                return Some(replaced_for_import);
+            }
+        }
+
+        // If no mapping matched, try baseUrl + spec (baseUrl resolution)
+        let candidate = self.base_url.join(spec);
+        if let Some(abs_found) = try_find_file_on_disk(&candidate) {
+            let rel = make_relative_or_prefixed(&self.file_dir, &abs_found);
+            return Some(rel);
+        }
+
+        None
+    }
+}
+
+impl VisitMut for PathsRewriter {
+    fn visit_mut_module(&mut self, n: &mut Module) {
+        // Walk module items and rewrite specifiers where applicable
+        n.visit_mut_children_with(self);
+    }
+
+    fn visit_mut_module_item(&mut self, n: &mut ModuleItem) {
+        match n {
+            ModuleItem::ModuleDecl(decl) => match decl {
+                ModuleDecl::Import(import_decl) => {
+                    let orig = import_decl.src.value.to_string_lossy().to_string();
+                    if let Some(new_spec) = self.resolve_using_paths(&orig) {
+                        import_decl.src.value = Wtf8Atom::from(new_spec);
+                        import_decl.src.raw = None;
+                    }
+                }
+                ModuleDecl::ExportAll(export_all) => {
+                    let orig = export_all.src.value.to_string_lossy().to_string();
+                    if let Some(new_spec) = self.resolve_using_paths(&orig) {
+                        export_all.src.value = Wtf8Atom::from(new_spec);
+                        export_all.src.raw = None;
+                    }
+                }
+                ModuleDecl::ExportDecl(_) => {}
+                ModuleDecl::ExportNamed(named) => {
+                    if let Some(src) = &mut named.src {
+                        let orig = src.value.to_string_lossy().to_string();
+                        if let Some(new_spec) = self.resolve_using_paths(&orig) {
+                            src.value = Wtf8Atom::from(new_spec);
+                            src.raw = None;
+                        }
+                    }
+                }
+                _ => {}
+            },
+            ModuleItem::Stmt(stmt) => {
+                // For statements, we still need to inspect call expressions (require)
+                stmt.visit_mut_children_with(self);
+            }
+        }
+    }
+
+    fn visit_mut_expr(&mut self, n: &mut Expr) {
+        // dynamic import: import("x")
+        if let Expr::Call(CallExpr { callee, args, .. }) = n {
+            // CommonJS require: require("x")
+            #[allow(clippy::collapsible_match)]
+            if let Callee::Expr(callee_expr) = callee {
+                if let Expr::Ident(ident) = &**callee_expr {
+                    if &*ident.sym == "require" {
+                        if let Some(ExprOrSpread { expr, .. }) = args.get_mut(0) {
+                            if let Expr::Lit(Lit::Str(s)) = &mut **expr {
+                                let orig = s.value.to_string_lossy().to_string();
+                                if let Some(new_spec) = self.resolve_using_paths(&orig) {
+                                    s.value = Wtf8Atom::from(new_spec);
+                                    s.raw = None;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // For other expressions, recurse
+        n.visit_mut_children_with(self);
+    }
+}
+
+/// Try to find a file on disk for a candidate path. We try:
+/// - the exact path
+/// - path + .ts, .tsx, .js, .jsx, .d.ts
+fn try_find_file_on_disk(candidate: &Path) -> Option<PathBuf> {
+    if candidate.exists() && candidate.is_file() {
+        return Some(std::fs::canonicalize(candidate).unwrap_or_else(|_| candidate.to_path_buf()));
+    }
+
+    static EXTS: [&str; 5] = ["ts", "tsx", "js", "jsx", "d.ts"];
+    for ext in &EXTS {
+        let mut p = candidate.to_path_buf();
+        // if candidate already has an extension, skip adding another
+        if candidate.extension().is_some() {
+            // already has extension and didn't exist, skip
+            continue;
+        }
+        p.set_extension(ext);
+        if p.exists() && p.is_file() {
+            return Some(std::fs::canonicalize(&p).unwrap_or(p));
+        }
+    }
+
+    // try index files if candidate is a directory
+    if candidate.is_dir() {
+        for ext in &["ts", "tsx", "js", "jsx"] {
+            let mut idx = candidate.to_path_buf();
+            idx.push(format!("index.{}", ext));
+            if idx.exists() && idx.is_file() {
+                return Some(std::fs::canonicalize(&idx).unwrap_or(idx));
+            }
+        }
+    }
+
+    None
+}
+
+/// Produce a specifier string to use in imports:
+/// - If target is inside file_dir parent, produce a relative path (e.g., "./sub/foo")
+/// - Otherwise produce a path prefixed with "./" and the path relative to base (fallback).
+fn make_relative_or_prefixed(file_dir: &Path, target: &Path) -> String {
+    // Canonicalize both paths where possible so diff_paths returns a clean relative path
+    let target_abs = std::fs::canonicalize(target).unwrap_or_else(|_| target.to_path_buf());
+    let file_dir_abs = std::fs::canonicalize(file_dir).unwrap_or_else(|_| file_dir.to_path_buf());
+
+    // Try to compute a relative path from file_dir to target
+    let rel =
+        pathdiff::diff_paths(&target_abs, &file_dir_abs).unwrap_or_else(|| target_abs.clone());
+
+    let mut s = rel.to_string_lossy().to_string().replace('\\', "/");
+
+    // Ensure relative paths start with ./
+    if !s.starts_with('.') && !s.starts_with('/') {
+        s = format!("./{}", s);
+    }
+
+    // Strip common source extensions (keep behaviour consistent with TS/SWC expectations)
+    if s.ends_with(".d.ts") {
+        s.truncate(s.len() - 5);
+    } else if s.ends_with(".tsx") || s.ends_with(".jsx") {
+        s.truncate(s.len() - 4);
+    } else if s.ends_with(".ts") || s.ends_with(".js") {
+        s.truncate(s.len() - 3);
+    }
+
+    s
+}
+
+/// TypeScript to JavaScript compiler backed by SWC.
+///
+/// `TypeScriptCompiler` wraps SWC parsing, transforms and codegen to produce
+/// JavaScript output and an optional source map. It is configured using
+/// `TsConfigOptions` so the host can control whether source maps are
+/// emitted and which ECMAScript target is selected.
+pub struct TypeScriptCompiler {
+    ts_config: TsConfigOptions,
+}
+
+impl TypeScriptCompiler {
+    /// Create a new compiler configured by `ts_config`.
+    pub fn new(ts_config: TsConfigOptions) -> Self {
+        Self { ts_config }
+    }
+
+    /// Compile a single TypeScript file to JavaScript.
+    pub fn compile_file(&self, input: &Path, output: &Path) -> Result<(), String> {
+        let cm: Lrc<SourceMap> = Default::default();
+
+        // Capture errors in a buffer instead of printing to stderr
+        let error_buffer = ErrorBuffer::new();
+        let error_buffer_clone = error_buffer.clone();
+
+        let emitter = EmitterWriter::new(Box::new(error_buffer), Some(cm.clone()), false, true);
+        let handler = Handler::with_emitter(true, false, Box::new(emitter));
+
+        let fm = cm
+            .load_file(input)
+            .map_err(|e| format!("Failed to load input {}: {}", input.display(), e))?;
+
+        let comments = SingleThreadedComments::default();
+
+        // Parse TypeScript (no TSX support - backend only)
+        let lexer = Lexer::new(
+            Syntax::Typescript(TsSyntax {
+                tsx: false,
+                ..Default::default()
+            }),
+            self.ts_config.target,
+            StringInput::from(&*fm),
+            Some(&comments),
+        );
+
+        let mut parser = Parser::new_from(lexer);
+
+        for e in parser.take_errors() {
+            e.into_diagnostic(&handler).emit();
+        }
+
+        let module = parser.parse_program().map_err(|e| {
+            e.into_diagnostic(&handler).emit();
+
+            let error_msg = error_buffer_clone.get_content();
+            if error_msg.is_empty() {
+                format!("Failed to parse {}", input.display())
+            } else {
+                format!("\n{}", error_msg.trim())
+            }
+        })?;
+
+        // Apply transformations and generate code + optional sourcemap
+        let globals = Globals::default();
+        let (code, map_opt) = GLOBALS
+            .set(&globals, || {
+                self.transform_and_generate(module, &cm, &comments, input)
+            })
+            .map_err(|e| format!("Transformation error: {:?}", e))?;
+
+        // Write output with optional sourcemap
+        if self.ts_config.emit_sourcemap {
+            if let Some(map) = map_opt {
+                write_sourcemap_and_code(output, &code, Some(map))?;
+            } else {
+                std::fs::write(output, code)
+                    .map_err(|e| format!("Failed to write output {}: {}", output.display(), e))?;
+            }
+        } else {
+            std::fs::write(output, code)
+                .map_err(|e| format!("Failed to write output {}: {}", output.display(), e))?;
+        }
+
+        Ok(())
+    }
+
+    /// Apply SWC transforms (resolver, strip, CommonJS conversion, hygiene)
+    /// and perform code generation.
+    ///
+    /// Now accepts `input` to compute relative paths when rewriting imports.
+    fn transform_and_generate(
+        &self,
+        module: swc_ecma_ast::Program,
+        cm: &Lrc<SourceMap>,
+        comments: &SingleThreadedComments,
+        input: &Path,
+    ) -> Result<(String, Option<String>), String> {
+        let unresolved_mark = Mark::new();
+        let top_level_mark = Mark::new();
+
+        // Start from Program (owned)
+        let mut program = module;
+
+        // If ts_config defines base_url or paths, run our paths rewriter
+        if let Some(base_url) = &self.ts_config.base_url {
+            let compiled_paths = &self.ts_config.paths; // Used direct field access
+            if !compiled_paths.is_empty() {
+                let rewriter = PathsRewriter {
+                    base_url: base_url.clone(),
+                    paths: compiled_paths.clone(),
+                    file_dir: input
+                        .parent()
+                        .map(PathBuf::from)
+                        .unwrap_or_else(|| PathBuf::from(".")),
+                };
+
+                // visit mutably to rewrite specifiers
+                let mut rewriter = rewriter;
+                program.visit_mut_with(&mut rewriter);
+            }
+        }
+
+        // agora aplique as transforms normais
+        let module = program.apply(resolver(unresolved_mark, top_level_mark, true));
+        let module = module.apply(strip(unresolved_mark, top_level_mark));
+        let module = module.apply(common_js(
+            PathResolverEnum::Default,
+            unresolved_mark,
+            swc_ecma_transforms_module::util::Config::default(),
+            swc_ecma_transforms_module::common_js::FeatureFlag::default(),
+        ));
+        let module = module.apply(hygiene());
+        let program = module.apply(fixer(Some(comments)));
+
+        // NOTE: buffer de mappings como Vec<(BytePos, LineCol)>
+        let mut src_map_buf: Vec<(BytePos, LineCol)> = Vec::new();
+        let mut code_buf: Vec<u8> = Vec::new();
+
+        {
+            let js_writer = JsWriter::new(cm.clone(), "\n", &mut code_buf, Some(&mut src_map_buf));
+            let mut emitter = CodegenEmitter {
+                cfg: Default::default(),
+                cm: cm.clone(),
+                comments: Some(comments),
+                wr: Box::new(js_writer),
+            };
+
+            emitter
+                .emit_program(&program)
+                .map_err(|e| format!("codegen emit error: {:?}", e))?;
+        }
+
+        let code = String::from_utf8(code_buf).map_err(|e| format!("code not utf8: {:?}", e))?;
+
+        let map = if !src_map_buf.is_empty() {
+            let sm = cm.build_source_map(&src_map_buf, None, SourceMapConfigImpl);
+            let mut s = Vec::new();
+            sm.to_writer(&mut s)
+                .map_err(|e| format!("failed to write source map file: {:?}", e))?;
+            Some(String::from_utf8(s).map_err(|e| format!("source map not utf8: {:?}", e))?)
+        } else {
+            None
+        };
+
+        Ok((code, map))
+    }
+}

package/src/builder/config.rs

@@ -0,0 +1,67 @@
+use std::path::PathBuf;
+
+use super::tsconfig::{parse_tsconfig, TsConfigOptions};
+
+/// Build configuration for the TypeScript compiler.
+///
+/// `BuildConfig` holds paths and parsed TypeScript options used by the
+/// native builder. It also provides convenient helpers to compute output
+/// locations and string representations used in other modules.
+#[derive(Clone, Debug)]
+pub struct BuildConfig {
+    /// Root directory containing the source files to compile.
+    pub source_root: PathBuf,
+
+    /// Output root directory where compiled assets will be written.
+    pub out_root: PathBuf,
+
+    /// Parsed tsconfig options used to configure the compiler.
+    pub ts_config: TsConfigOptions,
+
+    /// Glob patterns that should be ignored when scanning source files.
+    pub ignore_patterns: Vec<String>,
+}
+
+impl BuildConfig {
+    /// Create a new `BuildConfig` from `source_root` and `out_root` strings.
+    ///
+    /// This function attempts to parse `tsconfig.json` in the current
+    /// working directory to populate compiler options. It returns an error
+    /// string when parsing fails.
+    pub fn new(source_root: String, out_root: String) -> Result<Self, String> {
+        let tsconfig_path = PathBuf::from("tsconfig.json");
+        let ts_config = parse_tsconfig(Some(&tsconfig_path))?;
+
+        let source_root = PathBuf::from(source_root);
+        let out_root = PathBuf::from(out_root);
+
+        Ok(Self {
+            source_root,
+            out_root,
+            ts_config,
+            ignore_patterns: vec![".test.ts".to_string(), ".spec.ts".to_string()],
+        })
+    }
+
+    /// Return the `source_root` as a UTF-8 lossily converted `String`.
+    pub fn source_root_str(&self) -> String {
+        self.source_root.to_string_lossy().to_string()
+    }
+
+    /// Return the `out_root` as a UTF-8 lossily converted `String`.
+    pub fn output_path_str(&self) -> String {
+        self.out_root.to_string_lossy().to_string()
+    }
+
+    /// Compute the output path for a given input relative path.
+    ///
+    /// The function appends `input_relative` to the `out_root` and changes
+    /// the extension to `.js` (e.g. `src/users/route.ts` ->
+    /// `<out_root>/src/users/route.js`).
+    pub fn compute_output_path(&self, input_relative: &str) -> PathBuf {
+        let mut out_path = self.out_root.clone();
+        out_path.push(input_relative);
+        out_path.set_extension("js");
+        out_path
+    }
+}

package/src/builder/mod.rs

@@ -0,0 +1,126 @@
+//! Native builder entrypoints and orchestration.
+//!
+//! This module exposes the `build_project` function which is invoked from the
+//! host (Node) via N-API. It wires together scanning, compilation and route
+//! manifest generation using the Rust-based SWC compiler integration.
+//!
+//! Exposes the native `build_project` entrypoint used by the host.
+
+use napi_derive::napi;
+use rayon::prelude::*;
+use std::{fs, time::Instant};
+
+pub mod compiler;
+pub mod config;
+pub mod sourcemap;
+pub mod tsconfig;
+pub mod types;
+
+#[cfg(test)]
+mod tests;
+
+use compiler::TypeScriptCompiler;
+use config::BuildConfig;
+use types::{BuildResult, CompileResult};
+
+#[napi]
+/// Build the project located at `source_root` and emit outputs to `out_root`.
+///
+/// This function is exported to the host via N-API and performs the full
+/// native compilation pipeline:
+/// 1. Reads build configuration from `source_root`.
+/// 2. Scans for TypeScript files matching `.ts`.
+/// 3. Compiles files (in parallel) using the embedded SWC-based compiler.
+/// 4. Aggregates compilation results and fails the build if there are errors.
+/// 5. If route files exist in the output, produces a `routes.json` manifest
+///    containing route metadata consumed by the runtime.
+///
+/// Errors are returned as `napi::Error` to be propagated to the host.
+/// High-level build entrypoint for the native TypeScript builder.
+///
+/// `build_project` coordinates scanning the source tree, applying route
+/// conventions, and producing a `RoutesManifest` that can be consumed by the
+/// runtime. Currently this function is a thin wrapper and may be expanded to
+/// run parallel compilation and emit artifacts to disk.
+pub fn build_project(source_root: String, out_root: String) -> napi::Result<()> {
+    let start = Instant::now();
+
+    // Load configuration
+    let config =
+        BuildConfig::new(source_root, out_root).map_err(napi::Error::from_reason)?;
+
+    fs::remove_dir_all(&config.out_root).ok();
+
+    // Scan TypeScript files using glob patterns
+    use crate::scanner::FileScanner;
+    let ts_files = crate::scanner::NativeFileScanner::new()
+        .scan_dir(
+            &[config.source_root_str()],
+            Some(crate::scanner::ScanOptions {
+                include: Some(vec!["**/*.ts".to_string()]),
+                ignore: Some(config.ignore_patterns.clone()),
+            }),
+        )
+        .map_err(|e| napi::Error::from_reason(format!("scan failed: {}", e)))?;
+
+    // Compile files in parallel
+    let compiler = TypeScriptCompiler::new(config.ts_config.clone());
+
+    let results: Vec<Result<CompileResult, String>> = ts_files
+        .par_iter()
+        .map(|file| {
+            let output_path = config.compute_output_path(&file.path);
+
+            if let Some(parent) = output_path.parent() {
+                std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+            }
+
+            let file_start = Instant::now();
+            compiler
+                .compile_file(std::path::Path::new(&file.full_path), &output_path)
+                .map(|_| CompileResult {
+                    output_path: output_path.to_string_lossy().to_string(),
+                    duration_ms: file_start.elapsed().as_secs_f64() * 1000.0,
+                })
+        })
+        .collect();
+
+    // Aggregate results
+    let mut build_result = BuildResult::new(start.elapsed().as_secs_f64() * 1000.0);
+    build_result.files_compiled = ts_files.len();
+
+    for result in results {
+        match result {
+            Ok(timing) => build_result.timings.push(timing),
+            Err(e) => build_result.failures.push(e),
+        }
+    }
+
+    // Build summary is emitted to the host (Node) via the native API; avoid printing here.
+
+    if build_result.has_failures() {
+        let failures_msg = build_result
+            .failures
+            .iter()
+            .take(5)
+            .map(|e| e.as_str())
+            .collect::<Vec<_>>()
+            .join("\n\n");
+
+        return Err(napi::Error::from_reason(format!(
+            "Build completed with {} failures:\n\n{}",
+            build_result.failures.len(),
+            failures_msg
+        )));
+    }
+
+    build_result.total_duration_ms = start.elapsed().as_secs_f64() * 1000.0;
+
+    // Generate routes manifest using helper
+    crate::router::write_routes_manifest(&config).map_err(napi::Error::from_reason)?;
+
+    // Events manifest: build from already-scanned `ts_files` (no extra scan)
+    crate::events::write_events_manifest(&config).map_err(napi::Error::from_reason)?;
+
+    Ok(())
+}