zshy 0.0.6 → 0.0.7

package/{out → dist}/index.js

@@ -5,7 +5,7 @@ import parseArgs from "arg";
 import { globby } from "globby";
 import { table } from "table";
 import * as ts from "typescript";
-import { compileProject, formatForLog, getEntryPoints, readTsconfig } from "./utils.js";
+import { compileProject, emojiLog, formatForLog, getEntryPoints, readTsconfig } from "./utils.js";
 function isSourceFile(filePath) {
     return (filePath.endsWith(".ts") || filePath.endsWith(".mts") || filePath.endsWith(".cts") || filePath.endsWith(".tsx"));
 }
@@ -24,6 +24,7 @@ async function main() {
             "--verbose": Boolean,
             "--project": String,
             "--dry-run": Boolean,
+            // "--attw": Boolean,
             // Aliases
             "-h": "--help",
             "-p": "--project",
@@ -31,7 +32,7 @@ async function main() {
     }
     catch (error) {
         if (error instanceof Error) {
-            console.error(`❌ ${error.message}`);
+            emojiLog("❌", error.message, "error");
         }
         console.error(`Use --help for usage information`);
         process.exit(1);
@@ -55,14 +56,27 @@ Examples:
 		`);
         process.exit(0);
     }
-    console.log("💎 Starting zshy build...");
+    const userAgent = process.env.npm_config_user_agent;
+    let pmExec;
+    if (userAgent?.startsWith("pnpm")) {
+        pmExec = "pnpm exec";
+    }
+    else if (userAgent?.startsWith("yarn")) {
+        pmExec = "yarn exec";
+    }
+    else {
+        pmExec = "npx";
+    }
+    emojiLog("💎", "Starting build... 🐒");
     const isVerbose = args["--verbose"];
     const isDryRun = args["--dry-run"];
+    const isAttw = false; // args["--attw"];
     if (isVerbose) {
-        console.log("🗣️  Verbose mode enabled");
+        emojiLog("ℹ️", "Verbose mode enabled");
+        emojiLog("📦", `Detected package manager: ${pmExec}`);
     }
     if (isDryRun) {
-        console.log("🔍 Dry run mode enabled - no files will be written");
+        emojiLog("🔍", "Dry run mode enabled - no files will be written");
     }
     ///////////////////////////////////
     ///    find and read pkg json   ///
@@ -79,7 +93,7 @@ Examples:
         currentDir = path.dirname(currentDir);
     }
     if (!fs.existsSync(packageJsonPath)) {
-        console.error("❌ package.json not found in current directory or any parent directories");
+        emojiLog("❌", "package.json not found in current directory or any parent directories", "error");
         process.exit(1);
     }
     // read package.json and extract the "zshy" exports config
@@ -87,8 +101,8 @@ Examples:
     const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
     const pkgJsonDir = path.dirname(packageJsonPath);
     // print project root
-    console.log(`⚙️  Detected project root: ${pkgJsonDir}`);
-    console.log(`📦 Reading package.json from ./${path.relative(pkgJsonDir, packageJsonPath)}`);
+    emojiLog("⚙️", `Detected project root: ${pkgJsonDir}`);
+    emojiLog("📦", `Reading package.json from ./${path.relative(pkgJsonDir, packageJsonPath)}`);
     /////////////////////////////////
     ///    parse zshy config      ///
     /////////////////////////////////
@@ -96,7 +110,7 @@ Examples:
     const CONFIG_KEY = "zshy";
     let config;
     if (!pkgJson[CONFIG_KEY]) {
-        console.error(`❌ No "${CONFIG_KEY}" key found in package.json`);
+        emojiLog("❌", `No "${CONFIG_KEY}" key found in package.json`, "error");
         process.exit(1);
     }
     if (typeof pkgJson[CONFIG_KEY] === "string") {
@@ -110,11 +124,11 @@ Examples:
             config.exports = { ".": config.exports };
         }
         else if (typeof config.exports === "undefined") {
-            console.error(`❌ Missing "exports" key in package.json#/${CONFIG_KEY}`);
+            emojiLog("❌", `Missing "exports" key in package.json#/${CONFIG_KEY}`, "error");
             process.exit(1);
         }
         else if (typeof config.exports !== "object") {
-            console.error(`❌ Invalid "exports" key in package.json#/${CONFIG_KEY}`);
+            emojiLog("❌", `Invalid "exports" key in package.json#/${CONFIG_KEY}`, "error");
             process.exit(1);
         }
         // Validate bin field if present
@@ -126,7 +140,7 @@ Examples:
                 // Object format is valid
             }
             else {
-                console.error(`❌ Invalid "bin" key in package.json#/${CONFIG_KEY}, expected string or object`);
+                emojiLog("❌", `Invalid "bin" key in package.json#/${CONFIG_KEY}, expected string or object`, "error");
                 process.exit(1);
             }
         }
@@ -135,15 +149,15 @@ Examples:
         // };
     }
     else if (typeof pkgJson[CONFIG_KEY] === "undefined") {
-        console.error(`❌ Missing "${CONFIG_KEY}" key in package.json`);
+        emojiLog("❌", `Missing "${CONFIG_KEY}" key in package.json`, "error");
         process.exit(1);
     }
     else {
-        console.error(`❌ Invalid "${CONFIG_KEY}" key in package.json, expected string or object`);
+        emojiLog("❌", `Invalid "${CONFIG_KEY}" key in package.json, expected string or object`, "error");
         process.exit(1);
     }
     if (isVerbose) {
-        console.log("🔧 Parsed zshy config:", formatForLog(config));
+        emojiLog("🔧", `Parsed zshy config: ${formatForLog(config)}`);
     }
     ///////////////////////////
     ///    read tsconfig    ///
@@ -155,7 +169,7 @@ Examples:
         const resolvedProjectPath = path.resolve(process.cwd(), args["--project"]);
         if (fs.existsSync(resolvedProjectPath)) {
             if (fs.statSync(resolvedProjectPath).isDirectory()) {
-                console.error(`❌ --project must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`);
+                emojiLog("❌", `--project must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`, "error");
                 process.exit(1);
             }
             else {
@@ -164,7 +178,7 @@ Examples:
             }
         }
         else {
-            console.error(`❌ tsconfig.json file not found: ${resolvedProjectPath}`);
+            emojiLog("❌", `tsconfig.json file not found: ${resolvedProjectPath}`, "error");
             process.exit(1);
         }
     }
@@ -173,7 +187,7 @@ Examples:
         const resolvedProjectPath = path.resolve(pkgJsonDir, config.tsconfig);
         if (fs.existsSync(resolvedProjectPath)) {
             if (fs.statSync(resolvedProjectPath).isDirectory()) {
-                console.error(`❌ zshy.tsconfig must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`);
+                emojiLog("❌", `zshy.tsconfig must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`, "error");
                 process.exit(1);
             }
             else {
@@ -182,7 +196,7 @@ Examples:
             }
         }
         else {
-            console.error(`❌ Tsconfig file not found: ${resolvedProjectPath}`);
+            emojiLog("❌", `Tsconfig file not found: ${resolvedProjectPath}`, "error");
             process.exit(1);
         }
     }
@@ -193,10 +207,10 @@ Examples:
     const _parsedConfig = readTsconfig(tsconfigPath);
     if (!fs.existsSync(tsconfigPath)) {
         // Check if tsconfig.json exists
-        console.error(`❌ tsconfig.json not found at ${path.resolve(tsconfigPath)}`);
+        emojiLog("❌", `tsconfig.json not found at ${path.resolve(tsconfigPath)}`, "error");
         process.exit(1);
     }
-    console.log(`📁 Reading tsconfig from ./${path.relative(pkgJsonDir, tsconfigPath)}`);
+    emojiLog("📁", `Reading tsconfig from ./${path.relative(pkgJsonDir, tsconfigPath)}`);
     // if (_parsedConfig.rootDir) {
     // 	console.error(
     // 		`❌ rootDir is determined from your set of entrypoints; you can remove it from your tsconfig.json.`,
@@ -217,31 +231,31 @@ Examples:
     const relDeclarationDir = path.relative(pkgJsonDir, declarationDir);
     // clean up outDir and declarationDir
     if (relOutDir !== "") {
-        console.log(`🗑️  Cleaning up outDir...`);
+        emojiLog("🗑️", `Cleaning up outDir...`);
         fs.rmSync(outDir, { recursive: true, force: true });
         // // print success mesage in verbose mode
         if (isVerbose) {
             if (fs.existsSync(outDir)) {
-                console.error(`❌ Failed to clean up outDir: ${relOutDir}. Directory still exists.`);
+                emojiLog("❌", `Failed to clean up outDir: ${relOutDir}. Directory still exists.`, "error");
             }
         }
     }
     else {
-        console.log(`🗑️  Skipping cleanup of outDir as it contains source files`);
+        emojiLog("🗑️", `Skipping cleanup of outDir as it contains source files`);
     }
     if (relDeclarationDir !== relOutDir && relDeclarationDir !== "") {
-        console.log(`🗑️  Cleaning up declarationDir...`);
+        emojiLog("🗑️", `Cleaning up declarationDir...`);
         fs.rmSync(declarationDir, { recursive: true, force: true });
         // // print success mesage in verbose mode
         if (isVerbose) {
             if (fs.existsSync(declarationDir)) {
-                console.error(`❌ Failed to clean up declarationDir: ${relDeclarationDir}. Directory still exists.`);
+                emojiLog("❌", `Failed to clean up declarationDir: ${relDeclarationDir}. Directory still exists.`, "error");
             }
         }
     }
     else {
         if (isVerbose)
-            console.log(`🗑️  Skipping cleanup of declarationDir as it contains source files`);
+            emojiLog("🗑️", `Skipping cleanup of declarationDir as it contains source files`);
     }
     const tsconfigJson = {
         ..._parsedConfig,
@@ -256,11 +270,11 @@ Examples:
     };
     if (relOutDir === "") {
         if (!pkgJson.files) {
-            console.log('⚠️  You\'re building your code to the project root. This means your compiled files will be generated alongside your source files.\n   ➜ Setting "files" in package.json to exclude TypeScript source from the published package.');
+            emojiLog("⚠️", 'You\'re building your code to the project root. This means your compiled files will be generated alongside your source files.\n   ➜ Setting "files" in package.json to exclude TypeScript source from the published package.');
             pkgJson.files = ["**/*.js", "**/*.mjs", "**/*.cjs", "**/*.d.ts", "**/*.d.mts", "**/*.d.cts"];
         }
         else {
-            console.warn(`⚠️  You're building your code to the project root. This means your compiled files will be generated alongside your source files.
+            console.warn(`⚠️  You\'re building your code to the project root. This means your compiled files will be generated alongside your source files.
    ➜ Ensure that your "files" in package.json excludes TypeScript source files, or your users may experience .d.ts resolution issues in some environments:
 
    "files": ["**/*.js", "**/*.mjs", "**/*.cjs", "**/*.d.ts", "**/*.d.mts", "**/*.d.cts"],
@@ -269,7 +283,7 @@ Examples:
     }
     else {
         if (!pkgJson.files) {
-            console.log(`⚠️  The "files" key is missing in package.json. Setting to "${relOutDir}".`);
+            emojiLog("⚠️", `The "files" key is missing in package.json. Setting to "${relOutDir}".`);
             pkgJson.files = [relOutDir];
             if (relOutDir !== relDeclarationDir) {
                 pkgJson.files.push(relDeclarationDir);
@@ -280,7 +294,7 @@ Examples:
     ///   extract entry points    ///
     /////////////////////////////////
     // Extract entry points from zshy exports config
-    console.log("➡️  Determining entrypoints...");
+    emojiLog("➡️", "Determining entrypoints...");
     const entryPatterns = [];
     const rows = [["Subpath", "Entrypoint"]];
     for (const [exportPath, sourcePath] of Object.entries(config.exports)) {
@@ -294,13 +308,13 @@ Examples:
             cleanExportPath = pkgJson.name + "/" + exportPath.slice(2);
         }
         else {
-            console.error(`⚠️  Invalid subpath export "${exportPath}" — should start with "./"`);
+            emojiLog("⚠️", `Invalid subpath export "${exportPath}" — should start with "./"`, "warn");
             process.exit(1);
         }
         if (typeof sourcePath === "string") {
             if (sourcePath.includes("*")) {
                 if (!sourcePath.endsWith("/*")) {
-                    console.error(`❌ Wildcard paths should not contain file extensions: ${sourcePath}`);
+                    emojiLog("❌", `Wildcard paths should not contain file extensions: ${sourcePath}`, "error");
                     process.exit(1);
                 }
                 const pattern = sourcePath.slice(0, -2) + "/*.{ts,tsx,mts,cts}";
@@ -356,11 +370,11 @@ Examples:
     const entryPoints = await getEntryPoints(entryPatterns);
     // disallow .mts and .cts files
     if (entryPoints.some((ep) => ep.endsWith(".mts") || ep.endsWith(".cts"))) {
-        console.error("❌ Source files with .mts or .cts extensions are not supported. Please use regular .ts files.");
+        emojiLog("❌", "Source files with .mts or .cts extensions are not supported. Please use regular .ts files.", "error");
         process.exit(1);
     }
     if (entryPoints.length === 0) {
-        console.error("❌ No entry points found matching the specified patterns in package.json#/zshy exports");
+        emojiLog("❌", "No entry points found matching the specified patterns in package.json#/zshy exports", "error");
         process.exit(1);
     }
     ///////////////////////////////
@@ -391,7 +405,7 @@ Examples:
     }
     const relRootDir = path.relative(pkgJsonDir, rootDir);
     // Display resolved paths table
-    console.log("🔧 Resolved build paths:");
+    emojiLog("🔧", "Resolved build paths:");
     const pathRows = [["Location", "Resolved path"]];
     // pathRows.push([
     // 	"package.json",
@@ -417,19 +431,29 @@ Examples:
             .trim());
     const isTypeModule = pkgJson.type === "module";
     if (isTypeModule) {
-        console.log(`🟨 Package is an ES module (package.json#/type is \"module\")`);
+        emojiLog("🟨", `Package is an ES module (package.json#/type is "module")`);
     }
     else {
-        console.log(`🐢 Package is a CommonJS module (${pkgJson.type === "commonjs" ? 'package.json#/type is "commonjs"' : 'package.json#/type not set to "module"'})`);
+        emojiLog("🐢", `Package is a CommonJS module (${pkgJson.type === "commonjs" ? 'package.json#/type is "commonjs"' : 'package.json#/type not set to "module"'})`);
     }
     ///////////////////////////////
     ///       compile tsc        ///
     ///////////////////////////////
+    const uniqueEntryPoints = [...new Set(entryPoints)];
     try {
+        if (isVerbose) {
+            emojiLog("→", `Resolved entrypoints: ${formatForLog(uniqueEntryPoints)}`);
+            emojiLog("→", `Resolved compilerOptions: ${formatForLog({
+                ...tsconfigJson,
+                module: ts.ModuleKind[tsconfigJson.module],
+                moduleResolution: ts.ModuleResolutionKind[tsconfigJson.moduleResolution],
+                target: ts.ScriptTarget[tsconfigJson.target],
+            })}`);
+        }
         // Track all written files
         const allWrittenFiles = [];
         // CJS
-        console.log(`🧱 Building CJS...${isTypeModule ? ` (rewriting .ts -> .cjs/.d.cts)` : ``}`);
+        emojiLog("🧱", `Building CJS...${isTypeModule ? ` (rewriting .ts -> .cjs/.d.cts)` : ``}`);
         const cjsFiles = await compileProject({
             configPath: tsconfigPath,
             mode: isTypeModule ? "cts" : "ts",
@@ -442,10 +466,10 @@ Examples:
                 moduleResolution: ts.ModuleResolutionKind.Node10,
                 outDir,
             },
-        }, entryPoints);
+        }, uniqueEntryPoints);
         allWrittenFiles.push(...cjsFiles);
         // ESM
-        console.log(`🧱 Building ESM...${isTypeModule ? `` : ` (rewriting .ts -> .mjs/.d.mts)`}`);
+        emojiLog("🧱", `Building ESM...${isTypeModule ? `` : ` (rewriting .ts -> .mjs/.d.mts)`}`);
         const esmFiles = await compileProject({
             configPath: tsconfigPath,
             mode: isTypeModule ? "ts" : "mts",
@@ -458,28 +482,28 @@ Examples:
                 moduleResolution: ts.ModuleResolutionKind.Bundler,
                 outDir,
             },
-        }, entryPoints);
+        }, uniqueEntryPoints);
         allWrittenFiles.push(...esmFiles);
         ///////////////////////////////////
         ///      display written files  ///
         ///////////////////////////////////
         // Display files that were written or would be written (only in verbose mode)
         if (isVerbose && allWrittenFiles.length > 0) {
-            console.log(`📜 ${isDryRun ? "[dryrun] " : ""}Writing files... (${allWrittenFiles.length} total):`);
+            emojiLog("📜", `${isDryRun ? "[dryrun] " : ""}Writing files (${allWrittenFiles.length} total)...`);
             // Sort files by relative path for consistent display
             const sortedFiles = [...allWrittenFiles]
                 .map((file) => path.relative(pkgJsonDir, file))
                 .sort()
                 .map((relPath) => (relPath.startsWith(".") ? relPath : `./${relPath}`));
             sortedFiles.forEach((file) => {
-                console.log(`   ${file}`);
+                console.log(`     ${file}`);
             });
         }
         ///////////////////////////////
         ///   generate exports      ///
         ///////////////////////////////
         // generate package.json exports
-        console.log("📦 Updating package.json#/exports...");
+        emojiLog("📦", `${isDryRun ? "[dryrun] " : ""}Updating package.json#/exports...`);
         // Generate exports based on zshy config
         const newExports = {};
         const sourceDialects = config.sourceDialects || [];
@@ -497,13 +521,6 @@ Examples:
             if (typeof sourcePath === "string") {
                 if (sourcePath.endsWith("/*")) {
                     // Handle wildcard exports
-                    // const relSourcePath =
-                    // 	"./" +
-                    // 	path.relative(
-                    // 		pkgJsonDir,
-                    // 		path.resolve(outDir, sourcePath.slice(0, -2)),
-                    // 	) +
-                    // 	"/*";
                     newExports[exportPath] = {
                         types: relDtsPath,
                         import: relJsPath,
@@ -517,7 +534,7 @@ Examples:
                     }
                 }
                 else if (isSourceFile(sourcePath)) {
-                    const esmPath = removeExtension(relJsPath) + (isTypeModule ? `.js` : `.mjs`); // ./v4/index.js or ./v4/index.mjs
+                    const esmPath = removeExtension(relJsPath) + (isTypeModule ? `.js` : `.mjs`);
                     const cjsPath = removeExtension(relJsPath) + (isTypeModule ? `.cjs` : `.js`);
                     const dtsPath = removeExtension(relDtsPath) + (isTypeModule ? `.d.cts` : `.d.ts`); // ./
                     newExports[exportPath] = {
@@ -538,17 +555,20 @@ Examples:
                     }
                 }
                 else {
-                    console.error(`❌ Invalid entrypoint: ${sourcePath}`);
+                    emojiLog("❌", `Invalid entrypoint: ${sourcePath}`, "error");
                     process.exit();
                 }
             }
         }
+        if (isVerbose) {
+            emojiLog("🔧", `Generated "exports": ${formatForLog(newExports)}`);
+        }
         ///////////////////////////////
         ///      generate bin        ///
         ///////////////////////////////
         // Generate bin field based on zshy bin config
         if (config.bin) {
-            console.log("📦 Updating package.json#/bin...");
+            emojiLog("📦", `${isDryRun ? "[dryrun] " : ""}Updating package.json#/bin...`);
             const newBin = {};
             // Convert config.bin to object format for processing
             const binEntries = typeof config.bin === "string" ? [[pkgJson.name, config.bin]] : Object.entries(config.bin);
@@ -566,49 +586,74 @@ Examples:
             // If original config.bin was a string, output as string
             if (typeof config.bin === "string") {
                 pkgJson.bin = Object.values(newBin)[0];
-                if (isVerbose) {
-                    console.log(`🗣️ Updated package.json#/bin: "${Object.values(newBin)[0]}"`);
-                }
             }
             else {
                 // Output as object
                 pkgJson.bin = newBin;
-                if (isVerbose) {
-                    console.log("🗣️  Updated package.json#/bin: " + formatForLog(newBin));
-                }
             }
         }
+        if (isVerbose) {
+            emojiLog("🔧", `Generated "bin": ${formatForLog(pkgJson.bin)}`);
+        }
         ///////////////////////////////
         ///     write pkg json      ///
         ///////////////////////////////
         // Update package.json with new exports
         pkgJson.exports = newExports;
         if (isDryRun) {
-            console.log("🔍 Skipping package.json modification (dry-run)");
+            emojiLog("📦", "[dryrun] Skipping package.json modification");
         }
         else {
             fs.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
         }
-        // console.log("✅ Updating package.json#/exports");
-        if (isVerbose) {
-            console.log(`🗣️  Updated package.json#/exports: ${formatForLog(newExports)}`);
+        if (isAttw) {
+            // run `@arethetypeswrong/cli --pack .` to check types
+            emojiLog("🔍", "Checking types with @arethetypeswrong/cli...");
+            const { execFile } = await import("node:child_process");
+            const { promisify } = await import("node:util");
+            const execFileAsync = promisify(execFile);
+            const [cmd, ...args] = `${pmExec} @arethetypeswrong/cli --pack ${pkgJsonDir}`.split(" ");
+            console.dir([cmd, ...args], { depth: null });
+            let stdout = "";
+            let stderr = "";
+            let exitCode = 0;
+            try {
+                const result = await execFileAsync(cmd, args, {
+                    cwd: pkgJsonDir,
+                    encoding: "utf-8",
+                });
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            catch (error) {
+                stdout = error.stdout || "";
+                stderr = error.stderr || "";
+                exitCode = error.code || 1;
+            }
+            const output = stdout || stderr;
+            if (output) {
+                const indentedOutput = output
+                    .split("\n")
+                    .map((line) => `   ${line}`)
+                    .join("\n");
+                if (exitCode === 0) {
+                    console.log(indentedOutput);
+                }
+                else {
+                    console.error(indentedOutput);
+                    emojiLog("⚠️", "ATTW found issues, but the build was not affected.", "warn");
+                }
+            }
         }
-        // // run `@arethetypeswrong/cli --pack .` to check types
-        // console.log("🔍 Checking types with @arethetypeswrong/cli...");
-        // const { execSync } = await import("node:child_process");
-        // execSync(`npx @arethetypeswrong/cli --pack ${pkgJsonDir}`, {
-        // 	stdio: "inherit",
-        // 	cwd: pkgJsonDir,
-        // });
-        console.log("🎉 Build complete!");
+        emojiLog("🎉", "Build complete! ✅");
     }
     catch (error) {
-        console.error("❌ Build failed:", error);
+        emojiLog("❌", `Build failed: ${error}`, "error");
         process.exit(1);
     }
 }
 // Run the script
 main().catch((error) => {
-    console.error("❌ Script failed:", error);
+    emojiLog("❌", `Script failed: ${error}`, "error");
     process.exit(1);
 });

package/{out → dist}/utils.cjs

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatForLog = formatForLog;
+exports.emojiLog = emojiLog;
 exports.getEntryPoints = getEntryPoints;
 exports.readTsconfig = readTsconfig;
 exports.compileProject = compileProject;
@@ -43,6 +44,9 @@ const ts = __importStar(require("typescript"));
 function formatForLog(data) {
     return JSON.stringify(data, null, 2).split("\n").join("\n   ");
 }
+function emojiLog(_emoji, content, level = "log") {
+    console[level]("→  " + content);
+}
 // Get entry points using the same logic as esbuild.mts
 async function getEntryPoints(patterns) {
     const results = [];
@@ -51,7 +55,7 @@ async function getEntryPoints(patterns) {
             ignore: ["**/*.d.ts"],
         });
         if (!pattern.endsWith("/*") && _results.length === 0) {
-            console.error(`❌ File does not exist: ${pattern}`);
+            emojiLog("❌", `File does not exist: ${pattern}`, "error");
             process.exit(1);
         }
         results.push(..._results);
@@ -78,7 +82,7 @@ function readTsconfig(tsconfigPath) {
         getCurrentDirectory: () => configDir,
     }, configDir);
     if (parsedConfig.errors.length > 0) {
-        console.error("❌ Error parsing tsconfig.json:");
+        emojiLog("❌", "Error parsing tsconfig.json:", "error");
         for (const error of parsedConfig.errors) {
             console.error(ts.formatDiagnostic(error, {
                 getCurrentDirectory: () => configDir,
@@ -89,13 +93,13 @@ function readTsconfig(tsconfigPath) {
         process.exit(1);
     }
     if (!parsedConfig.options) {
-        throw new Error("❌ Error reading tsconfig.json#/compilerOptions");
+        emojiLog("❌", "Error reading tsconfig.json#/compilerOptions", "error");
+        process.exit(1);
     }
     return parsedConfig.options;
 }
 async function compileProject(config, entryPoints) {
     // Deduplicate entry points before compilation
-    const uniqueEntryPoints = [...new Set(entryPoints)];
     // Track files that would be written
     const writtenFiles = [];
     // Create compiler host
@@ -119,19 +123,9 @@ async function compileProject(config, entryPoints) {
             originalWriteFile(outputFileName, processedData, writeByteOrderMark, onError, sourceFiles);
         }
     };
-    if (config.verbose) {
-        console.log(`🗣️  Resolved entrypoints: ${formatForLog(uniqueEntryPoints)}`);
-        console.log(`🗣️  Resolved compilerOptions: ${formatForLog({
-            ...config.compilerOptions,
-            // resolve enum values to strings for better logging
-            module: ts.ModuleKind[config.compilerOptions.module],
-            moduleResolution: ts.ModuleResolutionKind[config.compilerOptions.moduleResolution],
-            target: ts.ScriptTarget[config.compilerOptions.target],
-        })}`);
-    }
     // Create the TypeScript program using unique entry points
     const program = ts.createProgram({
-        rootNames: uniqueEntryPoints,
+        rootNames: entryPoints,
         options: config.compilerOptions,
         host,
     });
@@ -209,7 +203,7 @@ async function compileProject(config, entryPoints) {
         const errorCount = diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Error).length;
         const warningCount = diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Warning).length;
         if (errorCount > 0 || warningCount > 0) {
-            console.log(`⚠️  Found ${errorCount} error(s) and ${warningCount} warning(s)`);
+            emojiLog("⚠️", `Found ${errorCount} error(s) and ${warningCount} warning(s)`, "warn");
             console.log();
         }
         // Format diagnostics with color and context like tsc, keeping original order
@@ -230,7 +224,7 @@ async function compileProject(config, entryPoints) {
         afterDeclarations: [extensionRewriteTransformer],
     });
     if (emitResult.emitSkipped) {
-        console.error("❌ Emit was skipped due to errors");
+        emojiLog("❌", "Emit was skipped due to errors", "error");
     }
     else {
         // console.log(`✅ Emitted ${config.jsExtension} and ${config.dtsExtension}
@@ -240,7 +234,7 @@ async function compileProject(config, entryPoints) {
     if (emitResult.diagnostics.length > 0) {
         const emitErrors = emitResult.diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Error);
         const emitWarnings = emitResult.diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Warning);
-        console.error(`❌ Found ${emitErrors.length} error(s) and ${emitWarnings.length} warning(s) during emit:`);
+        emojiLog("❌", `Found ${emitErrors.length} error(s) and ${emitWarnings.length} warning(s) during emit:`, "error");
         console.log();
         const formatHost = {
             getCurrentDirectory: () => process.cwd(),

package/{out → dist}/utils.d.cts

@@ -1,5 +1,6 @@
 import * as ts from "typescript";
 export declare function formatForLog(data: unknown): string;
+export declare function emojiLog(_emoji: string, content: string, level?: "log" | "warn" | "error"): void;
 export interface ProjectOptions {
     configPath: string;
     compilerOptions: ts.CompilerOptions & Required<Pick<ts.CompilerOptions, "module" | "moduleResolution" | "outDir">>;

package/{out → dist}/utils.d.ts

@@ -1,5 +1,6 @@
 import * as ts from "typescript";
 export declare function formatForLog(data: unknown): string;
+export declare function emojiLog(_emoji: string, content: string, level?: "log" | "warn" | "error"): void;
 export interface ProjectOptions {
     configPath: string;
     compilerOptions: ts.CompilerOptions & Required<Pick<ts.CompilerOptions, "module" | "moduleResolution" | "outDir">>;