@needle-tools/engine 4.15.0-next.f391a30 → 4.15.0

package/plugins/vite/build-pipeline.js

@@ -1,14 +1,9 @@
 import { ChildProcess, exec } from 'child_process';
 import { NEEDLE_CLOUD_CLI_NAME } from '../common/cloud.js';
 import { getOutputDirectory, loadConfig } from './config.js';
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
-import { relative } from 'path';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
 import { copyFilesSync } from '../common/files.js';
 import { delay } from '../common/timers.js';
-import { needleBlue, needleDim, needleLog, needleSupportsColor, setTransientLogLineCleaner } from './logging.js';
-
-const PIPELINE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const PIPELINE_STRUCTURED_LOG_PREFIX = "__needle_pipeline_log__:";
 
 /**
  * @param {import('../types').userSettings} config
@@ -40,12 +35,10 @@ env:
 // see https://linear.app/needle/issue/NE-3798
 
 
-/**  @type {Promise<void>|null} */
+/**  @type {Promise<any>|null} */
 let buildPipelineTask;
 /** @type {null | {tempDirectory:string, outputDirectory:string}} */
 let buildPipelineTaskResults = null;
-/** @type {null | string} */
-let buildPipelineStepSummary = null;
 
 export function waitForBuildPipelineToFinish() {
     return buildPipelineTask;
@@ -107,9 +100,7 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
     }
 
     if (!shouldRun) {
-        if (command === "build") {
-            log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
-        }
+        log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
         await new Promise((resolve, _) => setTimeout(resolve, 1000));
         return null;
     }
@@ -122,7 +113,6 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
 
     const verboseOutput = userSettings?.buildPipeline?.verbose || false;
     let taskHasCompleted = false;
-    let taskSucceeded = false;
 
     return {
         name: 'needle:buildpipeline',
@@ -158,22 +148,26 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
                     log("Build pipeline already running...");
                     return;
                 }
+                let taskSucceeded = false;
                 // start the compression process once vite is done copying the files
                 buildPipelineTask = invokeBuildPipeline(userSettings, { verbose: verboseOutput })
                     .then((res) => {
                         if (verboseOutput) log("Build pipeline task result:", res);
                         taskSucceeded = res;
                     })
-                    .catch((/** @type {{ message?: string }} */ err) => {
-                        needleLog("needle-buildpipeline", "- Error during build pipeline: " + err.message, "error");
+                    .catch(err => {
+                        console.error("[needle-buildpipeline] - Error during build pipeline: " + err.message);
                         if (verboseOutput) log("Error details:", err);
                     })
                     .finally(() => {
                         taskHasCompleted = true;
                         if (!taskSucceeded) {
-                            needleLog("needle-buildpipeline", "- Build pipeline task did not succeed.", "error");
+                            console.error("[needle-buildpipeline] - Build pipeline task did not succeed.");
                             throw new Error("[needle-buildpipeline] - Build pipeline failed. Please check the logs above for more information.");
                         }
+                        else {
+                            log("Finished successfully");
+                        }
                     });
             }
         },
@@ -181,34 +175,21 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
             if (!buildPipelineTask) {
                 return;
             }
+            if (!taskHasCompleted) {
+                log("Waiting for build pipeline to finish...");
+            }
             // // this is the last hook that is called, so we can wait for the task to finish here
             return buildPipelineTask = buildPipelineTask?.then(() => {
-                const lines = /** @type {string[]} */ ([]);
-                if (buildPipelineStepSummary) {
-                    lines.push(buildPipelineStepSummary);
-                }
-                if (taskSucceeded) {
-                    lines.push(needleDim("✓ Finished successfully"));
-                }
                 // Copy the results to their final output directory. 
                 if (buildPipelineTaskResults != null) {
-                    const supportsColor = needleSupportsColor();
-                    const key = (/** @type {string} */ text) => supportsColor ? needleBlue(text) : text;
-                    const outputPath = relative(process.cwd(), buildPipelineTaskResults.outputDirectory).replaceAll("\\", "/") || ".";
-                    const moved = getDirectoryStats(buildPipelineTaskResults.tempDirectory);
-                    lines.push(`${key("Copying files")}: \"${outputPath}\"`);
-                    const ctx = { count: 0, bytes: 0 }
+                    log(`Copying files from temporary output directory to final output directory at \"${buildPipelineTaskResults.outputDirectory}\"`);
+                    const ctx = { count: 0 }
                     copyFilesSync(buildPipelineTaskResults.tempDirectory, buildPipelineTaskResults.outputDirectory, true, ctx);
-                    lines.push(`${key("Copied files")}: ${ctx.count}`);
-                    lines.push(`${key("Data moved")}: ${formatBytes(moved.totalBytes)} (${moved.fileCount} files)`);
+                    log(`Copied ${ctx.count} file(s)`);
                 }
                 else {
-                    lines.push("No files to copy - build pipeline did not run or did not finish successfully");
+                    log("No files to copy - build pipeline did not run or did not finish successfully");
                 }
-                if (lines.length > 0) {
-                    needleLog("needle-buildpipeline", lines.join("\n"), "log", { dimBody: false });
-                }
-                buildPipelineStepSummary = null;
             });
         },
     }
@@ -235,31 +216,21 @@ async function fixPackageJson(packageJsonPath) {
     writeFileSync(packageJsonPath, fixed);
 }
 
-/** @param {...unknown} args */
+/** @param {any} args */
 function log(...args) {
-    needleLog("needle-buildpipeline", args.join(" "));
+    console.log("[needle-buildpipeline]", ...args);
 }
-/** @param {...unknown} args */
+/** @param {any} args */
 function warn(...args) {
-    needleLog("needle-buildpipeline", args.join(" "), "warn");
+    console.warn("WARN: [needle-buildpipeline]", ...args);
 }
 
-/**
- * @typedef {{ event?: string, phase?: string, target?: string, message?: string, level?: string }} BuildPipelinePayload
- */
 /**
  * @param {import('../types').userSettings} opts 
  * @param {{verbose?:boolean}} [options]
  * @returns {Promise<boolean>}
  */
 async function invokeBuildPipeline(opts, options = {}) {
-    const rel = (/** @type {string} */ pathValue) => {
-        const value = relative(process.cwd(), pathValue).replaceAll("\\", "/");
-        return value?.length ? value : ".";
-    };
-    const supportsColor = needleSupportsColor();
-    const key = (/** @type {string} */ text) => supportsColor ? needleBlue(text) : text;
-
     const installPath = "node_modules/@needle-tools/gltf-build-pipeline";
     const fullInstallPath = process.cwd() + "/" + installPath;
     const existsLocally = existsSync(fullInstallPath);
@@ -286,7 +257,7 @@ async function invokeBuildPipeline(opts, options = {}) {
                 log("Max wait time exceeded - aborting...");
                 return Promise.resolve(false);
             }
-            if (iteration <= 0) needleLog("needle-buildpipeline", `Waiting for output directory to be created... (${outputDirectory})`, "log", { leadingNewline: true });
+            if (iteration <= 0) log(`Waiting for output directory to be created... (${outputDirectory})`);
             return delay(1000).then(() => waitForOutputDirectory(iteration + 1));
         }
         if (options?.verbose) log(`Output directory found after ${iteration} iteration(s) at "${outputDirectory}" - continuing...`);
@@ -297,19 +268,7 @@ async function invokeBuildPipeline(opts, options = {}) {
         return false;
     }
     const files = readdirSync(outputDirectory).filter(f => f.endsWith(".glb") || f.endsWith(".gltf") || f.endsWith(".vrm") || f.endsWith(".fbx"));
-    const filesBytes = files.reduce((total, file) => {
-        try {
-            return total + statSync(outputDirectory + "/" + file).size;
-        }
-        catch {
-            return total;
-        }
-    }, 0);
-    needleLog("needle-buildpipeline", [
-        `${key("Files to process")}: ${files.length} in ${rel(outputDirectory)}`,
-        `${key("Input size")}: ${formatBytes(filesBytes)}`,
-        existsSync(process.cwd() + "/node_modules/.needle/build-pipeline/output") ? needleDim("Removing temporary output directory") : undefined,
-    ].filter(Boolean), "log", { dimBody: false });
+    log(`${files.length} file(s) to process in ${outputDirectory}`);
 
     /** @type {null | ChildProcess} */
     let proc = null;
@@ -331,6 +290,7 @@ async function invokeBuildPipeline(opts, options = {}) {
     // this is so that processes like sveltekit-static-adapter can run first and does not override already compressed files
     const tempOutputPath = process.cwd() + "/node_modules/.needle/build-pipeline/output";
     if (existsSync(tempOutputPath)) {
+        log("Removing temporary output directory at " + tempOutputPath);
         rmSync(tempOutputPath, { recursive: true, force: true });
     }
     mkdirSync(tempOutputPath, { recursive: true });
@@ -347,7 +307,6 @@ async function invokeBuildPipeline(opts, options = {}) {
 
     // allow running the build pipeline in the cloud. It requires and access token to be set in the vite.config.js
     // this can be set via e.g. process.env.NEEDLE_CLOUD_TOKEN
-    const commandEnv = { ...process.env, NEEDLE_PIPELINE_STRUCTURED_LOGS: "1" };
     if (runInCloud) {
         if (!cloudAccessToken || !(typeof cloudAccessToken === "string") || cloudAccessToken.length <= 0) {
             throw new Error("No cloud access token configured. Please set it via process.env.NEEDLE_CLOUD_TOKEN or in the vite.config.js");
@@ -369,12 +328,12 @@ async function invokeBuildPipeline(opts, options = {}) {
         console.log("\n");
         const obfuscatedToken = `${cloudAccessToken.slice(0, 2)}*****${cloudAccessToken.slice(-2)}`;
         log(`Running compression in cloud ⛅ using access token: ${obfuscatedToken}`);
-        proc = exec(cmd, { env: commandEnv });
+        proc = exec(cmd);
     }
     else if (existsLocally) {
         const cmd = `needle-gltf transform "${outputDirectory}" \"${tempOutputPath}\"`;
         log("Running command \"" + cmd + "\" at " + process.cwd() + "...");
-        proc = exec(cmd, { cwd: installPath, env: commandEnv });
+        proc = exec(cmd, { cwd: installPath });
     }
     else {
         // First check if the user passed in a specific version to use via the vite config
@@ -394,140 +353,33 @@ async function invokeBuildPipeline(opts, options = {}) {
 
         const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"`;
         log(`Running compression locally using version '${version}'`);
-        proc = exec(cmd, { env: commandEnv });
-    }
-    let pipelineSpinnerIndex = 0;
-    let pipelineSpinnerActive = false;
-    let transformStepCount = 0;
-    let compressStepCount = 0;
-
-    function clearPipelineProgress() {
-        if (!process.stdout.isTTY || !pipelineSpinnerActive) return;
-        process.stdout.write("\r\x1b[2K");
-        pipelineSpinnerActive = false;
-    }
-
-    /** @param {string} text */
-    function updatePipelineProgress(text) {
-        if (!process.stdout.isTTY) return;
-        const frame = PIPELINE_SPINNER_FRAMES[pipelineSpinnerIndex++ % PIPELINE_SPINNER_FRAMES.length];
-        const maxLength = Math.max(24, (process.stdout.columns || 120) - 4);
-        const value = text.length > maxLength ? `${text.slice(0, Math.max(0, maxLength - 1))}…` : text;
-        process.stdout.write(`\r\x1b[2K${frame} ${value}\x1b[0K`);
-        pipelineSpinnerActive = true;
+        proc = exec(cmd);
     }
-
-    setTransientLogLineCleaner(() => clearPipelineProgress());
-
-    /** @param {Buffer|string} data */
+    /** @param {any} data */
     function onLog(data) {
         if (data.length <= 0) return;
-        const str = String(data).replace(/\r/g, "");
-        const lines = str.split("\n");
-        for (let line of lines) {
-            if (!line?.trim().length) continue;
-
-            if (line.startsWith(PIPELINE_STRUCTURED_LOG_PREFIX)) {
-                let payload = /** @type {BuildPipelinePayload | null} */ (null);
-                try {
-                    payload = /** @type {BuildPipelinePayload} */ (JSON.parse(line.slice(PIPELINE_STRUCTURED_LOG_PREFIX.length)));
-                }
-                catch {
-                    payload = null;
-                }
-                if (payload) {
-                    if (payload.event === "progress") {
-                        if (payload.phase === "transform") transformStepCount++;
-                        if (payload.phase === "compress") compressStepCount++;
-                        updatePipelineProgress(`Build pipeline ${payload.phase === "compress" ? "Compressing" : "Transform"} ${payload.target || payload.message || ""}`.trim());
-                        continue;
-                    }
-
-                    clearPipelineProgress();
-
-                    if (payload.event === "summary") {
-                        needleLog("needle-buildpipeline", payload.message || "Build pipeline summary", "log", { showHeader: false, leadingNewline: true });
-                        continue;
-                    }
-
-                    const level = String(payload.level || "info").toLowerCase();
-                    const message = payload.message || line;
-                    if (level === "error") {
-                        needleLog("needle-buildpipeline", message, "error", { dimBody: false, showHeader: false, leadingNewline: true });
-                    }
-                    else if (level === "warn") {
-                        needleLog("needle-buildpipeline", message, "warn", { dimBody: false, showHeader: false, leadingNewline: true });
-                    }
-                    else {
-                        needleLog("needle-buildpipeline", message, "log", { showHeader: false, leadingNewline: true });
-                    }
-                    continue;
-                }
-            }
-
-            if (line.startsWith("info: [Needle Build Pipeline]") || line.startsWith("info: No \"gltf\" config found") || line.startsWith("info: No config found") || line.startsWith("Limit cache size to ") || line.startsWith("Current cache size is ")) {
-                continue;
-            }
-
-            if (line.startsWith("[NEEDLE_progressive] Skipping")) {
-                continue;
-            }
-
-            if (line.startsWith("objc[") || line.includes("Class GNotificationCenterDelegate is implemented in both") || line.includes("This may cause spurious casting failures and mysterious crashes")) {
-                continue;
-            }
-
-            if (line.startsWith("INFO: Environment variable 'NEEDLE_TOKTX' not set")) {
-                continue;
-            }
-
-            if (line.startsWith("metalRough: KHR_materials_pbrSpecularGlossiness not found")) {
-                continue;
-            }
-
-            if (line.startsWith("WARN: Could not validate image type")) {
-                continue;
-            }
-
-            const progressMatch = line.match(/^info:\s*→\s*(Transform|Compressing)\s+(.+)$/i);
-            if (progressMatch) {
-                if (progressMatch[1].toLowerCase() === "transform") transformStepCount++;
-                if (progressMatch[1].toLowerCase() === "compressing") compressStepCount++;
-                updatePipelineProgress(`Build pipeline ${progressMatch[1]} ${progressMatch[2]}`);
-                continue;
-            }
-
-            if (line.startsWith("info: ← Writing to ") || line.startsWith("info: ← Compressing done in ")) {
-                continue;
+        // ensure that it doesnt end with a newline
+        while (data.endsWith("\n")) data = data.slice(0, -1);
+        if (typeof data === "string") {
+            if (data.startsWith("ERR:")) {
+                console.error(data);
+                return;
             }
-
-            clearPipelineProgress();
-
-            if (line.startsWith("ERR:")) {
-                needleLog("needle-buildpipeline", line, "error", { dimBody: false, showHeader: false, leadingNewline: true });
-                continue;
+            else if (data.startsWith("WARN:")) {
+                console.warn(data);
+                return;
             }
-            else if (line.startsWith("WARN:")) {
-                needleLog("needle-buildpipeline", line, "warn", { dimBody: false, showHeader: false, leadingNewline: true });
-                continue;
+            // Ignore empty lines
+            else if (data.trim().length <= 0) {
+                return;
             }
-
-            const shouldDim = line.includes("Loaded compressed file from cache");
-            needleLog("needle-buildpipeline", line, "log", { showHeader: false, leadingNewline: true, dimBody: shouldDim });
         }
+        log(data);
     }
     proc.stdout?.on('data', onLog);
     proc.stderr?.on('data', onLog);
     return new Promise((resolve, reject) => {
         proc.on('exit', (code) => {
-            clearPipelineProgress();
-            setTransientLogLineCleaner(null);
-
-            if (transformStepCount > 0 || compressStepCount > 0) {
-                buildPipelineStepSummary = `✓ Pipeline steps: transformed ${transformStepCount} file(s), compressed ${compressStepCount} file(s)`;
-            }
-            else buildPipelineStepSummary = null;
-
             if (code === null || code === undefined) {
                 if (options?.verbose) log("Process exited with no code - assuming success");
                 code = 0;
@@ -539,38 +391,3 @@ async function invokeBuildPipeline(opts, options = {}) {
         });
     });
 }
-
-/** @param {number | undefined} bytes */
-function formatBytes(bytes) {
-    const value = Number(bytes || 0);
-    if (value < 1024) return `${value} B`;
-    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
-    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
-    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-
-/** @param {string | null | undefined} directory */
-function getDirectoryStats(directory) {
-    if (!directory || !existsSync(directory)) return { fileCount: 0, totalBytes: 0 };
-    let fileCount = 0;
-    let totalBytes = 0;
-    const entries = readdirSync(directory, { withFileTypes: true });
-    for (const entry of entries) {
-        const path = directory + "/" + entry.name;
-        if (entry.isDirectory()) {
-            const stats = getDirectoryStats(path);
-            fileCount += stats.fileCount;
-            totalBytes += stats.totalBytes;
-        }
-        else {
-            try {
-                const stat = statSync(path);
-                fileCount += 1;
-                totalBytes += stat.size;
-            }
-            catch {
-            }
-        }
-    }
-    return { fileCount, totalBytes };
-}

package/plugins/vite/buildinfo.js

@@ -1,8 +1,6 @@
-import { collectBuildDirectoryStats, createBuildInfoFile } from '../common/buildinfo.js';
-import { closeLogStreams } from '../common/logger.js';
+import { createBuildInfoFile } from '../common/buildinfo.js';
 import { waitForBuildPipelineToFinish } from './build-pipeline.js';
 import { getOutputDirectory } from './config.js';
-import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging.js';
 
 let level = 0;
 
@@ -23,80 +21,22 @@ export const needleBuildInfo = (command, config, userSettings) => {
         },
         closeBundle: async () => {
             if (--level > 0) {
-                needleLog("needle-buildinfo", "Skipped because of nested build");
+                console.log("[needle-buildinfo] - Skipped because of nested build");
                 return;
             }
-            const buildDirectory = getOutputDirectory();
-            const beforeStats = collectBuildDirectoryStats(buildDirectory);
             const task = waitForBuildPipelineToFinish();
             if (task instanceof Promise) {
-                needleLog("needle-buildinfo", "Waiting for build pipeline to finish");
-                await task.catch(() => { });
+                console.log("[needle-buildinfo] - Waiting for build pipeline to finish");
+                await task.catch(() => { }).finally(() => console.log("[needle-buildinfo] - Build pipeline finished!"));
             }
             // wait for gzip
             await delay(500);
-            const result = createBuildInfoFile(buildDirectory, { log: false });
-            const closedHandles = closeDanglingNetworkHandles();
-            if (!result?.ok) {
-                needleLog("needle-buildinfo", result?.error || "Failed to create build info file", "warn", { dimBody: false });
-                return;
-            }
-            const supportsColor = needleSupportsColor();
-            const key = (text) => supportsColor ? needleBlue(text) : text;
-            const sizeDelta = (result.totalSizeBytes || 0) - (beforeStats.totalSizeBytes || 0);
-            const fileDelta = (result.fileCount || 0) - (beforeStats.fileCount || 0);
-            const lines = [
-                "Build pipeline finished!",
-                `${key("Before pipeline")}: ${beforeStats.fileCount} files (${formatBytes(beforeStats.totalSizeBytes)})`,
-                `${key("After pipeline")}: ${result.fileCount} files (${formatBytes(result.totalSizeBytes)})`,
-                `${key("Delta")}: ${(sizeDelta >= 0 ? "+" : "-") + formatBytes(Math.abs(sizeDelta))}, ${(fileDelta >= 0 ? "+" : "") + fileDelta} files`,
-                needleDim(`Begin collecting files in \"${result.buildDirectory}\"`),
-                needleDim(`Collected ${result.fileCount} files (${result.totalSizeInMB.toFixed(2)} MB). Writing build info to \"${result.buildInfoPath}\"`),
-                needleDim(`Build info file successfully written to \"${result.buildInfoPath}\"`),
-            ];
-            if (closedHandles > 0) lines.push(`Closed ${closedHandles} dangling network handle(s)`);
-            needleLog("needle-buildinfo", lines.join("\n"), "log", { dimBody: false });
-            closeLogStreams();
+            const buildDirectory = getOutputDirectory();
+            createBuildInfoFile(buildDirectory);
         }
     }
 }
 
-function formatBytes(bytes) {
-    const value = Number(bytes || 0);
-    if (value < 1024) return `${value} B`;
-    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
-    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
-    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
-
 function delay(ms) {
     return new Promise(res => setTimeout(res, ms));
-}
-
-function closeDanglingNetworkHandles() {
-    /** @type {() => any[] | undefined} */
-    // @ts-ignore private node api
-    const getActiveHandles = process._getActiveHandles;
-    if (typeof getActiveHandles !== "function") {
-        return 0;
-    }
-
-    let closed = 0;
-    const handles = getActiveHandles() || [];
-    for (const handle of handles) {
-        if (!handle || handle === process.stdin || handle === process.stdout || handle === process.stderr) continue;
-        const hasNetworkShape = typeof handle.destroy === "function" && (typeof handle.remotePort === "number" || typeof handle.remoteAddress === "string");
-        if (!hasNetworkShape) continue;
-
-        if (typeof handle.remotePort === "number" && handle.remotePort > 0) {
-            try {
-                handle.destroy();
-                closed++;
-            }
-            catch {
-                // ignore cleanup failures
-            }
-        }
-    }
-    return closed;
 }

package/plugins/vite/copyfiles.js

@@ -1,9 +1,8 @@
 
-import { resolve, join, isAbsolute, relative } from 'path'
+import { resolve, join, isAbsolute } from 'path'
 import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir, rmSync } from 'fs';
 import { builtAssetsDirectory, tryLoadProjectConfig } from './config.js';
 import { copyFilesSync } from '../common/files.js';
-import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging.js';
 
 const pluginName = "needle-copy-files";
 
@@ -36,19 +35,11 @@ export const needleCopyFiles = (command, config, userSettings) => {
  * @param {import('../types').userSettings} config
  */
 async function run(buildstep, config) {
-    const logLines = [needleDim(`Copy files at ${buildstep}`)];
+    console.log(`[${pluginName}] - Copy files at ${buildstep}`);
     const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
-    const copied = { count: 0, bytes: 0 };
 
     const baseDir = process.cwd();
     const override = buildstep === "start";
-    const supportsColor = needleSupportsColor();
-    const key = (text) => supportsColor ? needleBlue(text) : text;
-    const rel = (pathValue) => {
-        const result = relative(baseDir, pathValue).replaceAll("\\", "/");
-        if (!result || result.length === 0) return ".";
-        return result;
-    };
 
     let assetsDirName = "assets";
     let outdirName = "dist";
@@ -66,9 +57,9 @@ async function run(buildstep, config) {
         // copy include from engine
         const engineIncludeDir = resolve(baseDir, 'node_modules', '@needle-tools', 'engine', 'src', 'include');
         if (existsSync(engineIncludeDir)) {
-            logLines.push(`Engine include: ${rel(engineIncludeDir)} -> ${rel(resolve(baseDir, 'include'))}`);
+            console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
             const projectIncludeDir = resolve(baseDir, 'include');
-            copyFilesSync(engineIncludeDir, projectIncludeDir, true, copied);
+            copyFilesSync(engineIncludeDir, projectIncludeDir);
         }
     }
 
@@ -94,8 +85,8 @@ async function run(buildstep, config) {
             const src = resolve(baseDir, entry);
             const dest = resolvePath(outDir, entry);
             if (existsSync(src) && dest) {
-                logLines.push(`Configured copy: ${rel(src)} -> ${rel(dest)}`);
-                copyFilesSync(src, dest, override, copied);
+                console.log(`[${pluginName}] - Copy ${entry} to ${outdirName}/${entry}`)
+                copyFilesSync(src, dest, override);
             }
         }
     }
@@ -107,41 +98,21 @@ async function run(buildstep, config) {
         // ensure that the target directory exists and is cleared if it already exists
         // otherwise we might run into issues where the build pipeline is running for already compressed files
         if (override && existsSync(targetDir)) {
-            logLines.push(needleDim(`Clearing target directory "${rel(targetDir)}"`));
+            console.log(`[${pluginName}] - Clearing target directory \"${targetDir}\"`);
             rmSync(targetDir, { recursive: true, force: true });
         }
-        logLines.push(needleDim(`Assets: ${rel(assetsDir)} -> ${rel(targetDir)}`));
-        copyFilesSync(assetsDir, targetDir, override, copied);
+        console.log(`[${pluginName}] - Copy assets to ${outdirName}/${builtAssetsDirectory()}`)
+        copyFilesSync(assetsDir, targetDir, override);
     }
-    else logLines.push(`No assets directory found. Skipping copy of ${assetsDirName} resolved to ${rel(assetsDir)}`);
+    else console.log(`WARN: No assets directory found. Skipping copy of ${assetsDirName} resolved to ${assetsDir}`)
 
     // copy include dir
     const includeDir = resolve(baseDir, 'include');
     if (existsSync(includeDir)) {
+        console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
         const targetDir = resolve(outDir, 'include');
-        logLines.push(needleDim(`Include: ${rel(includeDir)} -> ${rel(targetDir)}`));
-        copyFilesSync(includeDir, targetDir, override, copied);
+        copyFilesSync(includeDir, targetDir, override);
     }
-
-    logLines.push(`${key("Copied files")}: ${copied.count}`);
-    logLines.push(`${key("Copied size")}: ${formatBytes(copied.bytes || 0)}`);
-    if (buildstep === "end") {
-        logLines.push("");
-        logLines.push("✨ Happy creating! 🌵");
-    }
-
-    needleLog(pluginName, logLines.join("\n"), "log", {
-        leadingNewline: buildstep === "end",
-        dimBody: false,
-    });
-}
-
-function formatBytes(bytes) {
-    const value = Number(bytes || 0);
-    if (value < 1024) return `${value} B`;
-    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
-    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
-    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
 
 /** resolves relative or absolute paths to a path inside the out directory