fix: Reassemble USB chunks into complete lines before logging

Raw USB chunks were logged individually, causing lines to break at
arbitrary byte boundaries (mid-word) wherever the FTDI chip's 16ms
latency timer flushed its buffer. Both the debug logger and headless
file logger now accumulate incoming text and only write complete lines
once a CR/LF boundary is confirmed or a 50ms idle timeout expires.

Bump version to 0.9.21 for release.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ironsheep

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to PNut-Term-TS will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.21] - 2026-03-06
+
+### Fixed
+
+- **Mid-word line splits in log files** - Raw USB chunks were logged individually, causing lines to break at arbitrary byte boundaries (mid-word, mid-number) wherever the FTDI chip's 16ms latency timer flushed its buffer
+  - Both the debug logger and headless file logger now reassemble USB chunks into complete logical lines before writing, holding partial data until a CR/LF boundary is confirmed or a 50ms idle timeout expires
+  - Each reassembled line is individually timestamped, eliminating both mid-word splits and mid-line timestamp collisions
+
 ## [0.9.20] - 2026-03-06
 
 ### Fixed

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pnut-term-ts",
-  "version": "0.9.20",
+  "version": "0.9.21",
   "description": "A recreation of Chips' Debug listener but multiplatform combined with PST and downloader",
   "keywords": [
     "cli",

package.json

@@ -82,6 +82,11 @@ export class LoggerWindow extends DebugWindowBase {
   private logFileReady: boolean = false;
   private rendererReady: boolean = false; // Track when renderer DOM is ready for IPC
 
+  // Line reassembly: accumulate partial chunks until CR/LF confirms a complete line
+  private logLineAccumulator: string = '';
+  private logLineFlushTimer: NodeJS.Timeout | null = null;
+  private readonly LOG_LINE_FLUSH_TIMEOUT_MS = 50; // Flush partial lines after 50ms idle
+
   // Performance warning tracking
   private performanceMonitor: PerformanceMonitor | null = null;
   private warningHistory: PerformanceWarning[] = [];
@@ -1184,24 +1189,64 @@ export class LoggerWindow extends DebugWindowBase {
   }
 
   /**
-   * Write message to log file (buffered for performance)
+   * Write message to log file with line reassembly.
+   * Accumulates partial chunks until CR/LF confirms a complete line,
+   * so each log entry corresponds to a logical line — no mid-word splits.
    * RACE CONDITION FIX: Buffer messages if log file isn't ready yet
    */
   private writeToLog(message: string): void {
+    // Accumulate text and extract complete lines (terminated by \n or \r\n)
+    this.logLineAccumulator += message;
+
+    // Reset idle timer on every chunk
+    if (this.logLineFlushTimer) {
+      clearTimeout(this.logLineFlushTimer);
+    }
+
+    // Extract and write all complete lines
+    let newlineIdx: number;
+    while ((newlineIdx = this.logLineAccumulator.indexOf('\n')) !== -1) {
+      const line = this.logLineAccumulator.substring(0, newlineIdx + 1);
+      this.logLineAccumulator = this.logLineAccumulator.substring(newlineIdx + 1);
+      this.writeLogEntry(line);
+    }
+
+    // If there's remaining text without a newline, start idle timer to flush it
+    if (this.logLineAccumulator.length > 0) {
+      this.logLineFlushTimer = setTimeout(() => this.flushLogLineAccumulator(), this.LOG_LINE_FLUSH_TIMEOUT_MS);
+    }
+  }
+
+  /**
+   * Flush any partial line remaining in the accumulator (on idle timeout or shutdown)
+   */
+  private flushLogLineAccumulator(): void {
+    if (this.logLineFlushTimer) {
+      clearTimeout(this.logLineFlushTimer);
+      this.logLineFlushTimer = null;
+    }
+    if (this.logLineAccumulator.length > 0) {
+      this.writeLogEntry(this.logLineAccumulator);
+      this.logLineAccumulator = '';
+    }
+  }
+
+  /**
+   * Write a single reassembled line to the log file with timestamp.
+   */
+  private writeLogEntry(message: string): void {
     const timestamp = getFormattedDateTimeISO();
-    // Strip trailing CR/LF from message before logging (messages arrive with line endings from P2)
+    // Strip trailing CR/LF from the reassembled line
     const cleanMessage = message.replace(/[\r\n]+$/, '');
-    // Timestamp every line individually to prevent mid-line timestamps in log output
-    const lines = cleanMessage.split(/\r?\n/);
-    const logEntry = lines.map((line) => `[${timestamp}] ${line}\n`).join('');
+    const logEntry = `[${timestamp}] ${cleanMessage}\n`;
 
     if (this.logFileReady && this.logFile) {
       // Log file is ready - write normally
       this.writeBuffer.push(logEntry);
 
       // Log first few writes to confirm it's working
       if (this.writeBuffer.length <= 3) {
-        const truncated = message.length > 80 ? message.substring(0, 80) + '...' : message;
+        const truncated = cleanMessage.length > 80 ? cleanMessage.substring(0, 80) + '...' : cleanMessage;
         this.logConsoleMessage('[DEBUG LOGGER] Added to write buffer:', truncated);
       }
 
@@ -1211,22 +1256,21 @@ export class LoggerWindow extends DebugWindowBase {
       }
 
       // Force flush only if buffer is getting large (4KB)
-      // Removed the "|| this.writeBuffer.length === 1" condition that was causing every message to flush immediately
       if (this.writeBuffer.join('').length > 4096) {
         this.flushWriteBuffer();
       }
     } else {
       // Log file not ready yet - buffer the message for later
       this.pendingLogMessages.push(logEntry);
       this.logConsoleMessage(
-        `[DEBUG LOGGER] 📦 Buffered message (log file not ready): ${message.substring(0, 50)}${
-          message.length > 50 ? '...' : ''
+        `[DEBUG LOGGER] Buffered message (log file not ready): ${cleanMessage.substring(0, 50)}${
+          cleanMessage.length > 50 ? '...' : ''
         }`
       );
 
       // Limit buffer size to prevent memory issues
       if (this.pendingLogMessages.length > 1000) {
-        console.warn('[DEBUG LOGGER] ⚠️ Pending message buffer full, dropping oldest messages');
+        console.warn('[DEBUG LOGGER] Pending message buffer full, dropping oldest messages');
         this.pendingLogMessages.splice(0, 100); // Remove oldest 100 messages
       }
     }
@@ -1548,6 +1592,9 @@ export class LoggerWindow extends DebugWindowBase {
       this.processBatch();
     }
 
+    // Flush any partial line waiting for more data
+    this.flushLogLineAccumulator();
+
     // Flush any pending writes
     if (this.writeTimer) {
       clearTimeout(this.writeTimer);

src/classes/loggerWin.ts

@@ -30,6 +30,11 @@ export class HeadlessFileLogger {
   private readonly WRITE_INTERVAL_MS = 100; // Flush every 100ms
   private readonly MAX_BUFFER_SIZE = 4096; // Force flush at 4KB
 
+  // Line reassembly: accumulate partial USB chunks until CR/LF confirms a complete line
+  private lineAccumulator: string = '';
+  private lineFlushTimer: NodeJS.Timeout | null = null;
+  private readonly LINE_FLUSH_TIMEOUT_MS = 50; // Flush partial lines after 50ms idle
+
   // Callback for end-marker detection
   private onEndMarkerDetected: (() => void) | null = null;
   private endMarkers: string[] = [];
@@ -127,11 +132,11 @@ export class HeadlessFileLogger {
   }
 
   /**
-   * Log a message from serial data
+   * Log a message from serial data.
+   * Reassembles arbitrary USB chunks into complete lines before writing,
+   * so each log entry corresponds to a logical line (CR/LF terminated).
    */
   public logMessage(message: string): void {
-    this.writeToLog(message);
-
     // Check for end-markers using rolling buffer to handle markers split across chunks
     // (serial data arrives in arbitrary-sized chunks that can split marker strings)
     if (this.endMarkers.length > 0 && this.onEndMarkerDetected) {
@@ -140,6 +145,8 @@ export class HeadlessFileLogger {
       for (const marker of this.endMarkers) {
         if (this.markerSearchBuffer.includes(marker)) {
           console.log(`[HEADLESS] End marker "${marker}" detected!`);
+          // Flush any accumulated partial line before shutdown
+          this.flushLineAccumulator();
           this.logSystem(`End marker "${marker}" detected - initiating shutdown`);
           this.onEndMarkerDetected();
           return;
@@ -151,6 +158,42 @@ export class HeadlessFileLogger {
         this.markerSearchBuffer = this.markerSearchBuffer.slice(-(this.maxMarkerLength - 1));
       }
     }
+
+    // Accumulate text and extract complete lines (terminated by \n or \r\n)
+    this.lineAccumulator += message;
+
+    // Reset idle timer on every chunk
+    if (this.lineFlushTimer) {
+      clearTimeout(this.lineFlushTimer);
+    }
+
+    // Extract and write all complete lines
+    let newlineIdx: number;
+    while ((newlineIdx = this.lineAccumulator.indexOf('\n')) !== -1) {
+      // Extract line including the \n
+      let line = this.lineAccumulator.substring(0, newlineIdx + 1);
+      this.lineAccumulator = this.lineAccumulator.substring(newlineIdx + 1);
+      this.writeToLog(line);
+    }
+
+    // If there's remaining text without a newline, start idle timer to flush it
+    if (this.lineAccumulator.length > 0) {
+      this.lineFlushTimer = setTimeout(() => this.flushLineAccumulator(), this.LINE_FLUSH_TIMEOUT_MS);
+    }
+  }
+
+  /**
+   * Flush any partial line remaining in the accumulator (on idle timeout or shutdown)
+   */
+  private flushLineAccumulator(): void {
+    if (this.lineFlushTimer) {
+      clearTimeout(this.lineFlushTimer);
+      this.lineFlushTimer = null;
+    }
+    if (this.lineAccumulator.length > 0) {
+      this.writeToLog(this.lineAccumulator);
+      this.lineAccumulator = '';
+    }
   }
 
   /**
@@ -198,11 +241,9 @@ export class HeadlessFileLogger {
    */
   private writeToLog(message: string): void {
     const timestamp = getFormattedDateTimeISO();
-    // Strip trailing CR/LF from message before logging
+    // Strip trailing CR/LF — line reassembly in logMessage() ensures single logical lines
     const cleanMessage = message.replace(/[\r\n]+$/, '');
-    // Timestamp every line individually to prevent mid-line timestamps in log output
-    const lines = cleanMessage.split(/\r?\n/);
-    const logEntry = lines.map((line) => `[${timestamp}] ${line}\n`).join('');
+    const logEntry = `[${timestamp}] ${cleanMessage}\n`;
 
     if (this.logFileReady && this.logFile) {
       // Log file is ready - write normally
@@ -273,6 +314,9 @@ export class HeadlessFileLogger {
    * Close the log file gracefully
    */
   public close(): void {
+    // Flush any partial line waiting for more data
+    this.flushLineAccumulator();
+
     // Flush any remaining data
     this.flushWriteBuffer();