@rage-against-the-pixel/unity-cli 1.5.4 → 1.6.0

package/dist/unity-logging.js

@@ -0,0 +1,956 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionTableRenderer = void 0;
+exports.sanitizeTelemetryJson = sanitizeTelemetryJson;
+exports.stringDisplayWidth = stringDisplayWidth;
+exports.formatActionTimelineTable = formatActionTimelineTable;
+exports.TailLogFile = TailLogFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logging_1 = require("./logging");
+const utilities_1 = require("./utilities");
+const utp_1 = require("./utp");
+/**
+ * Editor log messages whose severity has been changed.
+ * Useful for making certain error messages that are not critical less noisy.
+ * Key is the exact log message, value is the remapped LogLevel.
+ */
+const remappedEditorLogs = {
+    'OpenCL device, baking cannot use GPU lightmapper.': logging_1.LogLevel.INFO,
+    'Failed to find a suitable OpenCL device, baking cannot use GPU lightmapper.': logging_1.LogLevel.INFO,
+};
+// Detects GitHub-style annotation markers to avoid emitting duplicates
+const annotationPrefixRegex = /\n::[a-z]+::/i;
+const TIMELINE_HEADING = '🔨 Unity Build Timeline';
+const PLAYER_BUILD_INFO_HEADING = '📋 Player Build Info';
+function sanitizeTelemetryJson(raw) {
+    if (!raw) {
+        return '';
+    }
+    return raw
+        .replace(/\uFEFF/gu, '')
+        .replace(/\u0000/gu, '')
+        .trim();
+}
+const MIN_DESCRIPTION_COLUMN_WIDTH = 16;
+const DEFAULT_TERMINAL_WIDTH = 120;
+const TERMINAL_WIDTH_SAFETY_MARGIN = 2;
+const MIN_TERMINAL_WIDTH = 40;
+const extendedPictographicRegex = /\p{Extended_Pictographic}/u;
+class ActionTelemetryAccumulator {
+    pendingActions = new Map();
+    completedActions = [];
+    totalDurationMs = 0;
+    totalErrorCount = 0;
+    playerBuildInfoSteps = [];
+    record(action) {
+        if (action.phase === utp_1.Phase.Begin) {
+            this.pendingActions.set(this.getActionKey(action), action);
+            return true;
+        }
+        if (action.phase === utp_1.Phase.End) {
+            const key = this.getActionKey(action);
+            let start = this.pendingActions.get(key);
+            if (start) {
+                this.pendingActions.delete(key);
+            }
+            else {
+                const fallback = this.findPendingMatchFor(action);
+                if (fallback) {
+                    start = fallback.action;
+                    this.pendingActions.delete(fallback.key);
+                }
+            }
+            const durationMs = this.calculateDurationMs(start, action);
+            const errors = this.extractErrors(action);
+            const summary = {
+                name: action.name ?? 'Unnamed Action',
+                description: action.description ?? '',
+                durationMs,
+                errors,
+            };
+            this.completedActions.push(summary);
+            this.totalDurationMs += durationMs;
+            this.totalErrorCount += errors.length;
+            return true;
+        }
+        return false;
+    }
+    recordPlayerBuildInfo(info) {
+        if (!Array.isArray(info.steps) || info.steps.length === 0) {
+            return false;
+        }
+        const normalizedSteps = info.steps
+            .map(step => {
+            const description = step.description?.trim();
+            if (!description) {
+                return undefined;
+            }
+            const durationMs = Math.max(0, step.duration ?? 0);
+            const errorCount = Math.max(0, step.errors ?? 0);
+            return {
+                description,
+                durationMs,
+                errorCount,
+            };
+        })
+            .filter((step) => step !== undefined);
+        if (normalizedSteps.length === 0) {
+            return false;
+        }
+        this.playerBuildInfoSteps = normalizedSteps;
+        return true;
+    }
+    snapshot() {
+        if (this.completedActions.length === 0 && this.pendingActions.size === 0 && this.playerBuildInfoSteps.length === 0) {
+            return undefined;
+        }
+        return {
+            completed: [...this.completedActions],
+            pending: Array.from(this.pendingActions.values()).map(action => ({
+                name: action.name ?? 'Unnamed Action',
+                description: action.description ?? '',
+            })),
+            totalDurationMs: this.totalDurationMs,
+            totalErrorCount: this.totalErrorCount,
+            playerBuildInfo: this.playerBuildInfoSteps.length > 0
+                ? {
+                    steps: [...this.playerBuildInfoSteps],
+                    totalDurationMs: this.playerBuildInfoSteps.reduce((sum, step) => sum + step.durationMs, 0),
+                    totalErrorCount: this.playerBuildInfoSteps.reduce((sum, step) => sum + step.errorCount, 0),
+                }
+                : undefined,
+        };
+    }
+    getActionKey(action) {
+        const pid = action.processId ?? 'na';
+        const name = action.name ?? '';
+        const description = action.description ?? '';
+        return `${pid}::${name}::${description}`;
+    }
+    findPendingMatchFor(action) {
+        for (const [key, pending] of this.pendingActions.entries()) {
+            const sameProcess = (pending.processId ?? 'na') === (action.processId ?? 'na');
+            const sameName = (pending.name ?? '') === (action.name ?? '');
+            if (!sameProcess || !sameName) {
+                continue;
+            }
+            const pendingDescription = pending.description ?? '';
+            const endingDescription = action.description ?? '';
+            if (!pendingDescription || !endingDescription) {
+                continue;
+            }
+            if (endingDescription.startsWith(pendingDescription) || pendingDescription.startsWith(endingDescription)) {
+                return { key, action: pending };
+            }
+        }
+        return undefined;
+    }
+    calculateDurationMs(start, end) {
+        if (start?.time != null && end.time != null) {
+            return Math.max(0, end.time - start.time);
+        }
+        if (typeof end.duration === 'number') {
+            return Math.max(0, end.duration);
+        }
+        return 0;
+    }
+    extractErrors(action) {
+        if (!Array.isArray(action.errors) || action.errors.length === 0) {
+            return [];
+        }
+        return action.errors.map(formatErrorDetailValue);
+    }
+}
+function formatErrorDetailValue(value) {
+    let raw = '';
+    if (value instanceof Error) {
+        raw = value.stack && value.stack.length > 0 ? value.stack : (value.message || value.toString());
+    }
+    else if (typeof value === 'string') {
+        raw = value;
+    }
+    else if (value === undefined || value === null) {
+        raw = '';
+    }
+    else if (typeof value === 'object') {
+        try {
+            raw = JSON.stringify(value, null, 2);
+        }
+        catch {
+            raw = String(value);
+        }
+    }
+    else {
+        raw = String(value);
+    }
+    return raw.replace(/\r\n/g, '\n').trimEnd();
+}
+function formatDuration(ms) {
+    if (ms >= 86_400_000) {
+        const days = ms / 86_400_000;
+        return `${days.toFixed(days >= 10 ? 0 : 1)} d`;
+    }
+    if (ms >= 3_600_000) {
+        const hours = ms / 3_600_000;
+        return `${hours.toFixed(hours >= 10 ? 0 : 1)} h`;
+    }
+    if (ms >= 60_000) {
+        const minutes = ms / 60_000;
+        return `${minutes.toFixed(minutes >= 10 ? 0 : 1)} m`;
+    }
+    if (ms >= 1_000) {
+        const seconds = ms / 1_000;
+        return `${seconds.toFixed(seconds >= 10 ? 0 : 1)} s`;
+    }
+    return `${ms} ms`;
+}
+function truncateDisplay(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return '';
+    }
+    if (stringDisplayWidth(value) <= maxWidth) {
+        return value;
+    }
+    if (maxWidth <= 3) {
+        let width = 0;
+        let result = '';
+        for (const symbol of [...value]) {
+            const codePoint = symbol.codePointAt(0);
+            if (codePoint === undefined) {
+                continue;
+            }
+            const charWidth = charDisplayWidth(codePoint);
+            if (width + charWidth > maxWidth) {
+                break;
+            }
+            width += charWidth;
+            result += symbol;
+            if (width >= maxWidth) {
+                break;
+            }
+        }
+        return result;
+    }
+    const ellipsis = '...';
+    const ellipsisWidth = stringDisplayWidth(ellipsis);
+    const targetWidth = Math.max(1, maxWidth - ellipsisWidth);
+    let width = 0;
+    let result = '';
+    for (const symbol of [...value]) {
+        const codePoint = symbol.codePointAt(0);
+        if (codePoint === undefined) {
+            continue;
+        }
+        const charWidth = charDisplayWidth(codePoint);
+        if (width + charWidth > targetWidth) {
+            break;
+        }
+        width += charWidth;
+        result += symbol;
+    }
+    if (!result) {
+        return ellipsis;
+    }
+    return `${result}${ellipsis}`;
+}
+function stringDisplayWidth(value) {
+    let width = 0;
+    for (const symbol of [...value]) {
+        const codePoint = symbol.codePointAt(0);
+        if (codePoint === undefined) {
+            continue;
+        }
+        width += charDisplayWidth(codePoint);
+    }
+    return width;
+}
+function charDisplayWidth(codePoint) {
+    if (isZeroWidthCodePoint(codePoint)) {
+        return 0;
+    }
+    if (isEmojiPresentation(codePoint) || isFullWidthCodePoint(codePoint)) {
+        return 2;
+    }
+    return 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    if (codePoint === 0) {
+        return true;
+    }
+    if (codePoint === 0x200d) {
+        return true; // zero width joiner used in emoji sequences
+    }
+    if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) {
+        return true;
+    }
+    if (isCombiningMark(codePoint)) {
+        return true;
+    }
+    if ((codePoint >= 0xfe00 && codePoint <= 0xfe0f) || (codePoint >= 0xe0100 && codePoint <= 0xe01ef)) {
+        return true; // variation selectors
+    }
+    return false;
+}
+function isEmojiPresentation(codePoint) {
+    // Use Unicode Extended_Pictographic to detect emoji that are rendered double-width
+    return extendedPictographicRegex.test(String.fromCodePoint(codePoint));
+}
+function isCombiningMark(codePoint) {
+    const ranges = [
+        [0x0300, 0x036f],
+        [0x0483, 0x0489],
+        [0x07eb, 0x07f3],
+        [0x135d, 0x135f],
+        [0x1ab0, 0x1aff],
+        [0x1dc0, 0x1dff],
+        [0x20d0, 0x20ff],
+        [0xfe20, 0xfe2f],
+    ];
+    return ranges.some(([start, end]) => codePoint >= start && codePoint <= end);
+}
+function isFullWidthCodePoint(codePoint) {
+    return codePoint >= 0x1100 && (codePoint <= 0x115f ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6b) ||
+        (codePoint >= 0xff01 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+        (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+function padDisplay(value, width, alignment = 'left') {
+    if (width <= 0) {
+        return '';
+    }
+    let text = value;
+    let valueWidth = stringDisplayWidth(text);
+    if (valueWidth > width) {
+        text = truncateDisplay(text, width);
+        valueWidth = stringDisplayWidth(text);
+    }
+    if (valueWidth === width) {
+        return text;
+    }
+    const padding = width - valueWidth;
+    if (alignment === 'right') {
+        return `${' '.repeat(padding)}${text}`;
+    }
+    if (alignment === 'center') {
+        const left = Math.floor(padding / 2);
+        return `${' '.repeat(left)}${text}${' '.repeat(padding - left)}`;
+    }
+    return `${text}${' '.repeat(padding)}`;
+}
+function computeTablePadding(columnCount) {
+    return columnCount * 3 + 1;
+}
+function computeTableWidth(columnWidths) {
+    let sum = 0;
+    for (const width of columnWidths) {
+        sum += width ?? 0;
+    }
+    return sum + computeTablePadding(columnWidths.length);
+}
+function adjustDescriptionColumnWidth(columnWidths, descriptionColumnIndex, descriptionHeaderWidth, maxWidth) {
+    if (maxWidth === undefined || !Number.isFinite(maxWidth) || maxWidth <= 0) {
+        return columnWidths;
+    }
+    const targetWidth = Math.floor(maxWidth);
+    const totalWidth = computeTableWidth(columnWidths);
+    const paddingWidth = computeTablePadding(columnWidths.length);
+    let sumWithoutDescription = 0;
+    columnWidths.forEach((width, index) => {
+        if (index === descriptionColumnIndex) {
+            return;
+        }
+        sumWithoutDescription += width ?? 0;
+    });
+    const minDescriptionWidth = Math.max(descriptionHeaderWidth, MIN_DESCRIPTION_COLUMN_WIDTH);
+    const currentDescriptionWidth = columnWidths[descriptionColumnIndex] ?? minDescriptionWidth;
+    const availableWidthForDescription = targetWidth - paddingWidth - sumWithoutDescription;
+    if (totalWidth <= targetWidth) {
+        columnWidths[descriptionColumnIndex] = Math.max(currentDescriptionWidth, availableWidthForDescription);
+        return columnWidths;
+    }
+    if (availableWidthForDescription >= minDescriptionWidth) {
+        columnWidths[descriptionColumnIndex] = Math.max(minDescriptionWidth, Math.min(currentDescriptionWidth, availableWidthForDescription));
+        return columnWidths;
+    }
+    columnWidths[descriptionColumnIndex] = minDescriptionWidth;
+    return columnWidths;
+}
+function buildBorderLine(columnWidths, left, middle, right) {
+    let result = left;
+    columnWidths.forEach((width, index) => {
+        const segmentWidth = Math.max(0, width + 2);
+        result += '─'.repeat(segmentWidth);
+        result += index === columnWidths.length - 1 ? right : middle;
+    });
+    return result;
+}
+function formatActionTimelineTable(snapshot, options) {
+    const showErrorsColumn = snapshot.totalErrorCount > 0;
+    const tableRows = [];
+    snapshot.pending.forEach(action => {
+        const row = {
+            status: '⏳',
+            description: action.description ?? '',
+            durationText: '...',
+        };
+        if (showErrorsColumn) {
+            row.errorsText = '';
+        }
+        tableRows.push(row);
+    });
+    snapshot.completed.forEach(action => {
+        const row = {
+            status: action.errors.length > 0 ? '❌' : '✅',
+            description: action.description ?? '',
+            durationText: formatDuration(action.durationMs),
+        };
+        if (showErrorsColumn) {
+            row.errorsText = action.errors.length.toString();
+        }
+        tableRows.push(row);
+    });
+    if (tableRows.length === 0 && snapshot.playerBuildInfo === undefined) {
+        return undefined;
+    }
+    const totalsRow = {
+        status: 'Σ',
+        description: ' Total Build Duration',
+        durationText: formatDuration(snapshot.totalDurationMs),
+    };
+    if (showErrorsColumn) {
+        totalsRow.errorsText = snapshot.totalErrorCount.toString();
+    }
+    const statusHeader = 'Status';
+    const descriptionHeader = 'Description';
+    const durationHeader = 'Duration';
+    const errorsHeader = '# of Errors';
+    let statusWidth = Math.max(stringDisplayWidth(statusHeader), ...tableRows.map(row => stringDisplayWidth(row.status)), stringDisplayWidth(totalsRow.status));
+    let descriptionWidth = Math.max(stringDisplayWidth(descriptionHeader), ...tableRows.map(row => stringDisplayWidth(row.description)), stringDisplayWidth(totalsRow.description));
+    let durationWidth = Math.max(stringDisplayWidth(durationHeader), ...tableRows.map(row => stringDisplayWidth(row.durationText)), stringDisplayWidth(totalsRow.durationText));
+    let errorsWidth = showErrorsColumn ? Math.max(stringDisplayWidth(errorsHeader), ...tableRows.map(row => stringDisplayWidth(row.errorsText ?? '')), stringDisplayWidth(totalsRow.errorsText ?? '')) : 0;
+    let columns = showErrorsColumn
+        ? [statusWidth, descriptionWidth, durationWidth, errorsWidth]
+        : [statusWidth, descriptionWidth, durationWidth];
+    columns = adjustDescriptionColumnWidth(columns, 1, stringDisplayWidth(descriptionHeader), options?.maxWidth);
+    statusWidth = columns[0] ?? statusWidth;
+    descriptionWidth = columns[1] ?? descriptionWidth;
+    durationWidth = columns[2] ?? durationWidth;
+    if (showErrorsColumn) {
+        errorsWidth = columns[3] ?? errorsWidth;
+    }
+    const resolvedColumns = showErrorsColumn
+        ? [statusWidth, descriptionWidth, durationWidth, errorsWidth]
+        : [statusWidth, descriptionWidth, durationWidth];
+    const padStatus = (value) => padDisplay(value, statusWidth, 'center');
+    const formatRow = (row) => {
+        let line = `│ ${padStatus(row.status)} │ ${padDisplay(row.description, descriptionWidth)} │ ${padDisplay(row.durationText, durationWidth, 'right')} │`;
+        if (showErrorsColumn) {
+            line += ` ${padDisplay(row.errorsText ?? '', errorsWidth, 'right')} │`;
+        }
+        return line;
+    };
+    const topBorder = buildBorderLine(resolvedColumns, '┌', '┬', '┐');
+    const headerRow = showErrorsColumn
+        ? `│ ${padStatus(statusHeader)} │ ${padDisplay(descriptionHeader, descriptionWidth)} │ ${padDisplay(durationHeader, durationWidth, 'right')} │ ${padDisplay(errorsHeader, errorsWidth, 'right')} │`
+        : `│ ${padStatus(statusHeader)} │ ${padDisplay(descriptionHeader, descriptionWidth)} │ ${padDisplay(durationHeader, durationWidth, 'right')} │`;
+    const headerDivider = buildBorderLine(resolvedColumns, '├', '┼', '┤');
+    const totalsDivider = buildBorderLine(resolvedColumns, '├', '┼', '┤');
+    const bottomBorder = buildBorderLine(resolvedColumns, '└', '┴', '┘');
+    let output = `${TIMELINE_HEADING}\n`;
+    output += `${topBorder}\n`;
+    output += `${headerRow}\n`;
+    output += `${headerDivider}\n`;
+    tableRows.forEach(row => {
+        output += `${formatRow(row)}\n`;
+    });
+    output += `${totalsDivider}\n`;
+    output += `${formatRow(totalsRow)}\n`;
+    output += `${bottomBorder}\n`;
+    const playerBuildInfoOptions = options?.maxWidth === undefined ? undefined : { maxWidth: options.maxWidth };
+    if (snapshot.playerBuildInfo) {
+        const playerBuildInfoSection = formatPlayerBuildInfoTable(snapshot.playerBuildInfo, playerBuildInfoOptions);
+        if (playerBuildInfoSection) {
+            output += `\n${playerBuildInfoSection}`;
+        }
+    }
+    if (showErrorsColumn && snapshot.totalErrorCount > 0) {
+        const errorSection = formatErrorDetailsSection(snapshot.completed);
+        if (errorSection) {
+            output += `\n${errorSection}\n`;
+        }
+        else {
+            output += '\n';
+        }
+    }
+    else {
+        output += '\n';
+    }
+    return {
+        text: output,
+        lineCount: countLines(output),
+    };
+}
+function countLines(block) {
+    if (!block) {
+        return 0;
+    }
+    const normalized = block.endsWith('\n') ? block : `${block}\n`;
+    return normalized.split('\n').length - 1;
+}
+function formatPlayerBuildInfoTable(playerInfo, options) {
+    if (!playerInfo.steps || playerInfo.steps.length === 0) {
+        return undefined;
+    }
+    const rows = playerInfo.steps.map(step => ({
+        description: step.description,
+        durationText: formatDuration(step.durationMs),
+        errorsText: step.errorCount.toString(),
+    }));
+    const totalsRow = {
+        description: ' Total Player Build Duration',
+        durationText: formatDuration(playerInfo.totalDurationMs),
+        errorsText: playerInfo.totalErrorCount.toString(),
+    };
+    const descriptionHeader = 'Description';
+    const durationHeader = 'Duration';
+    const errorsHeader = '# of Errors';
+    let descriptionWidth = Math.max(stringDisplayWidth(descriptionHeader), ...rows.map(row => stringDisplayWidth(row.description)), stringDisplayWidth(totalsRow.description));
+    let durationWidth = Math.max(stringDisplayWidth(durationHeader), ...rows.map(row => stringDisplayWidth(row.durationText)), stringDisplayWidth(totalsRow.durationText));
+    let errorWidth = Math.max(stringDisplayWidth(errorsHeader), ...rows.map(row => stringDisplayWidth(row.errorsText)), stringDisplayWidth(totalsRow.errorsText));
+    let columns = [descriptionWidth, durationWidth, errorWidth];
+    columns = adjustDescriptionColumnWidth(columns, 0, stringDisplayWidth(descriptionHeader), options?.maxWidth);
+    descriptionWidth = columns[0] ?? descriptionWidth;
+    durationWidth = columns[1] ?? durationWidth;
+    errorWidth = columns[2] ?? errorWidth;
+    const padDescription = (value) => padDisplay(value, descriptionWidth);
+    const topBorder = buildBorderLine([descriptionWidth, durationWidth, errorWidth], '┌', '┬', '┐');
+    const headerDivider = buildBorderLine([descriptionWidth, durationWidth, errorWidth], '├', '┼', '┤');
+    const totalsDivider = buildBorderLine([descriptionWidth, durationWidth, errorWidth], '├', '┼', '┤');
+    const bottomBorder = buildBorderLine([descriptionWidth, durationWidth, errorWidth], '└', '┴', '┘');
+    let output = `${PLAYER_BUILD_INFO_HEADING}\n`;
+    output += `${topBorder}\n`;
+    output += `│ ${padDescription(descriptionHeader)} │ ${padDisplay(durationHeader, durationWidth, 'right')} │ ${padDisplay(errorsHeader, errorWidth, 'right')} │\n`;
+    output += `${headerDivider}\n`;
+    rows.forEach(row => {
+        output += `│ ${padDescription(row.description)} │ ${padDisplay(row.durationText, durationWidth, 'right')} │ ${padDisplay(row.errorsText, errorWidth, 'right')} │\n`;
+    });
+    output += `${totalsDivider}\n`;
+    output += `│ ${padDescription(totalsRow.description)} │ ${padDisplay(totalsRow.durationText, durationWidth, 'right')} │ ${padDisplay(totalsRow.errorsText, errorWidth, 'right')} │\n`;
+    output += `${bottomBorder}\n`;
+    if (!output.endsWith('\n')) {
+        output += '\n';
+    }
+    return output;
+}
+function formatErrorDetailsSection(actions) {
+    const actionsWithErrors = actions.filter(action => action.errors.length > 0);
+    if (actionsWithErrors.length === 0) {
+        return undefined;
+    }
+    const lines = ['Error Details'];
+    actionsWithErrors.forEach(action => {
+        const headerText = (action.description && action.description.trim().length > 0)
+            ? action.description
+            : (action.name && action.name.trim().length > 0 ? action.name : 'Unnamed Action');
+        lines.push('');
+        lines.push(headerText);
+        action.errors.forEach(errorText => {
+            const normalized = errorText.length > 0 ? errorText : '(no details provided)';
+            const segments = normalized.split('\n');
+            const [firstLine, ...rest] = segments;
+            lines.push(`  - ${firstLine}`);
+            rest.forEach(segment => {
+                if (segment.length === 0) {
+                    lines.push('');
+                }
+                else {
+                    lines.push(`    ${segment}`);
+                }
+            });
+        });
+    });
+    return lines.join('\n').trimEnd();
+}
+class ActionTableRenderer {
+    canUpdateTerminal;
+    lastRenderLineCount = 0;
+    anchorActive = false;
+    constructor(canUpdateTerminal) {
+        this.canUpdateTerminal = canUpdateTerminal;
+    }
+    prepareForContent() {
+        if (!this.canUpdateTerminal) {
+            return;
+        }
+        this.clearTimelineRegion();
+    }
+    render(snapshot) {
+        if (!snapshot) {
+            this.clearTimelineRegion();
+            return;
+        }
+        const formatted = formatActionTimelineTable(snapshot, { maxWidth: this.getMaxWidth() });
+        if (!formatted) {
+            this.clearTimelineRegion();
+            return;
+        }
+        if (this.canUpdateTerminal) {
+            this.clearTimelineRegion();
+            process.stdout.write(formatted.text);
+            this.anchorActive = true;
+            this.lastRenderLineCount = formatted.lineCount;
+        }
+        else {
+            process.stdout.write(formatted.text);
+        }
+    }
+    clearTimelineRegion() {
+        if (!this.anchorActive || this.lastRenderLineCount <= 0) {
+            return;
+        }
+        this.rewindToAnchor();
+        process.stdout.write('\u001b[J');
+        this.anchorActive = false;
+        this.lastRenderLineCount = 0;
+    }
+    rewindToAnchor() {
+        // The TIMELINE_HEADING line is our anchor; rewind to it before clearing so updates stay in place.
+        const linesToMove = this.lastRenderLineCount;
+        if (linesToMove <= 0) {
+            return;
+        }
+        process.stdout.write(`\u001b[${linesToMove}F`);
+    }
+    getMaxWidth() {
+        const detectedWidth = this.detectTerminalWidth();
+        const adjustedWidth = detectedWidth - TERMINAL_WIDTH_SAFETY_MARGIN;
+        return Math.max(MIN_TERMINAL_WIDTH, adjustedWidth);
+    }
+    detectTerminalWidth() {
+        const stdoutColumns = typeof process.stdout.columns === 'number' ? process.stdout.columns : undefined;
+        if (stdoutColumns && stdoutColumns > 0) {
+            return stdoutColumns;
+        }
+        const envColumns = Number(process.env.COLUMNS);
+        if (Number.isFinite(envColumns) && envColumns > 0) {
+            return envColumns;
+        }
+        return DEFAULT_TERMINAL_WIDTH;
+    }
+}
+exports.ActionTableRenderer = ActionTableRenderer;
+function toNumeric(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function normalizeMemoryLabelEntries(memoryLabels) {
+    if (!memoryLabels) {
+        return [];
+    }
+    if (Array.isArray(memoryLabels)) {
+        const entries = [];
+        for (const labelObject of memoryLabels) {
+            for (const [label, value] of Object.entries(labelObject)) {
+                const numericValue = toNumeric(value);
+                if (numericValue !== undefined) {
+                    entries.push([label, numericValue]);
+                }
+            }
+        }
+        return entries;
+    }
+    return Object.entries(memoryLabels)
+        .map(([label, value]) => {
+        const numericValue = toNumeric(value);
+        return numericValue === undefined ? undefined : [label, numericValue];
+    })
+        .filter((entry) => entry !== undefined);
+}
+function formatMemoryLeakTable(memLeaks) {
+    const rows = normalizeMemoryLabelEntries(memLeaks.memoryLabels);
+    const allocated = memLeaks.allocatedMemory ?? 0;
+    const labelHeader = 'Label';
+    const sizeHeader = 'Size';
+    const totalLabel = 'Total';
+    const nonePlaceholder = '(none)';
+    const totalValueStr = allocated.toString();
+    const rowLabelWidth = rows.length > 0 ? Math.max(...rows.map(([label]) => label.length)) : nonePlaceholder.length;
+    const rowSizeWidth = rows.length > 0 ? Math.max(...rows.map(([, size]) => size.toString().length)) : 0;
+    const labelWidth = Math.max(labelHeader.length, totalLabel.length, rowLabelWidth);
+    const sizeWidth = Math.max(sizeHeader.length, totalValueStr.length, rowSizeWidth);
+    const columns = [labelWidth, sizeWidth];
+    const topBorder = buildBorderLine(columns, '┌', '┬', '┐');
+    const headerDivider = buildBorderLine(columns, '├', '┼', '┤');
+    const bottomBorder = buildBorderLine(columns, '└', '┴', '┘');
+    let output = 'Memory Leaks Detected:\n';
+    output += `${topBorder}\n`;
+    output += `│ ${labelHeader.padEnd(labelWidth)} │ ${sizeHeader.padStart(sizeWidth)} │\n`;
+    output += `${headerDivider}\n`;
+    if (rows.length === 0) {
+        output += `│ ${nonePlaceholder.padEnd(labelWidth)} │ ${''.padStart(sizeWidth)} │\n`;
+    }
+    else {
+        for (const [label, size] of rows) {
+            output += `│ ${label.padEnd(labelWidth)} │ ${size.toString().padStart(sizeWidth)} │\n`;
+        }
+    }
+    output += `${headerDivider}\n`;
+    output += `│ ${totalLabel.padEnd(labelWidth)} │ ${totalValueStr.padStart(sizeWidth)} │\n`;
+    output += `${bottomBorder}\n`;
+    return output;
+}
+function buildUtpLogPath(logPath) {
+    const parsed = path.parse(logPath);
+    const utpFileName = `utp-${parsed.name}.json`;
+    return parsed.dir ? path.join(parsed.dir, utpFileName) : utpFileName;
+}
+async function writeUtpTelemetryLog(filePath, entries, logger) {
+    try {
+        const content = `${JSON.stringify(entries, null, 2)}\n`;
+        await fs.promises.writeFile(filePath, content, 'utf8');
+    }
+    catch (error) {
+        logger.warn(`Failed to write UTP telemetry log (${filePath}): ${error}`);
+    }
+}
+/**
+ * Tails a log file using fs.watch and ReadStream for efficient reading.
+ * @param logPath The path to the log file to tail.
+ * @param projectPath The path to the project (used for log annotation).
+ * @returns An object containing the tail promise and signalEnd function.
+ */
+function TailLogFile(logPath, projectPath) {
+    let logEnded = false;
+    let lastSize = 0;
+    const logPollingInterval = 250;
+    const telemetry = [];
+    const logger = logging_1.Logger.instance;
+    const actionAccumulator = new ActionTelemetryAccumulator();
+    const actionTableRenderer = new ActionTableRenderer(process.stdout.isTTY === true && process.env.CI !== 'true');
+    const utpLogPath = buildUtpLogPath(logPath);
+    let telemetryFlushed = false;
+    const renderActionTable = () => {
+        const snapshot = actionAccumulator.snapshot();
+        if (snapshot) {
+            actionTableRenderer.render(snapshot);
+        }
+    };
+    const flushTelemetryLog = async () => {
+        if (telemetryFlushed) {
+            return;
+        }
+        telemetryFlushed = true;
+        await writeUtpTelemetryLog(utpLogPath, telemetry, logger);
+    };
+    const writeStdout = (content, restoreTable = true) => {
+        actionTableRenderer.prepareForContent();
+        process.stdout.write(content);
+        if (restoreTable) {
+            renderActionTable();
+        }
+    };
+    async function readNewLogContent() {
+        try {
+            if (!fs.existsSync(logPath)) {
+                return;
+            }
+            const stats = await fs.promises.stat(logPath);
+            if (stats.size < lastSize) {
+                lastSize = 0;
+            }
+            if (stats.size > lastSize) {
+                const bytesToRead = stats.size - lastSize;
+                const buffer = Buffer.alloc(bytesToRead);
+                let fh;
+                try {
+                    fh = await fs.promises.open(logPath, fs.constants.O_RDONLY);
+                    await fh.read(buffer, 0, bytesToRead, lastSize);
+                }
+                finally {
+                    await fh?.close();
+                }
+                lastSize = stats.size;
+                if (bytesToRead > 0) {
+                    const chunk = buffer.toString('utf8');
+                    // Parse telemetry lines in this chunk (lines starting with '##utp:')
+                    try {
+                        const lines = chunk.split(/\r?\n/);
+                        for (const rawLine of lines) {
+                            const line = rawLine.trim();
+                            if (!line) {
+                                continue;
+                            }
+                            // Attempt to parse telemetry utp JSON
+                            if (line.startsWith('##utp:')) {
+                                const jsonPart = line.substring('##utp:'.length).trim();
+                                try {
+                                    const sanitizedJson = sanitizeTelemetryJson(jsonPart);
+                                    if (!sanitizedJson) {
+                                        continue;
+                                    }
+                                    const utpJson = JSON.parse(sanitizedJson);
+                                    const utp = utpJson;
+                                    telemetry.push(utp);
+                                    if (utp.message && 'severity' in utp && (utp.severity === utp_1.Severity.Error || utp.severity === utp_1.Severity.Exception || utp.severity === utp_1.Severity.Assert)) {
+                                        let messageLevel = logging_1.LogLevel.ERROR;
+                                        if (remappedEditorLogs[utp.message] !== undefined) {
+                                            messageLevel = remappedEditorLogs[utp.message];
+                                        }
+                                        const file = utp.file ? utp.file.replace(/\\/g, '/') : undefined;
+                                        const lineNum = utp.line ? utp.line : undefined;
+                                        const message = utp.message;
+                                        const stacktrace = utp.stacktrace ? `${utp.stacktrace}` : undefined;
+                                        if (!annotationPrefixRegex.test(message)) {
+                                            // only annotate if the file is within the current project
+                                            if (projectPath && file && file.startsWith(projectPath)) {
+                                                logger.annotate(logging_1.LogLevel.ERROR, stacktrace == undefined ? message : `${message}\n${stacktrace}`, file, lineNum);
+                                            }
+                                            else {
+                                                switch (messageLevel) {
+                                                    case logging_1.LogLevel.WARN:
+                                                        logger.warn(stacktrace == undefined ? message : `${message}\n${stacktrace}`);
+                                                        break;
+                                                    case logging_1.LogLevel.ERROR:
+                                                        logger.error(stacktrace == undefined ? message : `${message}\n${stacktrace}`);
+                                                        break;
+                                                    case logging_1.LogLevel.INFO:
+                                                    default:
+                                                        logger.info(stacktrace == undefined ? message : `${message}\n${stacktrace}`);
+                                                        break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        // switch utp types, fallback to json if we don't have a toString() implementation or a type implementation
+                                        switch (utp.type) {
+                                            case 'Action': {
+                                                const actionEntry = utp;
+                                                const tableChanged = actionAccumulator.record(actionEntry);
+                                                if (tableChanged) {
+                                                    renderActionTable();
+                                                }
+                                                break;
+                                            }
+                                            case 'MemoryLeaks':
+                                                logger.debug(formatMemoryLeakTable(utp));
+                                                break;
+                                            case 'PlayerBuildInfo': {
+                                                const infoEntry = utp;
+                                                const changed = actionAccumulator.recordPlayerBuildInfo(infoEntry);
+                                                if (changed) {
+                                                    renderActionTable();
+                                                }
+                                                break;
+                                            }
+                                            default:
+                                                // Print raw JSON for unhandled UTP types
+                                                writeStdout(`${jsonPart}\n`);
+                                                break;
+                                        }
+                                    }
+                                }
+                                catch (error) {
+                                    logger.warn(`Failed to parse telemetry JSON: ${error} -- raw: ${jsonPart}`);
+                                }
+                            }
+                            else {
+                                if (logging_1.Logger.instance.logLevel !== logging_1.LogLevel.UTP) {
+                                    writeStdout(`${line}\n`);
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        if (error.code !== 'EPIPE') {
+                            throw error;
+                        }
+                        logger.warn(`Error while parsing telemetry from log chunk: ${error}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Error while tailing log file: ${error}`);
+        }
+    }
+    const tailPromise = new Promise((resolve, reject) => {
+        (async () => {
+            try {
+                while (!logEnded) {
+                    await (0, utilities_1.Delay)(logPollingInterval);
+                    await readNewLogContent();
+                }
+                // Final read to capture any remaining content after tailing stops
+                await (0, utilities_1.WaitForFileToBeUnlocked)(logPath, 10_000);
+                await readNewLogContent();
+                try {
+                    // write a final newline to separate log output
+                    writeStdout('\n');
+                }
+                catch (error) {
+                    if (error.code !== 'EPIPE') {
+                        logger.warn(`Error while writing log tail: ${error}`);
+                    }
+                }
+                await flushTelemetryLog();
+                resolve();
+            }
+            catch (error) {
+                await flushTelemetryLog();
+                reject(error);
+            }
+        })();
+    });
+    function stopLogTail() {
+        logEnded = true;
+    }
+    return { tailPromise, stopLogTail, telemetry };
+}
+//# sourceMappingURL=unity-logging.js.map