tasmota-esp-web-tools 12.1.1 → 12.2.0

package/README.md

@@ -108,6 +108,36 @@ The `chipVariant` field is optional. If omitted, the build will match any varian
 
 See [manifest-example-p4-variants.json](manifest-example-p4-variants.json) for a complete example.
 
+## Flash Size Support
+
+For chips with different flash sizes, you can specify `flashSizeMB` to target specific hardware configurations. This is useful for ESP32-S3 modules that come with various flash sizes.
+
+```json
+{
+  "name": "My Firmware",
+  "builds": [
+    {
+      "chipFamily": "ESP32-S3",
+      "flashSizeMB": 16,
+      "parts": [{ "path": "s3-16mb.bin", "offset": 0 }]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "flashSizeMB": 4,
+      "parts": [{ "path": "s3-4mb.bin", "offset": 0 }]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "parts": [{ "path": "s3-generic.bin", "offset": 0 }]
+    }
+  ]
+}
+```
+
+A device with ESP32-S3 and 16MB flash gets the first build, 4MB gets the second, and any other ESP32-S3 falls back to the third.
+
+The `flashSizeMB` field is **optional**. If omitted, the build will match any flash size. Builds with matching `flashSizeMB` are preferred over builds without it (most-specific-matching algorithm).
+
 ## Performance
 
 ESP Web Tools supports configurable baud rates for flashing. By default, it uses 115200 baud for maximum compatibility. You can increase the baud rate for significantly faster flashing speeds.

package/dist/components/ew-littlefs-manager.js

@@ -20,11 +20,13 @@ async function loadLittleFS() {
     try {
         // Try to import from the calculated path
         const indexUrl = _wasmBasePath + "index.js";
+        // eslint-disable-next-line no-console
         console.log("[LittleFS] Loading module from:", indexUrl);
         _littleFSModule = await import(/* @vite-ignore */ indexUrl);
         return _littleFSModule;
     }
     catch (err) {
+        // eslint-disable-next-line no-console
         console.error("[LittleFS] Failed to load from calculated path:", _wasmBasePath, err);
         // Fallback to relative import (for local development)
         try {
@@ -32,6 +34,7 @@ async function loadLittleFS() {
             return _littleFSModule;
         }
         catch (fallbackErr) {
+            // eslint-disable-next-line no-console
             console.error("[LittleFS] Fallback import also failed:", fallbackErr);
             throw new Error(`Failed to load LittleFS module: ${err}`);
         }
@@ -105,7 +108,7 @@ let EwtLittleFSManager = class EwtLittleFSManager extends LitElement {
                     this.logger.log(`Successfully mounted LittleFS with block size ${bs}`);
                     break;
                 }
-                catch (err) {
+                catch (_err) {
                     // Try next block size
                     fs = null;
                 }
@@ -125,7 +128,7 @@ let EwtLittleFSManager = class EwtLittleFSManager extends LitElement {
                     this._diskVersion = "Unknown";
                 }
             }
-            catch (e) {
+            catch (_e) {
                 this._diskVersion = "Unknown";
             }
             this._refreshFiles();
@@ -238,7 +241,7 @@ let EwtLittleFSManager = class EwtLittleFSManager extends LitElement {
                     try {
                         this._fs.mkdir(built);
                     }
-                    catch (e) {
+                    catch (_e) {
                         // Ignore if directory already exists
                     }
                 }
@@ -397,12 +400,7 @@ let EwtLittleFSManager = class EwtLittleFSManager extends LitElement {
     }
     _cleanup() {
         if (this._fs) {
-            try {
-                // Don't call destroy() - just let garbage collection handle it
-            }
-            catch (e) {
-                console.error("Error cleaning up LittleFS:", e);
-            }
+            // Don't call destroy() - just let garbage collection handle it
             this._fs = null;
         }
     }

package/dist/connect.js

@@ -50,6 +50,7 @@ export const connect = async (button) => {
         esploader = await esptoolConnect({
             log: () => { }, // Silent logger for connection
             debug: () => { },
+            // eslint-disable-next-line no-console
             error: (msg) => console.error(msg),
         });
     }
@@ -85,7 +86,7 @@ export const connect = async (button) => {
         try {
             await esploader.disconnect();
         }
-        catch (err) {
+        catch (_err) {
             // Ignore disconnect errors
         }
     }, { once: true });

package/dist/const.d.ts

@@ -6,6 +6,7 @@ export interface Logger {
 export interface Build {
     chipFamily: "ESP32" | "ESP8266" | "ESP32-S2" | "ESP32-S3" | "ESP32-C2" | "ESP32-C3" | "ESP32-C5" | "ESP32-C6" | "ESP32-C61" | "ESP32-H2" | "ESP32-P4";
     chipVariant?: string;
+    flashSizeMB?: number;
     parts: {
         path: string;
         offset: number;
@@ -29,6 +30,7 @@ export interface BaseFlashState {
     build?: Build;
     chipFamily?: Build["chipFamily"] | "Unknown Chip";
     chipVariant?: string | null;
+    flashSize?: string;
 }
 export interface InitializingState extends BaseFlashState {
     state: FlashStateType.INITIALIZING;

package/dist/flash.d.ts

@@ -1,4 +1,4 @@
 import { Logger } from "tasmota-webserial-esptool";
 import { FlashState } from "./const";
 export declare const flash: (onEvent: (state: FlashState) => void, esploader: any, // ESPLoader instance from tasmota-webserial-esptool
-logger: Logger, manifestPath: string, eraseFirst: boolean, firmwareBuffer: Uint8Array, baudRate?: number) => Promise<void>;
+logger: Logger, manifestPath: string, eraseFirst: boolean, firmwareBuffer: Uint8Array, _baudRate?: number) => Promise<void>;

package/dist/flash.js

@@ -1,21 +1,77 @@
 import { getChipFamilyName } from "./util/chip-family-name";
 import { sleep } from "./util/sleep";
 import { corsProxyFetch } from "./util/cors-proxy";
+/**
+ * Parse flash size string (e.g., "4MB", "8MB", "16MB") to megabytes number
+ */
+function parseFlashSizeToMB(flashSize) {
+    if (!flashSize)
+        return undefined;
+    const match = flashSize.match(/^(\d+)(MB|GB)$/);
+    if (!match)
+        return undefined;
+    const size = parseInt(match[1], 10);
+    const unit = match[2];
+    if (unit === "GB")
+        return size * 1024;
+    return size;
+}
+/**
+ * Select the best build using most-specific-matching algorithm
+ * - Builds with matching flashSizeMB are preferred
+ * - Among builds with same specificity, first one wins
+ * - Builds without flashSizeMB are fallback options
+ */
+function selectBestBuild(builds, detectedFlashSizeMB) {
+    if (builds.length === 0)
+        return undefined;
+    // Score builds: higher score = more specific match
+    let bestBuild;
+    let bestScore = -Infinity;
+    for (const build of builds) {
+        let score = 0;
+        // Flash size match gives highest priority
+        if (build.flashSizeMB !== undefined && detectedFlashSizeMB !== undefined) {
+            if (build.flashSizeMB === detectedFlashSizeMB) {
+                score += 100; // Exact flash size match
+            }
+            else {
+                score -= 1; // Penalize non-matching specific builds
+            }
+        }
+        else if (build.flashSizeMB !== undefined) {
+            // flashSizeMB is defined but detectedFlashSizeMB is undefined
+            score -= 1; // Penalize non-matching specific builds
+        }
+        // Generic builds (flashSizeMB undefined) stay at score 0
+        // Prefer this build if it has higher score
+        // If same score, keep the first one (stable selection)
+        if (score > bestScore) {
+            bestScore = score;
+            bestBuild = build;
+        }
+    }
+    return bestScore >= 0 ? bestBuild : undefined;
+}
 export const flash = async (onEvent, esploader, // ESPLoader instance from tasmota-webserial-esptool
-logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
+logger, manifestPath, eraseFirst, firmwareBuffer, _baudRate) => {
     let manifest;
     let build;
+    // eslint-disable-next-line prefer-const
     let chipFamily;
     let chipVariant = null;
+    // eslint-disable-next-line prefer-const
+    let flashSize;
     const fireStateEvent = (stateUpdate) => onEvent({
         ...stateUpdate,
         manifest,
         build,
         chipFamily,
         chipVariant,
+        flashSize,
     });
-    var manifestProm = null;
-    var manifestURL = "";
+    let manifestProm = null;
+    let manifestURL = "";
     try {
         manifestProm = JSON.parse(manifestPath);
     }
@@ -51,9 +107,20 @@ logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
     }
     chipFamily = getChipFamilyName(esploader);
     chipVariant = esploader.chipVariant;
+    // Detect flash size if not already detected
+    if (!esploader.flashSize && esploader.detectFlashSize) {
+        try {
+            await esploader.detectFlashSize();
+        }
+        catch (err) {
+            logger.debug("Failed to detect flash size:", err);
+        }
+    }
+    flashSize = esploader.flashSize; // e.g., "4MB", "8MB"
+    const flashSizeMB = flashSize ? parseFlashSizeToMB(flashSize) : undefined;
     fireStateEvent({
         state: "initializing" /* FlashStateType.INITIALIZING */,
-        message: `Initialized. Found ${chipFamily}${chipVariant ? ` (${chipVariant})` : ""}`,
+        message: `Initialized. Found ${chipFamily}${chipVariant ? ` (${chipVariant})` : ""}${flashSize ? `, ${flashSize}` : ""}`,
         details: { done: true },
     });
     fireStateEvent({
@@ -73,17 +140,24 @@ logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
         await esploader.disconnect();
         return;
     }
-    build = manifest.builds.find((b) => {
-        // Match chipFamily and optionally chipVariant
+    // Filter builds by chipFamily and chipVariant
+    const compatibleBuilds = manifest.builds.filter((b) => {
         if (b.chipFamily !== chipFamily) {
             return false;
         }
-        // If build specifies chipVariant, it must match
         if (b.chipVariant && b.chipVariant !== chipVariant) {
             return false;
         }
         return true;
     });
+    // Select the best build using most-specific-matching algorithm
+    // Prefer builds with more matching qualifiers (flashSizeMB)
+    const exactVariantBuilds = compatibleBuilds.filter((b) => b.chipVariant !== undefined && b.chipVariant === chipVariant);
+    const variantAgnosticBuilds = compatibleBuilds.filter((b) => b.chipVariant === undefined);
+    build = selectBestBuild(exactVariantBuilds, flashSizeMB);
+    if (!build) {
+        build = selectBestBuild(variantAgnosticBuilds, flashSizeMB);
+    }
     if (!build) {
         fireStateEvent({
             state: "error" /* FlashStateType.ERROR */,
@@ -198,7 +272,7 @@ logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
         for (let i = 0; i < build.parts.length; i++) {
             const part = build.parts[i];
             const data = files[i];
-            await espStub.flashData(data, (bytesWritten, bytesTotal) => {
+            await espStub.flashData(data, (bytesWritten, _bytesTotal) => {
                 const newPct = Math.floor(((totalBytesWritten + bytesWritten) / totalSize) * 100);
                 if (newPct === lastPct) {
                     return;

package/dist/install-dialog.d.ts

@@ -45,12 +45,14 @@ export declare class EwtInstallDialog extends LitElement {
     private _consoleInitialized;
     private _improvSupported;
     private _isUsbJtagOrOtgDevice;
+    private _flashSize?;
     private _openConsoleAfterReconnect;
     private _visitDeviceAfterReconnect;
     private _addToHAAfterReconnect;
     private _changeWiFiAfterReconnect;
     private _ensureStub;
     private get _port();
+    private _probeFlashSize;
     private _isUsbJtagOrOtg;
     private _isWebUsbWithExternalSerial;
     private _releaseReaderWriter;

package/dist/install-dialog.js

@@ -57,6 +57,8 @@ export class EwtInstallDialog extends LitElement {
         this._handleDisconnect = () => {
             this._state = "ERROR";
             this._error = "Disconnected";
+            // Reset flash size when device is actually disconnected
+            this._flashSize = undefined;
         };
     }
     // Ensure stub is initialized (called before any operation that needs it)
@@ -116,6 +118,8 @@ export class EwtInstallDialog extends LitElement {
         const espStub = await this.esploader.runStub();
         this.logger.log(`Stub created: IS_STUB=${espStub.IS_STUB}, chipFamily=${getChipFamilyName(espStub)}`);
         this._espStub = espStub;
+        // Detect flash size AFTER stub creation (flash size is only available after stub)
+        await this._probeFlashSize(espStub);
         // Set baudrate BEFORE any operations (use user-selected baudrate if available)
         if (this.baudRate && this.baudRate > 115200) {
             this.logger.log(`Setting baudrate to ${this.baudRate}...`);
@@ -138,6 +142,19 @@ export class EwtInstallDialog extends LitElement {
     get _port() {
         return this.esploader.port;
     }
+    // Helper to probe flash size from a running stub (only available after stub)
+    async _probeFlashSize(espStub) {
+        if (espStub.detectFlashSize && !this._flashSize) {
+            try {
+                await espStub.detectFlashSize();
+                this._flashSize = espStub.flashSize;
+                this.logger.log(`Flash size detected: ${this._flashSize}`);
+            }
+            catch (err) {
+                this.logger.debug("Failed to detect flash size:", err);
+            }
+        }
+    }
     // Helper to check if device is using USB-JTAG or USB-OTG (not external serial chip)
     async _isUsbJtagOrOtg() {
         // Use detectUsbConnectionType from tasmota-webserial-esptool
@@ -504,16 +521,17 @@ export class EwtInstallDialog extends LitElement {
     }
     _renderDashboard() {
         const heading = this._info.name;
-        let content;
-        let hideActions = true;
-        let allowClosing = true;
-        content = html `
+        const hideActions = true;
+        const allowClosing = true;
+        const content = html `
       <ew-list>
         <ew-list-item>
           <div slot="headline">Connected to ${this._info.name}</div>
           <div slot="supporting-text">
             ${this._info.firmware}&nbsp;${this._info.version}
-            (${this._info.chipFamily})
+            (${this._info.chipFamily}${this._flashSize
+            ? `, ${this._flashSize}`
+            : ""})
           </div>
         </ew-list-item>
         ${!this._isSameVersion
@@ -827,11 +845,25 @@ export class EwtInstallDialog extends LitElement {
     }
     _renderDashboardNoImprov() {
         const heading = "Device Dashboard";
-        let content;
-        let hideActions = true;
-        let allowClosing = true;
-        content = html `
+        const hideActions = true;
+        const allowClosing = true;
+        // Build device info string if available
+        const chipFamily = this.esploader.chipFamily
+            ? getChipFamilyName(this.esploader)
+            : null;
+        const deviceInfo = chipFamily
+            ? `(${chipFamily}${this._flashSize ? `, ${this._flashSize}` : ""})`
+            : null;
+        const content = html `
       <ew-list>
+        ${deviceInfo
+            ? html `
+              <ew-list-item>
+                <div slot="headline">${chipFamily}</div>
+                <div slot="supporting-text">${deviceInfo}</div>
+              </ew-list-item>
+            `
+            : ""}
         <ew-list-item
           type="button"
           ?disabled=${this._busy}
@@ -1099,8 +1131,8 @@ export class EwtInstallDialog extends LitElement {
                 case 3 /* ImprovSerialErrorState.UNABLE_TO_CONNECT */:
                     error = "Unable to connect";
                     break;
+                // UNKNOWN_RPC_COMMAND happens when list SSIDs not supported.
                 case 0 /* ImprovSerialErrorState.NO_ERROR */:
-                // Happens when list SSIDs not supported.
                 case 2 /* ImprovSerialErrorState.UNKNOWN_RPC_COMMAND */:
                     break;
                 default:
@@ -1219,6 +1251,7 @@ export class EwtInstallDialog extends LitElement {
         return [heading, content];
     }
     _renderInstall() {
+        var _a, _b, _c;
         let heading;
         let content;
         let hideActions = false;
@@ -1247,11 +1280,20 @@ export class EwtInstallDialog extends LitElement {
         else if (!this._installConfirmed) {
             heading = "Confirm Installation";
             const action = isUpdate ? "update to" : "install";
+            // Build device info with flash size if available
+            const deviceInfo = this._flashSize
+                ? html ` (${((_a = this._info) === null || _a === void 0 ? void 0 : _a.chipFamily) || ""}${((_b = this._info) === null || _b === void 0 ? void 0 : _b.chipFamily)
+                    ? `, ${this._flashSize}`
+                    : this._flashSize})`
+                : "";
             content = html `
         ${isUpdate
                 ? html `Your device is running
-              ${this._info.firmware}&nbsp;${this._info.version}.<br /><br />`
-                : ""}
+              ${this._info.firmware}&nbsp;${this._info
+                    .version}${deviceInfo}.<br /><br />`
+                : deviceInfo
+                    ? html `Device detected: ${deviceInfo}<br /><br />`
+                    : ""}
         Do you want to ${action}
         ${this._manifest.name}&nbsp;${this._manifest.version}?
         ${this._installErase
@@ -1274,7 +1316,11 @@ export class EwtInstallDialog extends LitElement {
             this._installState.state === "manifest" /* FlashStateType.MANIFEST */ ||
             this._installState.state === "preparing" /* FlashStateType.PREPARING */) {
             heading = "Installing";
-            content = this._renderProgress("Preparing installation");
+            // Show flash size in preparing message if available
+            const preparingMsg = ((_c = this._installState) === null || _c === void 0 ? void 0 : _c.flashSize)
+                ? `Preparing installation (${this._installState.flashSize})`
+                : "Preparing installation";
+            content = this._renderProgress(preparingMsg);
             hideActions = true;
         }
         else if (this._installState.state === "erasing" /* FlashStateType.ERASING */) {
@@ -1354,10 +1400,9 @@ export class EwtInstallDialog extends LitElement {
         return [heading, content, hideActions, allowClosing];
     }
     _renderLogs() {
-        let heading = `Logs`;
-        let content;
-        let hideActions = false;
-        content = html `
+        const heading = `Logs`;
+        const hideActions = false;
+        const content = html `
       <ew-console
         .port=${this._port}
         .logger=${this.logger}
@@ -1422,7 +1467,22 @@ export class EwtInstallDialog extends LitElement {
       `;
         }
         else {
+            // Build device info with flash size for partition view
+            const chipFamily = this.esploader.chipFamily
+                ? getChipFamilyName(this.esploader)
+                : null;
+            const deviceInfo = chipFamily
+                ? `${chipFamily}${this._flashSize ? `, ${this._flashSize}` : ""}`
+                : null;
             content = html `
+        ${deviceInfo
+                ? html `<div
+              class="device-info"
+              style="margin-bottom: 16px; font-size: 14px; color: var(--md-sys-color-on-surface-variant, #666);"
+            >
+              Device: ${deviceInfo}
+            </div>`
+                : ""}
         <div class="partition-list">
           <table class="partition-table">
             <thead>
@@ -1632,7 +1692,7 @@ export class EwtInstallDialog extends LitElement {
         try {
             ssids = await this._client.scan();
         }
-        catch (err) {
+        catch (_err) {
             // When we fail while loading, pick "Join other"
             if (this._ssids === undefined) {
                 this._ssids = null;
@@ -1720,7 +1780,7 @@ export class EwtInstallDialog extends LitElement {
             try {
                 this._manifest = await downloadManifest(this.manifestPath);
             }
-            catch (err) {
+            catch (_err) {
                 this._state = "ERROR";
                 this._error = "Failed to download manifest";
                 this._busy = false;
@@ -1786,6 +1846,8 @@ export class EwtInstallDialog extends LitElement {
                         this._espStub = await this.esploader.runStub();
                         this.logger.log(`Stub created: IS_STUB=${this._espStub.IS_STUB}`);
                     }
+                    // Detect flash size after stub is running
+                    await this._probeFlashSize(this._espStub);
                     // CRITICAL: Save parent loader
                     const loaderToSave = this._espStub._parent || this._espStub;
                     this._savedLoaderBeforeConsole = loaderToSave;
@@ -2094,7 +2156,7 @@ export class EwtInstallDialog extends LitElement {
         try {
             await this._client.provision(ssid, password);
         }
-        catch (err) {
+        catch (_err) {
             return;
         }
         finally {
@@ -2500,6 +2562,8 @@ export class EwtInstallDialog extends LitElement {
             await this._closeClientWithoutEvents(this._client);
         }
         document.body.style.overflow = (_a = this._bodyOverflow) !== null && _a !== void 0 ? _a : "";
+        // Reset flash size when dialog is closed
+        this._flashSize = undefined;
         fireEvent(this, "closed");
         this.parentNode.removeChild(this);
     }
@@ -2689,4 +2753,7 @@ __decorate([
 __decorate([
     state()
 ], EwtInstallDialog.prototype, "_isUsbJtagOrOtgDevice", void 0);
+__decorate([
+    state()
+], EwtInstallDialog.prototype, "_flashSize", void 0);
 customElements.define("ewt-install-dialog", EwtInstallDialog);

package/dist/util/cors-proxy.js

@@ -32,7 +32,7 @@ export const corsProxyFetch = async (url, options) => {
         // GitHub releases don't support CORS, use proxy directly
         if (url.includes("github.com") && url.includes("/releases/download/")) {
             const proxiedUrl = `${CORS_PROXY}/?url=${encodeURIComponent(url)}`;
-            const { headers, credentials, ...safeOptions } = options !== null && options !== void 0 ? options : {};
+            const { headers: _headers, credentials: _credentials, ...safeOptions } = options !== null && options !== void 0 ? options : {};
             return fetch(proxiedUrl, safeOptions);
         }
         // Try direct fetch first for other cross-origin requests
@@ -44,10 +44,10 @@ export const corsProxyFetch = async (url, options) => {
             // Direct fetch failed, try proxy
             try {
                 const proxiedUrl = `${CORS_PROXY}/?url=${encodeURIComponent(url)}`;
-                const { headers, credentials, ...safeOptions } = options !== null && options !== void 0 ? options : {};
+                const { headers: _headers, credentials: _credentials, ...safeOptions } = options !== null && options !== void 0 ? options : {};
                 return await fetch(proxiedUrl, safeOptions);
             }
-            catch (proxyError) {
+            catch (_proxyError) {
                 // Both failed, throw the original error
                 throw directError;
             }

package/dist/util/line-break-transformer.js

@@ -11,7 +11,9 @@ export class LineBreakTransformer {
         let lastIndex = 0;
         let match;
         while ((match = re.exec(this.chunks)) !== null) {
-            if (match[0] === "\r" && re.lastIndex === this.chunks.length) {
+            // If this is a lone \r at the very end of the buffer, leave it so it can
+            // be combined with a possible following \n in the next chunk.
+            if (match[0] === "\r" && match.index === this.chunks.length - 1) {
                 break;
             }
             const line = this.chunks.substring(lastIndex, match.index);

package/dist/util/manifest.js

@@ -7,6 +7,7 @@ export const downloadManifest = async (manifestPath) => {
     }
     const manifest = await resp.json();
     if ("new_install_skip_erase" in manifest) {
+        // eslint-disable-next-line no-console
         console.warn('Manifest option "new_install_skip_erase" is deprecated. Use "new_install_prompt_erase" instead.');
         if (manifest.new_install_skip_erase) {
             manifest.new_install_prompt_erase = true;

package/dist/util/partition.js

@@ -35,7 +35,7 @@ export async function detectFilesystemType(espStub, offset, size, logger = conso
                         }
                     }
                 }
-                catch (e) {
+                catch (_e) {
                     // Continue checking other methods
                 }
             }

package/dist/util/timestamp-transformer.js

@@ -7,6 +7,9 @@
 //   [HH:MM:SS.mmm]    wall-clock bracket with millis
 //   HH:MM:SS.mmm      plain wall-clock
 const DEVICE_TIMESTAMP_RE = /^\s*(?:\[\d{2}:\d{2}:\d{2}(?:\.\d+)?\]|(?:\d{2}:){2}\d{2}\.\d)/;
+// Matches leading ANSI SGR (color/style) codes at the start of a string
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences
+const LEADING_ANSI_RE = /^(\x1b\[(?:\d+;)*\d*m)+/;
 export class TimestampTransformer {
     constructor() {
         this.deviceHasTimestamps = false;
@@ -25,11 +28,30 @@ export class TimestampTransformer {
             controller.enqueue(chunk);
             return;
         }
+        // Extract leading ANSI codes to preserve them across line splits
+        const ansiMatch = chunk.match(LEADING_ANSI_RE);
+        const leadingAnsi = ansiMatch ? ansiMatch[0] : "";
+        const contentWithoutAnsi = leadingAnsi
+            ? chunk.slice(leadingAnsi.length)
+            : chunk;
         const date = new Date();
         const h = date.getHours().toString().padStart(2, "0");
         const m = date.getMinutes().toString().padStart(2, "0");
         const s = date.getSeconds().toString().padStart(2, "0");
-        controller.enqueue(`[${h}:${m}:${s}] ${chunk}`);
+        const timestamp = `[${h}:${m}:${s}]`;
+        // For multi-line chunks, we need to preserve ANSI codes on each line
+        // Split on newlines, but keep the newline characters
+        const lines = contentWithoutAnsi.split(/(\r?\n)/);
+        let result = "";
+        for (const part of lines) {
+            if (part === "\n" || part === "\r\n") {
+                result += part;
+            }
+            else if (part !== "") {
+                result += leadingAnsi + timestamp + " " + part;
+            }
+        }
+        controller.enqueue(result);
     }
     reset() {
         this.deviceHasTimestamps = false;

package/dist/web/{index-DUmRg0Cu.js → index-B5owDZF7.js}

@@ -1,4 +1,4 @@
-import{y as e,z as t,k as o,_ as l,t as r,b as i,h as a}from"./styles-D69gtq6_.js";const n=e`
+import{y as e,z as t,k as o,_ as l,t as r,b as i,h as a}from"./styles-D4zXLz1s.js";const n=e`
   <svg
     version="1.1"
     id="Capa_1"