@ugo-studio/jspp 0.3.1 → 0.3.2

package/dist/{core → interpreter/core}/codegen/helpers.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
-import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols, } from "../../ast/symbols.js";
 import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 /**
@@ -250,7 +250,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                         : ts.isEnumDeclaration(decl)
                             ? DeclarationType.enum
                             : DeclarationType.var;
-    const hoistName = (nameNode) => {
+    const hoistName = (nameNode, isFromDestructuring = false) => {
         if (ts.isIdentifier(nameNode)) {
             const name = nameNode.text;
             if (hoistedSymbols.has(name)) {
@@ -269,6 +269,10 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             }
             else {
                 // Add the symbol to the hoisted symbols
+                hoistedSymbols.add(name, {
+                    type: declType,
+                });
+                // Get and update symbol features
                 if (ts.isFunctionDeclaration(decl) ||
                     (ts.isVariableDeclaration(decl) && decl.initializer &&
                         nameNode === decl.name &&
@@ -278,22 +282,23 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                     const funcExpr = ts.isVariableDeclaration(decl)
                         ? decl.initializer
                         : decl;
-                    const isAsync = this.isAsyncFunction(funcExpr);
-                    const isGenerator = this.isGeneratorFunction(funcExpr);
-                    hoistedSymbols.add(name, {
-                        type: declType,
-                        features: { isAsync, isGenerator },
+                    // Update features
+                    hoistedSymbols.update(name, {
+                        features: {
+                            isAsync: this.isAsyncFunction(funcExpr),
+                            isGenerator: this.isGeneratorFunction(funcExpr),
+                        },
                     });
                     // Don't hoist declarations not used as a variable
                     // They will be called with their native lambda/value
                     if (!this.isDeclarationUsedAsValue(decl, scopeNode) &&
                         !this.isDeclarationUsedBeforeInitialization(name, scopeNode)) {
+                        hoistedSymbols.update(name, {
+                            checks: { skippedHoisting: true },
+                        });
                         return "";
                     }
                 }
-                else {
-                    hoistedSymbols.add(name, { type: declType });
-                }
             }
             const scope = this.getScopeForNode(decl);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
@@ -304,6 +309,13 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                 return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
             }
             else {
+                if ((isLet || isConst) &&
+                    !this.isDeclarationUsedBeforeInitialization(name, scopeNode) && !isFromDestructuring) {
+                    hoistedSymbols.update(name, {
+                        checks: { skippedHoisting: true },
+                    });
+                    return "";
+                }
                 return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
             }
         }
@@ -311,7 +323,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             let code = "";
             nameNode.elements.forEach((element) => {
                 if (ts.isBindingElement(element)) {
-                    code += hoistName(element.name);
+                    code += hoistName(element.name, true);
                 }
             });
             return code;
@@ -715,6 +727,33 @@ export function isVariableUsedWithoutDeclaration(name, root) {
     visit(root);
     return isUsedIllegally;
 }
+/**
+ * Checks if a node (usually a SourceFile) contains any top-level await expressions.
+ * This determines if the module function should be a coroutine.
+ */
+export function needsTopLevelAwait(node) {
+    let found = false;
+    const visitor = (n) => {
+        if (found)
+            return;
+        if (ts.isAwaitExpression(n)) {
+            found = true;
+            return;
+        }
+        if (ts.isForOfStatement(n) && n.awaitModifier) {
+            found = true;
+            return;
+        }
+        // Nested functions/classes have their own context
+        if (ts.isFunctionLike(n) || ts.isClassLike(n) ||
+            ts.isModuleDeclaration(n)) {
+            return;
+        }
+        ts.forEachChild(n, visitor);
+    };
+    ts.forEachChild(node, visitor);
+    return found;
+}
 /**
  * Validates and filters function parameters, checking for illegal "this"
  * and correctly positioned rest parameters.
@@ -744,3 +783,32 @@ export function validateFunctionParams(parameters) {
         return p;
     }) || [];
 }
+/**
+ * Traverses the AST upwards from the given node to find the nearest enclosing
+ * `FunctionDeclaration` node that contains a `ReturnStatement` ancestor.
+ *
+ * This function is useful for determining the function context in which a return
+ * statement appears. It starts from the provided node and walks up the parent
+ * chain, tracking whether a return statement has been encountered. Once a
+ * function declaration is found after encountering a return statement, it is returned.
+ *
+ * @param node - The starting TypeScript AST node.
+ * @returns The enclosing `ts.FunctionDeclaration` node if found, otherwise `undefined`.
+ */
+export function findEnclosingFunctionDeclarationFromReturnStatement(node) {
+    let current = node;
+    let foundReturn = false;
+    while (current) {
+        if (ts.isFunctionDeclaration(current)) {
+            if (foundReturn) {
+                return current;
+            }
+            break;
+        }
+        if (ts.isReturnStatement(current)) {
+            foundReturn = true;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}

package/dist/interpreter/core/codegen/index.js

@@ -0,0 +1,156 @@
+import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { generateDestructuring } from "./destructuring-handlers.js";
+import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
+import { escapeString, findEnclosingFunctionDeclarationFromReturnStatement, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, isVariableUsedWithoutDeclaration, markSymbolAsInitialized, needsTopLevelAwait, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { visit } from "./visitor.js";
+export class CodeGenerator {
+    indentationLevel = 0;
+    typeAnalyzer;
+    isTypescript = false;
+    moduleFunctionName;
+    globalThisVar;
+    uniqueNameCounter = 0;
+    isWasm = false;
+    wasmExports = [];
+    // visitor
+    visit = visit;
+    // helpers
+    getDeclaredSymbols = getDeclaredSymbols;
+    generateUniqueName = generateUniqueName;
+    generateUniqueExceptionName = generateUniqueExceptionName;
+    hoistDeclaration = hoistDeclaration;
+    getScopeForNode = getScopeForNode;
+    indent = indent;
+    escapeString = escapeString;
+    getJsVarName = getJsVarName;
+    getDerefCode = getDerefCode;
+    getReturnCommand = getReturnCommand;
+    isBuiltinObject = isBuiltinObject;
+    isGeneratorFunction = isGeneratorFunction;
+    isAsyncFunction = isAsyncFunction;
+    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
+    markSymbolAsInitialized = markSymbolAsInitialized;
+    isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
+    isDeclarationUsedAsValue = isDeclarationUsedAsValue;
+    isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
+    isVariableUsedWithoutDeclaration = isVariableUsedWithoutDeclaration;
+    validateFunctionParams = validateFunctionParams;
+    generateDestructuring = generateDestructuring;
+    findEnclosingFunctionDeclarationFromReturnStatement = findEnclosingFunctionDeclarationFromReturnStatement;
+    // function handlers
+    generateLambdaComponents = generateLambdaComponents;
+    generateNativeLambda = generateNativeLambda;
+    generateWrappedLambda = generateWrappedLambda;
+    /**
+     * Main entry point for the code generation process.
+     */
+    generate(ast, analyzer, isTypescript, isWasm = false) {
+        this.typeAnalyzer = analyzer;
+        this.isTypescript = isTypescript;
+        this.isWasm = isWasm;
+        this.wasmExports = [];
+        this.moduleFunctionName = this.generateUniqueName("__module_entry_point_", this.getDeclaredSymbols(ast));
+        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
+        const isAsyncModule = needsTopLevelAwait(ast);
+        const moduleReturnType = isAsyncModule
+            ? "jspp::JsPromise"
+            : "jspp::AnyValue";
+        const moduleReturnCommand = isAsyncModule ? "co_return" : "return";
+        let declarations = `#include "jspp.hpp"\n#include "library/global_usings.hpp"\n`;
+        if (isWasm) {
+            declarations += `#include <emscripten.h>\n`;
+        }
+        declarations += `\n`;
+        // module function code
+        let moduleCode = `${moduleReturnType} ${this.moduleFunctionName}() {\n`;
+        this.indentationLevel++;
+        moduleCode +=
+            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
+        const context = {
+            currentScopeNode: ast,
+            isMainContext: true,
+            isInsideFunction: true,
+            isFunctionBody: true,
+            isInsideAsyncFunction: isAsyncModule,
+            globalScopeSymbols: new DeclaredSymbols(),
+            localScopeSymbols: new DeclaredSymbols(),
+        };
+        const generatedBody = this.visit(ast, context);
+        moduleCode += generatedBody;
+        moduleCode +=
+            `${this.indent()}${moduleReturnCommand} jspp::Constants::UNDEFINED;\n`;
+        this.indentationLevel--;
+        moduleCode += "}\n\n";
+        // Wasm Exports
+        let wasmGlobalPointers = "";
+        let wasmWrappers = "";
+        if (isWasm) {
+            for (const exp of this.wasmExports) {
+                const paramTypes = exp.params.map((_, i) => `jspp::AnyValue`);
+                const paramList = paramTypes.length > 0
+                    ? `, ${paramTypes.join(", ")}`
+                    : "";
+                const pointerName = `__wasm_export_ptr_${exp.jsName}`;
+                wasmGlobalPointers +=
+                    `std::function<jspp::AnyValue(jspp::AnyValue${paramList})> ${pointerName} = nullptr;\n`;
+                const wrapperParamList = exp.params.map((_, i) => `double p${i}`).join(", ");
+                const callArgsList = exp.params.map((_, i) => `jspp::AnyValue::make_number(p${i})`);
+                const callArgs = callArgsList.length > 0
+                    ? `, ${callArgsList.join(", ")}`
+                    : "";
+                wasmWrappers += `extern "C" EMSCRIPTEN_KEEPALIVE\n`;
+                wasmWrappers +=
+                    `double wasm_export_${exp.jsName}(${wrapperParamList}) {\n`;
+                wasmWrappers += `    if (!${pointerName}) return 0;\n`;
+                wasmWrappers +=
+                    `    auto res = ${pointerName}(global${callArgs});\n`;
+                wasmWrappers +=
+                    `    return jspp::Operators_Private::ToNumber(res);\n`;
+                wasmWrappers += `}\n\n`;
+            }
+        }
+        // main function code
+        let mainCode = "int main(int argc, char** argv) {\n";
+        this.indentationLevel++;
+        mainCode += `${this.indent()}try {\n`;
+        this.indentationLevel++;
+        mainCode += `${this.indent()}jspp::initialize_runtime();\n`;
+        mainCode += `${this.indent()}jspp::setup_process_argv(argc, argv);\n`;
+        if (isAsyncModule) {
+            mainCode +=
+                `${this.indent()}auto p = ${this.moduleFunctionName}();\n`;
+            mainCode +=
+                `${this.indent()}p.then(nullptr, [](jspp::AnyValue err) {\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(err);\n`;
+            this.indentationLevel++;
+            mainCode +=
+                `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+            mainCode += `${this.indent()}std::exit(1);\n`;
+            this.indentationLevel--;
+            mainCode += `${this.indent()}});\n`;
+        }
+        else {
+            mainCode += `${this.indent()}${this.moduleFunctionName}();\n`;
+        }
+        mainCode += `${this.indent()}jspp::Scheduler::instance().run();\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}} catch (const std::exception& ex) {\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n`;
+        this.indentationLevel++;
+        mainCode +=
+            `${this.indent()}console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `${this.indent()}return 1;\n`;
+        this.indentationLevel--;
+        mainCode += `${this.indent()}}\n`;
+        mainCode += `${this.indent()}return 0;\n`;
+        this.indentationLevel--;
+        mainCode += `}`;
+        return declarations + wasmGlobalPointers + wasmWrappers + moduleCode +
+            mainCode;
+    }
+}

package/dist/{core → interpreter/core}/codegen/literal-handlers.js

@@ -11,6 +11,15 @@ export function visitIdentifier(node) {
     return node.text;
 }
 export function visitNumericLiteral(node) {
+    const getOuterExpr = (n) => !ts.isParenthesizedExpression(n) &&
+        n.kind !== ts.SyntaxKind.FirstLiteralToken
+        ? n
+        : getOuterExpr(n.parent);
+    const outerExpr = getOuterExpr(node);
+    if (!ts.isPropertyAccessExpression(outerExpr) &&
+        !ts.isElementAccessExpression(outerExpr)) {
+        return this.escapeString(node.text);
+    }
     if (node.text === "0" || (node.text.startsWith("0.") &&
         !node.text.substring(2).split("").some((c) => c !== "0")))
         return "jspp::Constants::ZERO";

package/dist/{core → interpreter/core}/codegen/statement-handlers.js

@@ -52,6 +52,21 @@ export function visitSourceFile(node, context) {
         // Mark before further visits
         this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
+        // Check for @export comment
+        let exported = false;
+        if (this.isWasm) {
+            const fullText = sourceFile.text;
+            const commentRanges = ts.getLeadingCommentRanges(fullText, stmt.pos);
+            if (commentRanges) {
+                for (const range of commentRanges) {
+                    const comment = fullText.substring(range.pos, range.end);
+                    if (comment.includes("@export")) {
+                        exported = true;
+                        break;
+                    }
+                }
+            }
+        }
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
         const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
@@ -72,9 +87,18 @@ export function visitSourceFile(node, context) {
             noTypeSignature: true,
         });
         // Generate native lambda
-        if (this.isDeclarationCalledAsFunction(stmt, node)) {
+        if (this.isDeclarationCalledAsFunction(stmt, node) || exported) {
             const nativeLambda = this.generateNativeLambda(lambdaComps);
             code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+            if (exported) {
+                this.wasmExports.push({
+                    jsName: funcName,
+                    nativeName,
+                    params: Array.from(stmt.parameters),
+                });
+                code +=
+                    `${this.indent()}__wasm_export_ptr_${funcName} = ${nativeName};\n`;
+            }
         }
         // Generate AnyValue wrapped lamda
         if (this.isDeclarationUsedAsValue(stmt, node) ||
@@ -799,6 +823,20 @@ export function visitReturnStatement(node, context) {
                 !typeInfo.isBuiltin) {
                 finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
             }
+            const exprReturnType = this.typeAnalyzer.inferNodeReturnType(expr);
+            if (exprReturnType === "number" &&
+                context.isInsideNativeLambda &&
+                context.isInsideFunction) {
+                const funcDecl = this
+                    .findEnclosingFunctionDeclarationFromReturnStatement(expr);
+                if (funcDecl) {
+                    const funcReturnType = this.typeAnalyzer
+                        .inferFunctionReturnType(funcDecl);
+                    if (funcReturnType === "number") {
+                        finalExpr = `${finalExpr}.as_double()`;
+                    }
+                }
+            }
         }
         return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,14 +14,16 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/precompile-headers.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/setup-emsdk.ts && bun run scripts/precompile-headers.ts",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
-    "precompile": "bun run scripts/precompile-headers.ts",
     "test": "bun test",
     "build": "tsc",
     "prepack": "bun run build",
-    "publish:npm": "npm publish --access=public"
+    "publish:npm": "npm publish --access=public",
+    "script:setup-compiler": "bun run scripts/setup-compiler.ts",
+    "script:setup-emsdk": "bun run scripts/setup-emsdk.ts",
+    "script:precompile-headers": "bun run scripts/precompile-headers.ts"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/scripts/precompile-headers.ts

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 
@@ -87,10 +87,23 @@ const MODES = [
     {
         name: "debug",
         flags: ["-Og"],
+        linkerFlags: [],
+        compiler: "g++",
+        archiver: "ar",
     },
     {
         name: "release",
         flags: ["-O3", "-DNDEBUG"],
+        linkerFlags: [],
+        compiler: "g++",
+        archiver: "ar",
+    },
+    {
+        name: "wasm",
+        flags: ["-O3", "-DNDEBUG"],
+        linkerFlags: ["-sASYNCIFY", "-sALLOW_MEMORY_GROWTH=1"],
+        compiler: "em++",
+        archiver: "emar",
     },
 ];
 
@@ -133,18 +146,32 @@ async function findCppFiles(dir: string): Promise<string[]> {
 }
 
 async function runCommand(cmd: string, args: string[]): Promise<boolean> {
+    // console.log(`${COLORS.dim}> ${cmd} ${args.join(" ")}${COLORS.reset}`);
     return new Promise((resolve) => {
-        const proc = spawn(cmd, args, { stdio: "ignore" });
+        const proc = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
         proc.on("close", (code) => resolve(code === 0));
     });
 }
 
 async function precompileHeaders() {
-    console.log(
-        `${COLORS.bold}${COLORS.cyan}JSPP: Precompiling headers and runtime...${COLORS.reset}\n`,
-    );
-
     const force = process.argv.includes("--force");
+    const jsppCliIsParent = process.argv.includes("--jspp-cli-is-parent");
+    const silent = process.argv.includes("--silent");
+
+    const modeArgIdx = process.argv.indexOf("--mode");
+    const targetMode = modeArgIdx !== -1
+        ? process.argv[modeArgIdx + 1]
+        : undefined;
+
+    if (!jsppCliIsParent && !silent) {
+        console.log(
+            `${COLORS.bold}${COLORS.cyan}JSPP: Precompiling headers and runtime...${COLORS.reset}\n`,
+        );
+    }
+
     try {
         await fs.mkdir(PRECOMPILED_HEADER_BASE_DIR, { recursive: true });
 
@@ -154,13 +181,15 @@ async function precompileHeaders() {
         );
 
         for (const mode of MODES) {
+            if (targetMode && mode.name !== targetMode) continue;
+
             const modeDir = path.join(PRECOMPILED_HEADER_BASE_DIR, mode.name);
             const headerPath = path.join(modeDir, "jspp.hpp");
             const gchPath = path.join(modeDir, "jspp.hpp.gch");
 
             const modeLabel = `[${mode.name.toUpperCase()}]`;
             const spinner = new Spinner(`${modeLabel} Checking headers...`);
-            spinner.start();
+            if (!silent) spinner.start();
 
             await fs.mkdir(modeDir, { recursive: true });
 
@@ -179,6 +208,7 @@ async function precompileHeaders() {
             }
 
             if (shouldBuildGch) {
+                if (silent) spinner.start();
                 spinner.update(`${modeLabel} Compiling header...`);
                 await fs.copyFile(
                     path.join(PRELUDE_DIR, "jspp.hpp"),
@@ -186,7 +216,7 @@ async function precompileHeaders() {
                 );
 
                 const tempGchPath = `${gchPath}.tmp`;
-                const success = await runCommand("g++", [
+                const success = await runCommand(mode.compiler, [
                     "-x",
                     "c++-header",
                     "-std=c++23",
@@ -209,7 +239,9 @@ async function precompileHeaders() {
                 gchRebuilt = true;
                 spinner.succeed(`${modeLabel} PCH Success.`);
             } else {
-                spinner.succeed(`${modeLabel} Headers are up-to-date.`);
+                if (!silent) {
+                    spinner.succeed(`${modeLabel} Headers are up-to-date.`);
+                }
             }
 
             // --- Incremental Compilation of .cpp files ---
@@ -217,12 +249,16 @@ async function precompileHeaders() {
             const objFiles: string[] = [];
             let anyObjRebuilt = false;
 
-            const gchMtime = (await fs.stat(gchPath)).mtimeMs;
+            // We need gchPath to exist for next check, if it doesn't we probably have a problem or it's a first run
+            let gchMtime = 0;
+            try {
+                gchMtime = (await fs.stat(gchPath)).mtimeMs;
+            } catch (e) {}
 
             const libSpinner = new Spinner(
                 `${modeLabel} Checking runtime library...`,
             );
-            libSpinner.start();
+            if (!silent) libSpinner.start();
 
             for (let idx = 0; idx < cppFiles.length; idx++) {
                 const cppFile = cppFiles[idx];
@@ -251,12 +287,13 @@ async function precompileHeaders() {
                 }
 
                 if (shouldCompile) {
+                    if (silent && !libSpinner["interval"]) libSpinner.start();
                     libSpinner.update(
                         `${modeLabel} Compiling ${relativePath} ${COLORS.dim}[${
                             idx + 1
                         }/${cppFiles.length}]${COLORS.reset}`,
                     );
-                    const success = await runCommand("g++", [
+                    const success = await runCommand(mode.compiler, [
                         "-c",
                         "-std=c++23",
                         ...mode.flags,
@@ -290,10 +327,11 @@ async function precompileHeaders() {
             }
 
             if (shouldArchive) {
+                if (silent && !libSpinner["interval"]) libSpinner.start();
                 libSpinner.update(`${modeLabel} Updating runtime library...`);
                 const tempLibPath = `${libPath}.tmp`;
 
-                const success = await runCommand("ar", [
+                const success = await runCommand(mode.archiver, [
                     "rcs",
                     tempLibPath,
                     ...objFiles,
@@ -309,14 +347,20 @@ async function precompileHeaders() {
                 await fs.rename(tempLibPath, libPath);
                 libSpinner.succeed(`${modeLabel} Runtime Library Success.`);
             } else {
-                libSpinner.succeed(
-                    `${modeLabel} Runtime library is up-to-date.`,
-                );
+                if (!silent) {
+                    libSpinner.succeed(
+                        `${modeLabel} Runtime library is up-to-date.`,
+                    );
+                } else {
+                    libSpinner.stop();
+                }
             }
         }
-        console.log(
-            `\n${COLORS.bold}${COLORS.green}JSPP: Environment ready.${COLORS.reset}\n`,
-        );
+        if (!jsppCliIsParent && !silent) {
+            console.log(
+                `\n${COLORS.bold}${COLORS.green}JSPP: Environment ready.${COLORS.reset}\n`,
+            );
+        }
     } catch (error: any) {
         console.error(`${COLORS.red}Error: ${error.message}${COLORS.reset}`);
         process.exit(1);