@nogataka/smart-edit 0.0.14

package/dist/solidlsp/ls_config.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SolidLSP の Python 実装における Language Enum の TypeScript 版。
+ * 現段階では config 層からの利用に必要な最小機能（列挙値と簡易ユーティリティ）のみを提供する。
+ * TODO: SolidLSP モジュール移植時に Python 版の完全な API と一致するよう拡張する。
+ */
+export declare enum Language {
+    CSHARP = "csharp",
+    PYTHON = "python",
+    RUST = "rust",
+    JAVA = "java",
+    KOTLIN = "kotlin",
+    TYPESCRIPT = "typescript",
+    GO = "go",
+    RUBY = "ruby",
+    DART = "dart",
+    CPP = "cpp",
+    PHP = "php",
+    R = "r",
+    CLOJURE = "clojure",
+    ELIXIR = "elixir",
+    TERRAFORM = "terraform",
+    SWIFT = "swift",
+    BASH = "bash",
+    ZIG = "zig",
+    LUA = "lua",
+    NIX = "nix",
+    ERLANG = "erlang",
+    AL = "al",
+    TYPESCRIPT_VTS = "typescript_vts",
+    PYTHON_JEDI = "python_jedi",
+    CSHARP_OMNISHARP = "csharp_omnisharp",
+    RUBY_SOLARGRAPH = "ruby_solargraph"
+}
+export interface ListLanguagesOptions {
+    includeExperimental?: boolean;
+}
+export declare function listLanguages(options?: ListLanguagesOptions): Language[];
+export declare function isExperimentalLanguage(language: Language): boolean;
+export declare function coerceLanguage(value: string): Language;
+export interface FilenameMatcherLike {
+    isRelevantFilename(filename: string): boolean;
+}
+export declare function getLanguageFilenameMatcher(language: Language): FilenameMatcherLike;

package/dist/solidlsp/ls_config.js

@@ -0,0 +1,157 @@
+/**
+ * SolidLSP の Python 実装における Language Enum の TypeScript 版。
+ * 現段階では config 層からの利用に必要な最小機能（列挙値と簡易ユーティリティ）のみを提供する。
+ * TODO: SolidLSP モジュール移植時に Python 版の完全な API と一致するよう拡張する。
+ */
+export var Language;
+(function (Language) {
+    Language["CSHARP"] = "csharp";
+    Language["PYTHON"] = "python";
+    Language["RUST"] = "rust";
+    Language["JAVA"] = "java";
+    Language["KOTLIN"] = "kotlin";
+    Language["TYPESCRIPT"] = "typescript";
+    Language["GO"] = "go";
+    Language["RUBY"] = "ruby";
+    Language["DART"] = "dart";
+    Language["CPP"] = "cpp";
+    Language["PHP"] = "php";
+    Language["R"] = "r";
+    Language["CLOJURE"] = "clojure";
+    Language["ELIXIR"] = "elixir";
+    Language["TERRAFORM"] = "terraform";
+    Language["SWIFT"] = "swift";
+    Language["BASH"] = "bash";
+    Language["ZIG"] = "zig";
+    Language["LUA"] = "lua";
+    Language["NIX"] = "nix";
+    Language["ERLANG"] = "erlang";
+    Language["AL"] = "al";
+    Language["TYPESCRIPT_VTS"] = "typescript_vts";
+    Language["PYTHON_JEDI"] = "python_jedi";
+    Language["CSHARP_OMNISHARP"] = "csharp_omnisharp";
+    Language["RUBY_SOLARGRAPH"] = "ruby_solargraph";
+})(Language || (Language = {}));
+const EXPERIMENTAL_LANGUAGES = new Set([
+    Language.TYPESCRIPT_VTS,
+    Language.PYTHON_JEDI,
+    Language.CSHARP_OMNISHARP,
+    Language.RUBY_SOLARGRAPH
+]);
+const LANGUAGE_LOOKUP = new Map(Object.values(Language).map((value) => [value.toLowerCase(), value]));
+export function listLanguages(options) {
+    const includeExperimental = options?.includeExperimental ?? false;
+    return Object.values(Language).filter((lang) => includeExperimental || !EXPERIMENTAL_LANGUAGES.has(lang));
+}
+export function isExperimentalLanguage(language) {
+    return EXPERIMENTAL_LANGUAGES.has(language);
+}
+export function coerceLanguage(value) {
+    const normalized = value.toLowerCase();
+    const found = LANGUAGE_LOOKUP.get(normalized);
+    if (!found) {
+        const valid = Array.from(LANGUAGE_LOOKUP.keys()).sort().join(', ');
+        throw new RangeError(`Unsupported language "${value}". 有効な値: ${valid}`);
+    }
+    return found;
+}
+const CASE_INSENSITIVE = process.platform === 'win32';
+function globToRegExp(pattern) {
+    let regex = '';
+    for (const char of pattern) {
+        if (char === '*') {
+            regex += '.*';
+        }
+        else if (char === '?') {
+            regex += '.';
+        }
+        else if ('\\[]{}()+-.^$|'.includes(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+    }
+    return new RegExp(`^${regex}$`, CASE_INSENSITIVE ? 'i' : undefined);
+}
+function createMatcher(patterns) {
+    if (patterns.length === 0) {
+        return () => true;
+    }
+    const regexes = patterns.map((pattern) => globToRegExp(pattern));
+    return (filename) => regexes.some((regex) => regex.test(filename));
+}
+function getPatternsForLanguage(language) {
+    switch (language) {
+        case Language.PYTHON:
+        case Language.PYTHON_JEDI:
+            return ['*.py', '*.pyi'];
+        case Language.JAVA:
+            return ['*.java'];
+        case Language.TYPESCRIPT:
+        case Language.TYPESCRIPT_VTS: {
+            const patterns = [];
+            for (const prefix of ['c', 'm', '']) {
+                for (const postfix of ['x', '']) {
+                    for (const base of ['ts', 'js']) {
+                        patterns.push(`*.${prefix}${base}${postfix}`);
+                    }
+                }
+            }
+            return patterns;
+        }
+        case Language.CSHARP:
+        case Language.CSHARP_OMNISHARP:
+            return ['*.cs'];
+        case Language.RUST:
+            return ['*.rs'];
+        case Language.GO:
+            return ['*.go'];
+        case Language.RUBY:
+            return ['*.rb', '*.erb'];
+        case Language.RUBY_SOLARGRAPH:
+            return ['*.rb'];
+        case Language.CPP:
+            return ['*.cpp', '*.h', '*.hpp', '*.c', '*.hxx', '*.cc', '*.cxx'];
+        case Language.KOTLIN:
+            return ['*.kt', '*.kts'];
+        case Language.DART:
+            return ['*.dart'];
+        case Language.PHP:
+            return ['*.php'];
+        case Language.R:
+            return ['*.R', '*.r', '*.Rmd', '*.Rnw'];
+        case Language.CLOJURE:
+            return ['*.clj', '*.cljs', '*.cljc', '*.edn'];
+        case Language.ELIXIR:
+            return ['*.ex', '*.exs'];
+        case Language.TERRAFORM:
+            return ['*.tf', '*.tfvars', '*.tfstate'];
+        case Language.SWIFT:
+            return ['*.swift'];
+        case Language.BASH:
+            return ['*.sh', '*.bash'];
+        case Language.ZIG:
+            return ['*.zig', '*.zon'];
+        case Language.LUA:
+            return ['*.lua'];
+        case Language.NIX:
+            return ['*.nix'];
+        case Language.ERLANG:
+            return ['*.erl', '*.hrl', '*.escript', '*.config', '*.app', '*.app.src'];
+        case Language.AL:
+            return ['*.al', '*.dal'];
+        default:
+            return [];
+    }
+}
+export function getLanguageFilenameMatcher(language) {
+    const patterns = getPatternsForLanguage(language);
+    if (!patterns.length) {
+        throw new RangeError(`Unhandled language '${language}' for filename matcher`);
+    }
+    const matcher = createMatcher(patterns);
+    return {
+        isRelevantFilename: (filename) => matcher(filename)
+    };
+}

package/dist/solidlsp/ls_exceptions.d.ts

@@ -0,0 +1,5 @@
+export declare class SolidLSPException extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+    isLanguageServerTerminated(): boolean;
+}

package/dist/solidlsp/ls_exceptions.js

@@ -0,0 +1,14 @@
+export class SolidLSPException extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'SolidLSPException';
+        this.cause = cause;
+    }
+    isLanguageServerTerminated() {
+        if (!this.cause) {
+            return false;
+        }
+        return this.cause.name === 'LanguageServerTerminatedException';
+    }
+}

package/dist/solidlsp/ls_handler.d.ts

@@ -0,0 +1,54 @@
+import { type DocumentSymbolRequestParams, type LanguageServerRequestDelegate } from './ls_request.js';
+import { LSPError, type PayloadLike, type ProcessLaunchInfo } from './lsp_protocol_handler/server.js';
+import type { DocumentSymbolResult, FullSymbolTreeOptions, ReferenceInSymbol, ReferencingSymbolsOptions, SolidLanguageServerHandler, SolidLanguageServerNotifications, SolidLanguageServerRequests, UnifiedSymbolInformation } from './ls.js';
+type WireLogger = (source: string, destination: string, payload: unknown) => void;
+export declare class LanguageServerTerminatedException extends Error {
+    readonly cause?: Error;
+    constructor(message: string, cause?: Error);
+}
+export interface NodeLanguageServerHandlerOptions {
+    logger?: WireLogger;
+    startIndependentProcessGroup?: boolean;
+    requestTimeoutSeconds?: number | null;
+}
+export declare class NodeLanguageServerHandler implements SolidLanguageServerHandler, LanguageServerRequestDelegate {
+    readonly send: SolidLanguageServerRequests;
+    readonly notify: SolidLanguageServerNotifications;
+    private readonly processLaunchInfo;
+    private readonly logger?;
+    private readonly startIndependentProcessGroup;
+    private child;
+    private stdoutBuffer;
+    private stdoutFd;
+    private requestId;
+    private requestTimeoutSeconds;
+    private shuttingDown;
+    private readonly requestHandlers;
+    private readonly notificationHandlers;
+    constructor(processLaunchInfo: ProcessLaunchInfo, options?: NodeLanguageServerHandlerOptions);
+    setRequestTimeout(timeout: number | null): void;
+    isRunning(): boolean;
+    start(): void;
+    shutdown(): void;
+    dispose(): void;
+    sendRequest(method: 'textDocument/documentSymbol', params: DocumentSymbolRequestParams): DocumentSymbolResult | null;
+    sendRequest(method: 'serena/fullSymbolTree', params: FullSymbolTreeOptions): UnifiedSymbolInformation[] | null;
+    sendRequest(method: 'serena/referencingSymbols', params: ReferencingSymbolsOptions): ReferenceInSymbol[] | null;
+    sendRequest(method: 'serena/overview', params: string): Record<string, UnifiedSymbolInformation[]> | null;
+    sendRequest(method: 'shutdown'): void;
+    sendRequest(method: string, params?: unknown): unknown;
+    private waitForResponse;
+    private readNextMessage;
+    private extractMessageFromBuffer;
+    private handleServerRequest;
+    private handleNotification;
+    sendNotification(method: string, params?: PayloadLike): void;
+    sendResponse(requestId: number | string | null, params: PayloadLike): void;
+    sendErrorResponse(requestId: number | string | null, err: LSPError): void;
+    on_request(method: string, handler: (params: unknown) => unknown): void;
+    onRequest(method: string, handler: (params: unknown) => unknown): void;
+    onNotification(method: string, handler: (params: unknown) => void): void;
+    private sendPayload;
+    private logWire;
+}
+export {};

package/dist/solidlsp/ls_handler.js

@@ -0,0 +1,406 @@
+import { spawn } from 'node:child_process';
+import { Buffer } from 'node:buffer';
+import fs from 'node:fs';
+import { ensureDefaultSubprocessOptions } from './util/subprocess_util.js';
+import { SolidLSPException } from './ls_exceptions.js';
+import { LspNotification, LanguageServerRequest } from './ls_request.js';
+import { ErrorCodes } from './ls_types.js';
+import { ENCODING, LSPError, createMessage, makeErrorResponse, makeNotification, makeRequest, makeResponse } from './lsp_protocol_handler/server.js';
+const HEADER_SEPARATOR = Buffer.from('\r\n\r\n', ENCODING);
+function cloneEnv(extra) {
+    return { ...process.env, ...(extra ?? {}) };
+}
+function normalizeCommand(cmd) {
+    if (Array.isArray(cmd)) {
+        const [first, ...rest] = cmd;
+        if (!first) {
+            throw new Error('Process command cannot be empty.');
+        }
+        return { command: first, args: rest, shell: false };
+    }
+    return { command: cmd, args: [], shell: true };
+}
+export class LanguageServerTerminatedException extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = 'LanguageServerTerminatedException';
+        this.cause = cause;
+    }
+}
+export class NodeLanguageServerHandler {
+    send;
+    notify;
+    processLaunchInfo;
+    logger;
+    startIndependentProcessGroup;
+    child = null;
+    stdoutBuffer = Buffer.alloc(0);
+    stdoutFd = null;
+    requestId = 1;
+    requestTimeoutSeconds;
+    shuttingDown = false;
+    requestHandlers = new Map();
+    notificationHandlers = new Map();
+    constructor(processLaunchInfo, options = {}) {
+        this.processLaunchInfo = processLaunchInfo;
+        this.logger = options.logger;
+        this.startIndependentProcessGroup = options.startIndependentProcessGroup ?? true;
+        this.requestTimeoutSeconds = options.requestTimeoutSeconds ?? null;
+        this.send = new LanguageServerRequest(this);
+        this.notify = new LspNotification((method, params) => this.sendNotification(method, (params ?? null)));
+    }
+    setRequestTimeout(timeout) {
+        this.requestTimeoutSeconds = timeout ?? null;
+    }
+    isRunning() {
+        return this.child !== null && this.child.exitCode === null;
+    }
+    start() {
+        if (this.child) {
+            throw new Error('Language server already started');
+        }
+        const { command, args, shell } = normalizeCommand(this.processLaunchInfo.cmd);
+        const env = cloneEnv(this.processLaunchInfo.env);
+        const cwd = this.processLaunchInfo.cwd ?? process.cwd();
+        const spawnOptions = ensureDefaultSubprocessOptions({
+            cwd,
+            env,
+            shell,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: this.startIndependentProcessGroup
+        });
+        const child = spawn(command, args, spawnOptions);
+        if (!child.stdin || !child.stdout || !child.stderr) {
+            child.kill();
+            throw new Error('Failed to spawn language server process with stdio pipes.');
+        }
+        this.child = child;
+        this.stdoutBuffer = Buffer.alloc(0);
+        this.stdoutFd = getStreamFd(child.stdout);
+        child.stdout.pause();
+        child.stdin.on('error', (error) => {
+            const code = error.code ?? 'UNKNOWN';
+            if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') {
+                if (!this.shuttingDown) {
+                    this.logWire('client', 'server', { type: 'stdin-error', code, message: error.message });
+                }
+                return;
+            }
+            this.logWire('client', 'server', { type: 'stdin-error', code, message: error.message });
+        });
+        child.stderr.setEncoding(ENCODING);
+        child.stderr.on('data', (chunk) => {
+            const message = chunk.trimEnd();
+            if (!message) {
+                return;
+            }
+            if (message.toLowerCase().includes('error') || message.startsWith('E[')) {
+                if (this.logger) {
+                    this.logger('server', 'stderr', message);
+                }
+            }
+        });
+        child.on('exit', (code, signal) => {
+            this.child = null;
+            this.stdoutFd = null;
+            if (this.shuttingDown) {
+                return;
+            }
+            const reason = `Language server exited with code ${code} signal ${signal ?? 'none'}`;
+            this.stdoutBuffer = Buffer.alloc(0);
+            this.shuttingDown = false;
+            this.logWire('server', 'client', reason);
+        });
+        const immediateExit = child.exitCode !== null;
+        if (immediateExit) {
+            const rawStderr = child.stderr.read();
+            const stderr = normalizeStreamOutput(rawStderr);
+            throw new Error(`Language server process terminated immediately with code ${child.exitCode}. ${stderr}`);
+        }
+    }
+    shutdown() {
+        if (!this.child) {
+            return;
+        }
+        this.shuttingDown = true;
+        try {
+            this.send.shutdown();
+        }
+        catch (error) {
+            // Ignore errors on shutdown path.
+            void error;
+        }
+        this.notify.exit();
+    }
+    dispose() {
+        const child = this.child;
+        this.child = null;
+        if (!child) {
+            return;
+        }
+        try {
+            child.stdin?.end();
+        }
+        catch (error) {
+            void error;
+        }
+        if (child.exitCode === null) {
+            child.kill('SIGTERM');
+            const timeout = globalThis.setTimeout(() => {
+                if (child.exitCode === null) {
+                    child.kill('SIGKILL');
+                }
+            }, 5_000);
+            child.once('exit', () => globalThis.clearTimeout(timeout));
+        }
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+    }
+    sendRequest(method, params) {
+        const child = this.child;
+        if (!child?.stdin || this.stdoutFd === null) {
+            throw new SolidLSPException('Language server is not running.');
+        }
+        const id = this.requestId;
+        this.requestId += 1;
+        const payload = makeRequest(method, id, (params ?? null));
+        this.logWire('client', 'server', payload);
+        child.stdin.write(createMessage(payload));
+        const response = this.waitForResponse(id, method);
+        switch (method) {
+            case 'textDocument/documentSymbol':
+                return (response ?? null);
+            case 'serena/fullSymbolTree':
+                return (response ?? null);
+            case 'serena/referencingSymbols':
+                return (response ?? null);
+            case 'serena/overview':
+                return (response ?? null);
+            case 'shutdown':
+                return undefined;
+            default:
+                return response;
+        }
+    }
+    waitForResponse(requestId, method) {
+        const timeoutMillis = this.requestTimeoutSeconds != null ? this.requestTimeoutSeconds * 1000 : null;
+        const deadline = timeoutMillis != null ? Date.now() + timeoutMillis : null;
+        while (true) {
+            const message = this.readNextMessage(deadline);
+            if (!message) {
+                continue;
+            }
+            if ('id' in message && Object.prototype.hasOwnProperty.call(message, 'result')) {
+                const response = message;
+                if (response.id === requestId) {
+                    return response.result;
+                }
+            }
+            if ('id' in message && Object.prototype.hasOwnProperty.call(message, 'error')) {
+                const response = message;
+                if (response.id === requestId) {
+                    const errorPayload = (response.error ?? {});
+                    const lspError = LSPError.fromLsp(errorPayload);
+                    throw new SolidLSPException(`Error processing request ${method}`, lspError);
+                }
+            }
+            if (isJsonRpcRequest(message)) {
+                if (Object.prototype.hasOwnProperty.call(message, 'id')) {
+                    this.handleServerRequest(message);
+                }
+                else {
+                    this.handleNotification(message);
+                }
+            }
+        }
+    }
+    readNextMessage(deadline) {
+        const fd = this.stdoutFd;
+        if (fd === null) {
+            throw new SolidLSPException('Language server stdout is not available.');
+        }
+        while (true) {
+            const message = this.extractMessageFromBuffer();
+            if (message) {
+                this.logWire('server', 'client', message);
+                return message;
+            }
+            if (deadline !== null && Date.now() > deadline) {
+                throw new SolidLSPException(`Request timed out after ${this.requestTimeoutSeconds} seconds.`);
+            }
+            const chunk = Buffer.allocUnsafe(4096);
+            let bytesRead;
+            try {
+                bytesRead = fs.readSync(fd, chunk, 0, chunk.length, null);
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'EAGAIN') {
+                    continue;
+                }
+                throw new SolidLSPException('Failed to read from language server stdout.', err);
+            }
+            if (bytesRead === 0) {
+                if (!this.isRunning()) {
+                    throw new LanguageServerTerminatedException('Language server terminated while waiting for response.');
+                }
+                continue;
+            }
+            this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk.subarray(0, bytesRead)]);
+        }
+    }
+    extractMessageFromBuffer() {
+        if (this.stdoutBuffer.length === 0) {
+            return null;
+        }
+        const headerEnd = this.stdoutBuffer.indexOf(HEADER_SEPARATOR);
+        if (headerEnd === -1) {
+            return null;
+        }
+        const header = this.stdoutBuffer.subarray(0, headerEnd).toString(ENCODING);
+        const headers = header.split('\r\n');
+        let contentLengthValue = null;
+        for (const line of headers) {
+            try {
+                const length = getContentLengthFromHeader(line);
+                if (length !== null) {
+                    contentLengthValue = length;
+                    break;
+                }
+            }
+            catch (error) {
+                throw new SolidLSPException('Invalid Content-Length header.', error);
+            }
+        }
+        if (contentLengthValue === null) {
+            // Drop malformed header and continue.
+            this.stdoutBuffer = this.stdoutBuffer.subarray(headerEnd + HEADER_SEPARATOR.length);
+            return null;
+        }
+        const totalLength = headerEnd + HEADER_SEPARATOR.length + contentLengthValue;
+        if (this.stdoutBuffer.length < totalLength) {
+            return null;
+        }
+        const body = this.stdoutBuffer.subarray(headerEnd + HEADER_SEPARATOR.length, totalLength).toString(ENCODING);
+        this.stdoutBuffer = this.stdoutBuffer.subarray(totalLength);
+        try {
+            return JSON.parse(body);
+        }
+        catch (error) {
+            throw new SolidLSPException('Malformed JSON payload received from language server.', error);
+        }
+    }
+    handleServerRequest(request) {
+        const handler = this.requestHandlers.get(request.method);
+        if (!handler) {
+            const err = new LSPError(ErrorCodes.MethodNotFound, `Unhandled method '${request.method}'.`);
+            this.sendPayload(makeErrorResponse(request.id ?? null, err));
+            return;
+        }
+        try {
+            const result = handler(request.params);
+            this.sendPayload(makeResponse(request.id ?? null, result));
+        }
+        catch (error) {
+            const err = error instanceof LSPError ? error : new LSPError(ErrorCodes.InternalError, String(error));
+            this.sendPayload(makeErrorResponse(request.id ?? null, err));
+        }
+    }
+    handleNotification(request) {
+        const handler = this.notificationHandlers.get(request.method);
+        if (!handler) {
+            return;
+        }
+        try {
+            handler(request.params);
+        }
+        catch (error) {
+            void error;
+        }
+    }
+    sendNotification(method, params = null) {
+        this.sendPayload(makeNotification(method, params));
+    }
+    sendResponse(requestId, params) {
+        this.sendPayload(makeResponse(requestId, params));
+    }
+    sendErrorResponse(requestId, err) {
+        this.sendPayload(makeErrorResponse(requestId, err));
+    }
+    on_request(method, handler) {
+        this.onRequest(method, handler);
+    }
+    onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    onNotification(method, handler) {
+        this.notificationHandlers.set(method, handler);
+    }
+    sendPayload(payload) {
+        const child = this.child;
+        if (!child?.stdin || child.stdin.destroyed) {
+            return;
+        }
+        this.logWire('client', 'server', payload);
+        try {
+            child.stdin.write(createMessage(payload));
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') {
+                if (!this.shuttingDown) {
+                    throw new LanguageServerTerminatedException('Language server stdin is no longer available.', err);
+                }
+                return;
+            }
+            throw new SolidLSPException('Failed to write to language server stdin.', err);
+        }
+    }
+    logWire(source, destination, payload) {
+        if (!this.logger) {
+            return;
+        }
+        try {
+            this.logger(source, destination, payload);
+        }
+        catch (error) {
+            void error;
+        }
+    }
+}
+function isJsonRpcRequest(message) {
+    return typeof message.method === 'string';
+}
+function getStreamFd(stream) {
+    if (!stream) {
+        return null;
+    }
+    const direct = stream.fd;
+    if (typeof direct === 'number') {
+        return direct;
+    }
+    const handleFd = stream._handle?.fd;
+    return typeof handleFd === 'number' ? handleFd : null;
+}
+function normalizeStreamOutput(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString(ENCODING);
+    }
+    return '';
+}
+function getContentLengthFromHeader(line) {
+    const normalized = line.trim().toLowerCase();
+    if (!normalized.startsWith('content-length:')) {
+        return null;
+    }
+    const value = normalized.slice('content-length:'.length).trim();
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid Content-Length header value: ${value}`);
+    }
+    return parsed;
+}