@daytonaio/sdk 0.170.0 → 0.171.0-alpha.3

package/cjs/utils/Multipart.js

@@ -0,0 +1,115 @@
+"use strict";
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractBoundary = extractBoundary;
+exports.parseMultipart = parseMultipart;
+exports.parseMultipartWithFormData = parseMultipartWithFormData;
+exports.getHeader = getHeader;
+const Binary_1 = require("./Binary");
+/**
+ * Extracts the boundary from a Content-Type header
+ */
+function extractBoundary(contentType) {
+    const match = /boundary="?([^";]+)"?/i.exec(contentType || '');
+    return match ? match[1] : null;
+}
+/**
+ * Extracts a parameter value from Content-Disposition header
+ */
+function getDispositionParam(disposition, paramName) {
+    const match = disposition.match(new RegExp(`${paramName}\\*?=([^;]+)`, 'i'));
+    if (!match)
+        return undefined;
+    return match[1].replace(/^"|"$/g, '').trim();
+}
+/**
+ * Parses multipart/form-data or multipart/mixed response body
+ */
+function parseMultipart(body, boundary) {
+    const encoder = new TextEncoder();
+    const dashBoundary = encoder.encode(`--${boundary}`);
+    const crlf = encoder.encode('\r\n');
+    const boundaryLine = (0, Binary_1.concatUint8Arrays)([dashBoundary, crlf]);
+    const boundaryPositions = (0, Binary_1.findAllBytes)(body, dashBoundary);
+    if (boundaryPositions.length === 0)
+        return [];
+    const parts = [];
+    for (let i = 0; i < boundaryPositions.length; i++) {
+        const start = boundaryPositions[i];
+        // Headers start after "--boundary\r\n"
+        const headerStart = (0, Binary_1.indexAfterSequence)(body, start, boundaryLine);
+        if (headerStart < 0)
+            continue;
+        // Part ends before next boundary
+        const nextBoundary = boundaryPositions[i + 1] ?? body.length;
+        let partEnd = nextBoundary - 2; // Remove trailing CRLF
+        if (partEnd < headerStart)
+            partEnd = headerStart;
+        // Find headers/body separator (\r\n\r\n)
+        const separator = (0, Binary_1.findBytesInRange)(body, headerStart, partEnd, encoder.encode('\r\n\r\n'));
+        if (separator < 0)
+            continue;
+        // Parse headers
+        const headersText = (0, Binary_1.utf8Decode)(body.subarray(headerStart, separator));
+        const headers = {};
+        headersText.split(/\r\n/).forEach((line) => {
+            const [key, ...valueParts] = line.split(':');
+            if (valueParts.length > 0) {
+                headers[key.trim().toLowerCase()] = valueParts.join(':').trim();
+            }
+        });
+        // Extract body
+        const dataStart = separator + 4;
+        const data = body.subarray(dataStart, partEnd);
+        // Extract name and filename from Content-Disposition
+        const disposition = headers['content-disposition'] || '';
+        const name = getDispositionParam(disposition, 'name');
+        const filename = getDispositionParam(disposition, 'filename');
+        parts.push({ name, filename, headers, data });
+    }
+    return parts;
+}
+/**
+ * Parses multipart response using browser's native FormData API
+ * This is more reliable than manual parsing when available
+ */
+async function parseMultipartWithFormData(bodyBytes, contentType) {
+    const result = [];
+    // Create a Blob and parse with FormData API
+    const blob = new Blob([bodyBytes.slice()], { type: contentType });
+    const formData = await new Response(blob).formData();
+    // Process FormData entries (forEach is more universally supported than entries())
+    const filePromises = [];
+    formData.forEach((value, fieldName) => {
+        if ((0, Binary_1.isFile)(value)) {
+            filePromises.push((async () => {
+                const file = value;
+                const arrayBuffer = await file.arrayBuffer();
+                result.push({
+                    fieldName,
+                    filename: file.name,
+                    contentType: file.type,
+                    data: new Uint8Array(arrayBuffer),
+                });
+            })());
+        }
+    });
+    await Promise.all(filePromises);
+    return result;
+}
+/**
+ * Extracts a header value from response headers (case-insensitive)
+ */
+function getHeader(headers, key) {
+    if (!headers)
+        return undefined;
+    const headerKey = Object.keys(headers).find((h) => h.toLowerCase() === key.toLowerCase());
+    if (!headerKey)
+        return undefined;
+    const value = headers[headerKey];
+    return Array.isArray(value) ? value[0] : value;
+}
+//# sourceMappingURL=Multipart.js.map

package/cjs/utils/Multipart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Multipart.js","sourceRoot":"","sources":["../../../../../../libs/sdk-typescript/src/utils/Multipart.ts"],"names":[],"mappings":"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"}

package/cjs/utils/Runtime.d.ts

@@ -0,0 +1,44 @@
+declare global {
+    /**
+     * In Deno this global exists and has a `version.deno` string;
+     * in all other runtimes it will be `undefined`.
+     */
+    var Deno: {
+        version: {
+            deno: string;
+        };
+        env: {
+            get(name: string): string | undefined;
+            toObject(): Record<string, string>;
+        };
+    } | undefined;
+    /**
+     * In Bun this global exists and has a `version.bun` string;
+     * in all other runtimes it will be `undefined`.
+     */
+    var Bun: {
+        version: {
+            bun: string;
+        };
+        file: (path: string) => File;
+    } | undefined;
+}
+export declare enum Runtime {
+    NODE = "node",
+    DENO = "deno",
+    BUN = "bun",
+    BROWSER = "browser",
+    SERVERLESS = "serverless",
+    UNKNOWN = "unknown"
+}
+export declare const RUNTIME: Runtime;
+export declare function getEnvVar(name: string): string | undefined;
+export declare class DaytonaEnvReader {
+    private readonly envLocalVars;
+    private readonly envVars;
+    constructor();
+    get(name: string): string | undefined;
+    private static parseFileVars;
+}
+export declare function isServerlessRuntime(): boolean;
+//# sourceMappingURL=Runtime.d.ts.map

package/cjs/utils/Runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../../../../../libs/sdk-typescript/src/utils/Runtime.ts"],"names":[],"mappings":"AAKA,OAAO,CAAC,MAAM,CAAC;IACb;;;OAGG;IACH,IAAI,IAAI,EACJ;QACE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;QACzB,GAAG,EAAE;YACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;YACrC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SACnC,CAAA;KACF,GACD,SAAS,CAAA;IAEb;;;OAGG;IACH,IAAI,GAAG,EACH;QACE,OAAO,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,CAAA;QACxB,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;KAC7B,GACD,SAAS,CAAA;CACd;AAED,oBAAY,OAAO;IACjB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,OAAO,YAAY;CACpB;AAED,eAAO,MAAM,OAAO,SAWS,CAAA;AAE7B,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS1D;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwB;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;;IAOhD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAarC,OAAO,CAAC,MAAM,CAAC,aAAa;CAQ7B;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C"}

package/cjs/utils/Runtime.js

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ * Copyright 2025 Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaytonaEnvReader = exports.RUNTIME = exports.Runtime = void 0;
+exports.getEnvVar = getEnvVar;
+exports.isServerlessRuntime = isServerlessRuntime;
+var Runtime;
+(function (Runtime) {
+    Runtime["NODE"] = "node";
+    Runtime["DENO"] = "deno";
+    Runtime["BUN"] = "bun";
+    Runtime["BROWSER"] = "browser";
+    Runtime["SERVERLESS"] = "serverless";
+    Runtime["UNKNOWN"] = "unknown";
+})(Runtime || (exports.Runtime = Runtime = {}));
+exports.RUNTIME = typeof Deno !== 'undefined'
+    ? Runtime.DENO
+    : typeof Bun !== 'undefined' && !!Bun.version
+        ? Runtime.BUN
+        : isServerlessRuntime()
+            ? Runtime.SERVERLESS
+            : typeof window !== 'undefined'
+                ? Runtime.BROWSER
+                : typeof process !== 'undefined' && !!process.versions?.node
+                    ? Runtime.NODE
+                    : Runtime.UNKNOWN;
+function getEnvVar(name) {
+    if (exports.RUNTIME === Runtime.NODE || exports.RUNTIME === Runtime.BUN) {
+        return process.env[name];
+    }
+    if (exports.RUNTIME === Runtime.DENO) {
+        return Deno.env.get(name);
+    }
+    return undefined;
+}
+class DaytonaEnvReader {
+    envLocalVars;
+    envVars;
+    constructor() {
+        this.envLocalVars = DaytonaEnvReader.parseFileVars('.env.local');
+        this.envVars = DaytonaEnvReader.parseFileVars('.env');
+    }
+    get(name) {
+        if (!name.startsWith('DAYTONA_')) {
+            throw new Error(`DaytonaEnvReader: variable name must start with 'DAYTONA_', got '${name}'`);
+        }
+        // 1. Runtime env
+        const runtimeVal = getEnvVar(name);
+        if (runtimeVal !== undefined)
+            return runtimeVal;
+        // 2. .env.local
+        if (name in this.envLocalVars)
+            return this.envLocalVars[name];
+        // 3. .env
+        return this.envVars[name];
+    }
+    static parseFileVars(path) {
+        if (exports.RUNTIME !== Runtime.NODE || typeof require === 'undefined')
+            return {};
+        const fs = require('fs');
+        if (!fs.existsSync(path))
+            return {};
+        const dotenv = require('dotenv');
+        const parsed = dotenv.parse(fs.readFileSync(path));
+        return Object.fromEntries(Object.entries(parsed).filter(([k]) => k.startsWith('DAYTONA_')));
+    }
+}
+exports.DaytonaEnvReader = DaytonaEnvReader;
+function isServerlessRuntime() {
+    // Safely grab env vars, even if `process` is undeclared
+    const env = typeof process !== 'undefined' ? process.env : {};
+    // Worker-specific globals
+    const globalObj = globalThis;
+    return Boolean(
+    // Cloudflare Workers (V8 isolate API)
+    typeof globalObj.WebSocketPair === 'function' ||
+        // Cloudflare Pages
+        env.CF_PAGES === '1' ||
+        // AWS Lambda (incl. SAM local)
+        env.AWS_EXECUTION_ENV?.startsWith('AWS_Lambda') ||
+        env.LAMBDA_TASK_ROOT !== undefined ||
+        env.AWS_SAM_LOCAL === 'true' ||
+        // Azure Functions
+        env.FUNCTIONS_WORKER_RUNTIME !== undefined ||
+        // Google Cloud Functions / Cloud Run
+        (env.FUNCTION_TARGET !== undefined && env.FUNCTION_SIGNATURE_TYPE !== undefined) ||
+        // Vercel
+        env.VERCEL === '1' ||
+        // Netlify Functions
+        env.SITE_NAME !== undefined);
+}
+//# sourceMappingURL=Runtime.js.map

package/cjs/utils/Runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.js","sourceRoot":"","sources":["../../../../../../libs/sdk-typescript/src/utils/Runtime.ts"],"names":[],"mappings":"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"}

package/cjs/utils/Stream.d.ts

@@ -0,0 +1,20 @@
+import WebSocket from 'isomorphic-ws';
+/**
+ * Process a streaming response from fetch(), where getStream() returns a Fetch Response.
+ *
+ * @param getStream – zero-arg function that does `await fetch(...)` and returns the Response
+ * @param onChunk – called with each decoded UTF-8 chunk
+ * @param shouldTerminate – pollable; if true for two consecutive timeouts (or once if requireConsecutiveTermination=false), the loop breaks
+ * @param chunkTimeout – milliseconds to wait for a new chunk before calling shouldTerminate()
+ * @param requireConsecutiveTermination – whether you need two time-outs in a row to break
+ */
+export declare function processStreamingResponse(getStream: () => Promise<Response>, onChunk: (chunk: string) => void, shouldTerminate: () => Promise<boolean>, chunkTimeout?: number, requireConsecutiveTermination?: boolean): Promise<void>;
+/**
+ * Demultiplexes a WebSocket stream into separate stdout and stderr streams.
+ *
+ * @param socket - The WebSocket instance to demultiplex.
+ * @param onStdout - Callback function for stdout messages.
+ * @param onStderr - Callback function for stderr messages.
+ */
+export declare function stdDemuxStream(ws: WebSocket, onStdout: (data: string) => void, onStderr: (data: string) => void): Promise<void>;
+//# sourceMappingURL=Stream.d.ts.map

package/cjs/utils/Stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stream.d.ts","sourceRoot":"","sources":["../../../../../../libs/sdk-typescript/src/utils/Stream.ts"],"names":[],"mappings":"AAIA,OAAO,SAAS,MAAM,eAAe,CAAA;AAmBrC;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAChC,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACvC,YAAY,SAAO,EACnB,6BAA6B,UAAO,GACnC,OAAO,CAAC,IAAI,CAAC,CAoEf;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,EAChC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/B,OAAO,CAAC,IAAI,CAAC,CA2Pf"}

package/cjs/utils/Stream.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStreamingResponse = processStreamingResponse;
+exports.stdDemuxStream = stdDemuxStream;
+const Process_1 = require("../Process");
+function isStreamTerminationError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    // Typical Undici / fetch termination cases
+    if (e.name === 'AbortError')
+        return true;
+    if (typeof e.message === 'string' && /terminated/i.test(e.message))
+        return true;
+    if (e.code === 'UND_ERR_SOCKET')
+        return true;
+    // Look into nested causes, Undici often nests errors
+    if (e.cause)
+        return isStreamTerminationError(e.cause);
+    return false;
+}
+/**
+ * Process a streaming response from fetch(), where getStream() returns a Fetch Response.
+ *
+ * @param getStream – zero-arg function that does `await fetch(...)` and returns the Response
+ * @param onChunk – called with each decoded UTF-8 chunk
+ * @param shouldTerminate – pollable; if true for two consecutive timeouts (or once if requireConsecutiveTermination=false), the loop breaks
+ * @param chunkTimeout – milliseconds to wait for a new chunk before calling shouldTerminate()
+ * @param requireConsecutiveTermination – whether you need two time-outs in a row to break
+ */
+async function processStreamingResponse(getStream, onChunk, shouldTerminate, chunkTimeout = 2000, requireConsecutiveTermination = true) {
+    const res = await getStream();
+    if (!res.body)
+        throw new Error('No streaming support');
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    const TIMEOUT = Symbol();
+    let exitCheckStreak = 0;
+    // Only one pending read promise at a time:
+    let readPromise = null;
+    try {
+        while (true) {
+            // Start a read if none in flight
+            if (!readPromise) {
+                readPromise = reader.read().then((r) => (r.done ? null : (r.value ?? new Uint8Array(0))));
+            }
+            // Race that single read against your timeout
+            const timeoutPromise = new Promise((r) => setTimeout(() => r(TIMEOUT), chunkTimeout));
+            const result = await Promise.race([readPromise, timeoutPromise]);
+            if (result === TIMEOUT) {
+                // no data yet, but the readPromise is still pending
+                const stop = await shouldTerminate();
+                if (stop) {
+                    exitCheckStreak++;
+                    if (!requireConsecutiveTermination || exitCheckStreak > 1) {
+                        try {
+                            await reader.cancel();
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                        readPromise = null;
+                        break;
+                    }
+                }
+                else {
+                    exitCheckStreak = 0;
+                }
+                // loop again—but do NOT overwrite readPromise!
+            }
+            else {
+                // readPromise has resolved
+                readPromise = null;
+                if (result === null) {
+                    // stream closed
+                    break;
+                }
+                // valid chunk - use {stream: true} to buffer incomplete UTF-8 sequences
+                onChunk(decoder.decode(result, { stream: true }));
+                exitCheckStreak = 0;
+            }
+        }
+    }
+    catch (err) {
+        if (!isStreamTerminationError(err)) {
+            throw err;
+        }
+    }
+    finally {
+        // Flush any remaining buffered bytes from the decoder
+        const remaining = decoder.decode();
+        if (remaining) {
+            onChunk(remaining);
+        }
+        try {
+            await reader.cancel();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/**
+ * Demultiplexes a WebSocket stream into separate stdout and stderr streams.
+ *
+ * @param socket - The WebSocket instance to demultiplex.
+ * @param onStdout - Callback function for stdout messages.
+ * @param onStderr - Callback function for stderr messages.
+ */
+function stdDemuxStream(ws, onStdout, onStderr) {
+    return new Promise((resolve, reject) => {
+        // If running in a browser or any WebSocket supporting binaryType, use ArrayBuffer for binary data
+        if ('binaryType' in ws) {
+            ws.binaryType = 'arraybuffer'; // ensure binary frames yield ArrayBuffer, not Blob
+        }
+        // Separate decoders for stdout and stderr to maintain independent UTF-8 decoding state
+        const stdoutDecoder = new TextDecoder('utf-8');
+        const stderrDecoder = new TextDecoder('utf-8');
+        const buf = []; // Buffer to accumulate incoming chunks
+        let currentDataType = null; // Track current stream type
+        // Helper function to emit payload data
+        const emit = (payload) => {
+            if (payload.length === 0)
+                return;
+            // Use {stream: true} to buffer incomplete UTF-8 sequences for the next chunk
+            if (currentDataType === 'stdout') {
+                const text = stdoutDecoder.decode(payload, { stream: true });
+                onStdout(text);
+            }
+            else if (currentDataType === 'stderr') {
+                const text = stderrDecoder.decode(payload, { stream: true });
+                onStderr(text);
+            }
+            // If currentDataType is null, drop unlabeled bytes (shouldn't happen with proper labeling)
+        };
+        // Helper function to find a subarray within a larger array
+        const findSubarray = (haystack, needle) => {
+            if (needle.length === 0)
+                return 0;
+            if (haystack.length < needle.length)
+                return -1;
+            for (let i = 0; i <= haystack.length - needle.length; i++) {
+                let found = true;
+                for (let j = 0; j < needle.length; j++) {
+                    if (haystack[i + j] !== needle[j]) {
+                        found = false;
+                        break;
+                    }
+                }
+                if (found)
+                    return i;
+            }
+            return -1;
+        };
+        // Event handler for incoming messages (Node: Buffer/ArrayBuffer/String; Browser: event.data etc.)
+        const handleMessage = (event) => {
+            // Normalize event/data between Node (ws) and browser WebSocket
+            const data = event && event instanceof Object && 'data' in event ? event.data : event;
+            try {
+                // Prepare a Uint8Array for the message data
+                let bytes;
+                if (typeof data === 'string') {
+                    // Convert string to bytes for consistent byte-based demuxing
+                    bytes = new TextEncoder().encode(data);
+                }
+                else if (data instanceof ArrayBuffer) {
+                    bytes = new Uint8Array(data);
+                }
+                else if (ArrayBuffer.isView(data)) {
+                    // Covers Node.js Buffer (Uint8Array subclass) and other TypedArrays
+                    bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+                }
+                else if (data instanceof Blob) {
+                    // Browser binary frames might be Blob if binaryType wasn't set in time. Convert to ArrayBuffer asynchronously.
+                    data.arrayBuffer().then((buf) => {
+                        try {
+                            processChunk(new Uint8Array(buf));
+                        }
+                        catch (err) {
+                            handleError(err);
+                        }
+                    }, (err) => {
+                        handleError(err);
+                    });
+                    return; // will continue asynchronously once blob is read
+                }
+                else {
+                    throw new Error(`Unsupported message data type: ${Object.prototype.toString.call(data)}`);
+                }
+                // Process the chunk
+                processChunk(bytes);
+            }
+            catch (err) {
+                // On any synchronous error in processing, clean up and reject.
+                cleanup();
+                try {
+                    ws.close();
+                }
+                catch {
+                    /* ignore if already closed */
+                }
+                reject(err);
+            }
+        };
+        // Process a chunk of data with buffering and safe region handling
+        const processChunk = (chunk) => {
+            if (chunk.length === 0)
+                return;
+            // Add chunk to buffer
+            buf.push(...chunk);
+            // Process as much as we can, preserving only bytes that could be part of a prefix
+            while (true) {
+                const bufArray = new Uint8Array(buf);
+                // Calculate how many bytes we can safely process
+                // We need to keep bytes that could potentially be the start of a prefix marker
+                let safeLen = buf.length;
+                // Check if the last few bytes could be part of a prefix marker
+                if (buf.length >= Process_1.MAX_PREFIX_LEN) {
+                    // Check if the last byte could be part of a prefix (must be 0x01 or 0x02)
+                    const lastByte = buf[buf.length - 1];
+                    if (lastByte !== 0x01 && lastByte !== 0x02) {
+                        // Last byte can't be part of any prefix, safe to process everything
+                        safeLen = buf.length;
+                    }
+                    else if (buf.length >= Process_1.MAX_PREFIX_LEN + 1) {
+                        // Check second-to-last byte if buffer is long enough
+                        const secondLastByte = buf[buf.length - 2];
+                        if (secondLastByte !== 0x01 && secondLastByte !== 0x02) {
+                            // Second-to-last byte can't be part of any prefix, safe to process all but last byte
+                            safeLen = buf.length - 1;
+                        }
+                        else {
+                            // Both last bytes could be part of prefix, keep MAX_PREFIX_LEN - 1 bytes
+                            safeLen = buf.length - (Process_1.MAX_PREFIX_LEN - 1);
+                        }
+                    }
+                    else {
+                        // Buffer is exactly MAX_PREFIX_LEN, keep MAX_PREFIX_LEN - 1 bytes
+                        safeLen = buf.length - (Process_1.MAX_PREFIX_LEN - 1);
+                    }
+                }
+                else {
+                    // Buffer shorter than MAX_PREFIX_LEN, keep MAX_PREFIX_LEN - 1 bytes
+                    safeLen = buf.length - (Process_1.MAX_PREFIX_LEN - 1);
+                }
+                if (safeLen <= 0) {
+                    break;
+                }
+                // Find earliest next marker within the safe region
+                const safeRegion = bufArray.subarray(0, safeLen);
+                const stdoutIndex = findSubarray(safeRegion, Process_1.STDOUT_PREFIX_BYTES);
+                const stderrIndex = findSubarray(safeRegion, Process_1.STDERR_PREFIX_BYTES);
+                let nextIdx = -1;
+                let nextKind = null;
+                let nextLen = 0;
+                if (stdoutIndex !== -1 && (stderrIndex === -1 || stdoutIndex < stderrIndex)) {
+                    nextIdx = stdoutIndex;
+                    nextKind = 'stdout';
+                    nextLen = Process_1.STDOUT_PREFIX_BYTES.length;
+                }
+                else if (stderrIndex !== -1) {
+                    nextIdx = stderrIndex;
+                    nextKind = 'stderr';
+                    nextLen = Process_1.STDERR_PREFIX_BYTES.length;
+                }
+                if (nextIdx === -1) {
+                    // No full marker in safe region: emit everything we safely can as payload
+                    const toEmit = bufArray.subarray(0, safeLen);
+                    emit(toEmit);
+                    buf.splice(0, safeLen);
+                    break; // wait for more data to resolve any partial marker at the end
+                }
+                // We found a marker. Emit preceding bytes (if any) under the current stream.
+                if (nextIdx > 0) {
+                    const toEmit = bufArray.subarray(0, nextIdx);
+                    emit(toEmit);
+                }
+                // Advance past the marker and switch current stream
+                buf.splice(0, nextIdx + nextLen);
+                currentDataType = nextKind;
+            }
+        };
+        // Event handler for errors
+        const handleError = (error) => {
+            // Convert Event or plain error to Error instance for consistency
+            const err = error && error instanceof Event ? new Error('WebSocket error') : error;
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* ignore if already closed */
+            }
+            reject(err);
+        };
+        // Event handler for socket closure
+        const handleClose = () => {
+            // Flush any remaining buffered payload on clean close
+            if (buf.length > 0 && currentDataType) {
+                const remainingBytes = new Uint8Array(buf);
+                // Use {stream: false} or omit to flush any buffered incomplete UTF-8 sequences
+                if (currentDataType === 'stdout') {
+                    const text = stdoutDecoder.decode(remainingBytes, { stream: false });
+                    onStdout(text);
+                }
+                else if (currentDataType === 'stderr') {
+                    const text = stderrDecoder.decode(remainingBytes, { stream: false });
+                    onStderr(text);
+                }
+            }
+            else {
+                // Flush any remaining bytes in the decoders even if buf is empty
+                const stdoutFlushed = stdoutDecoder.decode();
+                const stderrFlushed = stderrDecoder.decode();
+                if (stdoutFlushed)
+                    onStdout(stdoutFlushed);
+                if (stderrFlushed)
+                    onStderr(stderrFlushed);
+            }
+            cleanup();
+            resolve();
+        };
+        // Cleanup function to remove all listeners to avoid memory leaks
+        const cleanup = () => {
+            if (ws.removeEventListener) {
+                // Browser (EventTarget) style cleanup
+                ws.removeEventListener('message', handleMessage);
+                ws.removeEventListener('error', handleError);
+                ws.removeEventListener('close', handleClose);
+            }
+            if (ws.off) {
+                // Node.js ws (EventEmitter) style cleanup (supported in Node 14+)
+                ws.off('message', handleMessage);
+                ws.off('error', handleError);
+                ws.off('close', handleClose);
+            }
+            else if (ws.removeListener) {
+                // Node.js ws fallback for older Node versions
+                ;
+                ws.removeListener('message', handleMessage);
+                ws.removeListener('error', handleError);
+                ws.removeListener('close', handleClose);
+            }
+        };
+        // Attach event listeners in a way compatible with both Node (EventEmitter) and browser (EventTarget):
+        if (ws.addEventListener) {
+            // Browser or WebSocket implementation with EventTarget interface
+            ws.addEventListener('message', handleMessage);
+            ws.addEventListener('error', handleError);
+            ws.addEventListener('close', handleClose);
+        }
+        else if (ws.on) {
+            // Node.js ws library (EventEmitter) interface
+            ws.on('message', handleMessage); // ws@8+ yields Buffer for text frames, which we handle via TextDecoder
+            ws.on('error', handleError);
+            ws.on('close', handleClose);
+        }
+        else {
+            // Unknown WebSocket interface - should not happen with isomorphic-ws
+            throw new Error('Unsupported WebSocket implementation');
+        }
+    });
+}
+//# sourceMappingURL=Stream.js.map