@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/protocol-validation.d.ts

@@ -0,0 +1,4 @@
+type ProtocolDefinition = "InputRequest" | "InputResponses" | "ClientCapabilities" | "ElicitResult" | "CreateMessageResult" | "ListRootsResult" | "DiscoverResult" | "ListToolsResult" | "CallToolResult" | "ListPromptsResult" | "GetPromptResult" | "ListResourcesResult" | "ListResourceTemplatesResult" | "ReadResourceResult" | "CompleteResult" | "Result";
+export declare function validateServerResult(method: string, value: unknown): boolean;
+export declare function validateProtocolValue(definition: ProtocolDefinition, value: unknown): boolean;
+export {};

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/protocol-validation.js

@@ -0,0 +1,53 @@
+import { isBase64 } from "./base64.js";
+import { isValidMetadataKey } from "./metadata.js";
+import { isValidUri } from "./uri.js";
+import { compileJsonSchema } from "toolcraft-schema";
+import { inputRequestSchema } from "./input-request-schema.js";
+import { isJsonValue } from "toolcraft-schema";
+const validators = new Map();
+const protocolSchema = structuredClone(inputRequestSchema);
+const protocolDefinitions = protocolSchema.$defs;
+for (const definition of ["MetaObject", "ResultMetaObject"]) {
+    Object.assign(protocolDefinitions[definition], { propertyNames: { format: "mcp-metadata-key" } });
+}
+for (const definition of ["ClientCapabilities", "ServerCapabilities"]) {
+    const properties = protocolDefinitions[definition].properties;
+    Object.assign(properties.extensions, { propertyNames: { format: "mcp-extension-key" } });
+}
+const resultDefinitions = {
+    "server/discover": "DiscoverResult",
+    "tools/list": "ListToolsResult",
+    "tools/call": "CallToolResult",
+    "prompts/list": "ListPromptsResult",
+    "prompts/get": "GetPromptResult",
+    "resources/list": "ListResourcesResult",
+    "resources/templates/list": "ListResourceTemplatesResult",
+    "resources/read": "ReadResourceResult",
+    "completion/complete": "CompleteResult",
+    "ping": "Result",
+    "logging/setLevel": "Result"
+};
+export function validateServerResult(method, value) {
+    const definition = Object.hasOwn(resultDefinitions, method) ? resultDefinitions[method] : undefined;
+    return definition === undefined || validateProtocolValue(definition, value);
+}
+export function validateProtocolValue(definition, value) {
+    if (!isJsonValue(value))
+        return false;
+    if (definition === "ListRootsResult" && typeof value === "object" && value !== null &&
+        Array.isArray(value.roots) &&
+        !value.roots.every((root) => typeof root?.uri === "string" && root.uri.startsWith("file://") && isValidUri(root.uri)))
+        return false;
+    let validator = validators.get(definition);
+    if (validator === undefined) {
+        validator = compileJsonSchema({ ...protocolSchema, $ref: `#/$defs/${definition}` }, {
+            formats: {
+                "mcp-metadata-key": isValidMetadataKey,
+                "mcp-extension-key": (key) => key.includes("/") && isValidMetadataKey(key),
+                uri: isValidUri, byte: isBase64
+            }
+        });
+        validators.set(definition, validator);
+    }
+    return validator.validate(value).ok;
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/protocol.d.ts

@@ -0,0 +1,17 @@
+import { type HandleResult, type JSONRPCError } from "./types.js";
+export declare const MODERN_PROTOCOL_VERSION = "2026-07-28";
+export declare function selectRequestProtocol(method: string, params: Record<string, unknown> | undefined, legacyVersions: ReadonlySet<string>): {
+    modern: boolean;
+    error?: JSONRPCError;
+};
+export declare function validateInputRequiredResult(method: string, value: Record<string, unknown>, clientCapabilities: Record<string, unknown>): HandleResult | undefined;
+export declare function validateCacheMetadata(method: string, value: Record<string, unknown>): string | undefined;
+export declare function decorateModernResult(method: string, handled: HandleResult, serverInfo: {
+    name: string;
+    version: string;
+}, clientCapabilities?: Record<string, unknown>): HandleResult;
+export { validateProtocolValue, validateServerResult } from "./protocol-validation.js";
+export { isJsonValue } from "toolcraft-schema";
+export { isBase64 } from "./base64.js";
+export { isValidUri } from "./uri.js";
+export { isValidMetadata } from "./metadata.js";

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/protocol.js

@@ -0,0 +1,228 @@
+import { isValidMetadata } from "./metadata.js";
+import { JSON_RPC_ERROR_CODES } from "./types.js";
+import { isJsonValue } from "toolcraft-schema";
+import { validateProtocolValue } from "./protocol-validation.js";
+import { inspectSamplingMessages } from "./sampling-messages.js";
+export const MODERN_PROTOCOL_VERSION = "2026-07-28";
+const removedMethods = new Set([
+    "initialize",
+    "notifications/initialized",
+    "ping",
+    "logging/setLevel",
+    "resources/subscribe",
+    "resources/unsubscribe",
+    "notifications/roots/list_changed"
+]);
+const cacheableMethods = new Set([
+    "server/discover",
+    "tools/list",
+    "prompts/list",
+    "resources/list",
+    "resources/templates/list",
+    "resources/read"
+]);
+const inputRequiredMethods = new Set(["tools/call", "prompts/get", "resources/read"]);
+const inputRequestCapabilities = {
+    "roots/list": "roots",
+    "sampling/createMessage": "sampling",
+    "elicitation/create": "elicitation"
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function selectRequestProtocol(method, params, legacyVersions) {
+    const invalid = {
+        modern: false,
+        error: {
+            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+            message: "Request metadata must include protocolVersion and clientCapabilities"
+        }
+    };
+    const property = Object.getOwnPropertyDescriptor(params ?? {}, "_meta");
+    if (property === undefined || property.enumerable !== true)
+        return method === "server/discover" ? invalid : { modern: false };
+    if (!("value" in property))
+        return invalid;
+    const metadata = property.value;
+    if (!isRecord(metadata))
+        return invalid;
+    if (!isValidMetadata(metadata))
+        return { modern: false, error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP metadata keys"
+            } };
+    const versionKey = "io.modelcontextprotocol/protocolVersion";
+    const capabilitiesKey = "io.modelcontextprotocol/clientCapabilities";
+    if (!(versionKey in metadata) && !(capabilitiesKey in metadata) && method !== "server/discover") {
+        return { modern: false };
+    }
+    const version = metadata[versionKey];
+    if (!Object.prototype.hasOwnProperty.call(metadata, versionKey) ||
+        typeof version !== "string" ||
+        !Object.prototype.hasOwnProperty.call(metadata, capabilitiesKey) ||
+        !isRecord(metadata[capabilitiesKey]))
+        return invalid;
+    if (version !== MODERN_PROTOCOL_VERSION && !legacyVersions.has(version)) {
+        return {
+            modern: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.UNSUPPORTED_PROTOCOL_VERSION,
+                message: "Unsupported protocol version",
+                data: { requested: version, supported: [...legacyVersions].reverse() }
+            }
+        };
+    }
+    const modern = version === MODERN_PROTOCOL_VERSION;
+    if (modern && !validateProtocolValue("ClientCapabilities", metadata[capabilitiesKey])) {
+        return { modern, error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP clientCapabilities"
+            } };
+    }
+    if (modern &&
+        ((params?.requestState !== undefined && typeof params.requestState !== "string") ||
+            (params?.inputResponses !== undefined && !validateProtocolValue("InputResponses", params.inputResponses)))) {
+        return {
+            modern,
+            error: { code: JSON_RPC_ERROR_CODES.INVALID_PARAMS, message: "Invalid MCP retry parameters" }
+        };
+    }
+    if (modern && removedMethods.has(method)) {
+        return {
+            modern,
+            error: { code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND, message: "Method not found" }
+        };
+    }
+    return { modern };
+}
+export function validateInputRequiredResult(method, value, clientCapabilities) {
+    const requests = value.inputRequests;
+    const requiredCapabilities = {};
+    const invalidRequests = requests !== undefined &&
+        (!isRecord(requests) || !isJsonValue(requests) ||
+            Object.values(requests).some((request) => {
+                if (!isRecord(request) || typeof request.method !== "string")
+                    return true;
+                if (!validateProtocolValue("InputRequest", request))
+                    return true;
+                const sampling = request.method === "sampling/createMessage"
+                    ? inspectSamplingMessages(request.params.messages)
+                    : undefined;
+                if (sampling?.valid === false)
+                    return true;
+                if (request.method === "elicitation/create" &&
+                    request.params.mode === "url") {
+                    try {
+                        new URL(request.params.url);
+                    }
+                    catch {
+                        return true;
+                    }
+                }
+                const capability = Object.prototype.hasOwnProperty.call(inputRequestCapabilities, request.method)
+                    ? inputRequestCapabilities[request.method]
+                    : undefined;
+                if (capability === undefined || (request.params !== undefined && !isRecord(request.params)))
+                    return true;
+                const supported = Object.prototype.hasOwnProperty.call(clientCapabilities, capability)
+                    ? clientCapabilities[capability] : undefined;
+                if (!isRecord(supported))
+                    requiredCapabilities[capability] = {};
+                else if (capability === "elicitation") {
+                    const mode = request.params.mode ?? "form";
+                    const implicitForm = mode === "form" && Object.keys(supported).length === 0;
+                    if (!implicitForm && (typeof mode !== "string" ||
+                        !Object.prototype.hasOwnProperty.call(supported, mode) || !isRecord(supported[mode]))) {
+                        const required = requiredCapabilities.elicitation ??= {};
+                        required[String(mode)] = {};
+                    }
+                }
+                else if (capability === "sampling") {
+                    const params = request.params;
+                    if ((params.tools !== undefined || params.toolChoice !== undefined || sampling?.usesTools === true) &&
+                        (!Object.prototype.hasOwnProperty.call(supported, "tools") || !isRecord(supported.tools))) {
+                        const required = requiredCapabilities.sampling ??= {};
+                        required.tools = {};
+                    }
+                }
+                return false;
+            }));
+    if (!inputRequiredMethods.has(method) ||
+        (requests === undefined && value.requestState === undefined) ||
+        (value.requestState !== undefined && typeof value.requestState !== "string") ||
+        invalidRequests) {
+        return {
+            error: {
+                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "Invalid MCP input_required result"
+            }
+        };
+    }
+    if (Object.keys(requiredCapabilities).length > 0) {
+        return { error: {
+                code: -32021,
+                message: "Missing required client capability",
+                data: { requiredCapabilities }
+            } };
+    }
+}
+export function validateCacheMetadata(method, value) {
+    if (!cacheableMethods.has(method))
+        return undefined;
+    if (!Number.isSafeInteger(value.ttlMs) || value.ttlMs < 0) {
+        return "MCP cache ttlMs must be a nonnegative safe integer";
+    }
+    if (value.cacheScope !== "public" && value.cacheScope !== "private") {
+        return "MCP cacheScope must be public or private";
+    }
+    return undefined;
+}
+export function decorateModernResult(method, handled, serverInfo, clientCapabilities = {}) {
+    if (handled.error !== undefined) {
+        return handled.error.code === JSON_RPC_ERROR_CODES.RESOURCE_NOT_FOUND
+            ? { error: { ...handled.error, code: JSON_RPC_ERROR_CODES.INVALID_PARAMS } }
+            : handled;
+    }
+    if (handled.result === undefined && method.startsWith("notifications/"))
+        return handled;
+    const value = handled.result;
+    if (!isRecord(value))
+        return {
+            error: {
+                code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+                message: "MCP result must be an object"
+            }
+        };
+    if (value.resultType !== undefined &&
+        value.resultType !== "complete" &&
+        value.resultType !== "input_required") {
+        return {
+            error: { code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message: "Unrecognized MCP resultType" }
+        };
+    }
+    if (value.resultType === "input_required") {
+        const invalid = validateInputRequiredResult(method, value, clientCapabilities);
+        if (invalid !== undefined)
+            return invalid;
+    }
+    const result = {
+        ...value,
+        resultType: value.resultType ?? "complete",
+        _meta: {
+            ...(isRecord(value._meta) ? value._meta : {}),
+            "io.modelcontextprotocol/serverInfo": { ...serverInfo }
+        }
+    };
+    if (cacheableMethods.has(method) && result.resultType === "complete") {
+        const cacheableResult = { ...result, ttlMs: value.ttlMs === undefined ? 0 : value.ttlMs, cacheScope: value.cacheScope === undefined ? "private" : value.cacheScope };
+        const cacheError = validateCacheMetadata(method, cacheableResult);
+        if (cacheError !== undefined) {
+            return { error: { code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message: cacheError } };
+        }
+        return { result: cacheableResult };
+    }
+    return { result };
+}
+export { validateProtocolValue, validateServerResult } from "./protocol-validation.js";
+export { isJsonValue } from "toolcraft-schema";
+export { isBase64 } from "./base64.js";
+export { isValidUri } from "./uri.js";
+export { isValidMetadata } from "./metadata.js";

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/request-cancellation.d.ts

@@ -0,0 +1 @@
+export declare function waitForRequest<T>(operation: Promise<T>, signal: AbortSignal): Promise<T | undefined>;

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/request-cancellation.js

@@ -0,0 +1,18 @@
+export function waitForRequest(operation, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            signal.removeEventListener("abort", abort);
+            resolve(undefined);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        operation.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/sampling-messages.d.ts

@@ -0,0 +1,18 @@
+type SamplingContent = {
+    type: "tool_use";
+    id: string;
+} | {
+    type: "tool_result";
+    toolUseId: string;
+} | {
+    type: "text" | "image" | "audio";
+};
+export interface SamplingMessage {
+    role: "user" | "assistant";
+    content: SamplingContent | SamplingContent[];
+}
+export declare function inspectSamplingMessages(messages: readonly SamplingMessage[]): {
+    valid: boolean;
+    usesTools: boolean;
+};
+export {};

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/sampling-messages.js

@@ -0,0 +1,34 @@
+// Field schemas must be validated before checking cross-message invariants.
+export function inspectSamplingMessages(messages) {
+    let pending;
+    let usesTools = false;
+    const seenIds = new Set();
+    for (const message of messages) {
+        const content = Array.isArray(message.content) ? message.content : [message.content];
+        if (pending !== undefined) {
+            if (message.role !== "user")
+                return { valid: false, usesTools };
+            for (const block of content) {
+                if (block.type !== "tool_result" || !pending.delete(block.toolUseId))
+                    return { valid: false, usesTools };
+            }
+            if (pending.size > 0)
+                return { valid: false, usesTools };
+            pending = undefined;
+            continue;
+        }
+        for (const block of content) {
+            if (block.type === "tool_result")
+                return { valid: false, usesTools };
+            if (block.type !== "tool_use")
+                continue;
+            if (message.role !== "assistant" || seenIds.has(block.id))
+                return { valid: false, usesTools };
+            seenIds.add(block.id);
+            pending ??= new Set();
+            pending.add(block.id);
+            usesTools = true;
+        }
+    }
+    return { valid: pending === undefined, usesTools };
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/schema.d.ts

@@ -0,0 +1,26 @@
+import type { JSONSchema, OutputSchema } from "./types.js";
+import type { StandardSchema } from "toolcraft-schema";
+export type ToolInputSchema<T> = TypedSchema<T> | StandardSchema<unknown, T>;
+export type ToolOutputSchema<T> = TypedOutputSchema<T> | StandardSchema<T, unknown>;
+type SchemaPropertyType = "string" | "number" | "integer" | "boolean" | "object" | "array";
+interface SchemaPropertyDef {
+    type: SchemaPropertyType;
+    description?: string;
+    optional?: boolean;
+    [keyword: string]: unknown;
+}
+type SchemaDefinition = Record<string, SchemaPropertyDef>;
+type InferType<T extends SchemaPropertyType> = T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "object" ? Record<string, unknown> : T extends "array" ? unknown[] : never;
+type InferSchema<T extends SchemaDefinition> = {
+    [K in keyof T as T[K]["optional"] extends true ? never : K]: InferType<T[K]["type"]>;
+} & {
+    [K in keyof T as T[K]["optional"] extends true ? K : never]?: InferType<T[K]["type"]>;
+};
+export interface TypedSchema<T> extends JSONSchema {
+    __type?: T;
+}
+export interface TypedOutputSchema<T> extends OutputSchema {
+    __type?: T;
+}
+export declare function defineSchema<T extends SchemaDefinition>(definition: T): TypedSchema<InferSchema<T>>;
+export {};

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/schema.js

@@ -0,0 +1,26 @@
+export function defineSchema(definition) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(definition)) {
+        const jsonSchemaProperty = {};
+        for (const [propertyKey, propertyValue] of Object.entries(prop)) {
+            if (propertyKey !== "optional") {
+                jsonSchemaProperty[propertyKey] = propertyValue;
+            }
+        }
+        Object.defineProperty(properties, key, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: jsonSchemaProperty,
+        });
+        if (!prop.optional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required,
+    };
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { type Server } from "./protocol-server.js";
+import type { ServerOptions } from "./types.js";
+export type { CustomMethodHandler, MessageHandler, MessageRequestContext, MessageSession, MessageSessionContext, Server } from "./protocol-server.js";
+export declare function createServer(options: ServerOptions): Server;

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/server.js

@@ -0,0 +1,7 @@
+import * as readline from "node:readline";
+import { createProtocolServer } from "./protocol-server.js";
+import { StdioInput } from "./stdio-input.js";
+import { StdioOutput } from "./stdio-output.js";
+export function createServer(options) {
+    return createProtocolServer(options, { readline, StdioInput, StdioOutput });
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/standard-schema.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/standard-schema.compile-check.js

@@ -0,0 +1,15 @@
+import { S } from "toolcraft-schema";
+import { createServer, defineSchema } from "./index.js";
+const server = createServer({ name: "inference", version: "1" });
+const schema = S.Object({ count: S.Optional(S.Number({ default: 10 })) });
+server.tool("count", "Count", schema, ({ count }) => {
+    const result = count;
+    // @ts-expect-error The default produces a number, not a string.
+    const ignoredWrong = count;
+    return { count: result };
+}, S.Object({ count: S.Number() }));
+server.registerTool({ name: "registered", inputSchema: schema }, ({ count }) => String(count + 1));
+server.tool("transform", "Transform", transformed, ({ count }) => count.toFixed());
+server.tool("output", "Output", defineSchema({}), () => ({ count: "1" }), transformed);
+// @ts-expect-error The output parser requires a string before transformation.
+server.tool("invalid", "Invalid", defineSchema({}), () => ({ count: false }), transformed);

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/stdio-input.d.ts

@@ -0,0 +1,11 @@
+import { Transform, type TransformCallback } from "node:stream";
+export declare class StdioInput extends Transform {
+    private readonly maxLineBytes;
+    private lineBytes;
+    private trailingHighSurrogate;
+    private readonly decoder;
+    constructor(maxLineBytes: number);
+    _transform(chunk: Buffer | string, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private pushSegment;
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/stdio-input.js

@@ -0,0 +1,67 @@
+import { Transform } from "node:stream";
+export class StdioInput extends Transform {
+    maxLineBytes;
+    lineBytes = 0;
+    trailingHighSurrogate = false;
+    decoder = new TextDecoder("utf-8", { fatal: true });
+    constructor(maxLineBytes) {
+        super({ decodeStrings: false, readableObjectMode: true });
+        this.maxLineBytes = maxLineBytes;
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            const text = typeof chunk === "string";
+            if (!text)
+                this.trailingHighSurrogate = false;
+            let start = 0;
+            for (let index = 0; index < chunk.length; index++) {
+                const unit = text ? chunk.charCodeAt(index) : chunk[index];
+                if (unit === 10 || unit === 13) {
+                    this.lineBytes = 0;
+                    this.trailingHighSurrogate = false;
+                    this.pushSegment(text ? chunk.slice(start, index + 1) : chunk.subarray(start, index + 1));
+                    start = index + 1;
+                    if (this.destroyed) {
+                        callback();
+                        return;
+                    }
+                    continue;
+                }
+                if (text) {
+                    const lowSurrogate = unit >= 0xdc00 && unit <= 0xdfff;
+                    this.lineBytes += this.trailingHighSurrogate && lowSurrogate ? 1 : unit <= 0x7f ? 1 : unit <= 0x7ff ? 2 : 3;
+                    this.trailingHighSurrogate = unit >= 0xd800 && unit <= 0xdbff;
+                }
+                else {
+                    this.lineBytes++;
+                }
+                if (this.lineBytes > this.maxLineBytes) {
+                    callback(new Error("Stdio input line byte limit exceeded"));
+                    return;
+                }
+            }
+            if (start < chunk.length)
+                this.pushSegment(text ? chunk.slice(start) : chunk.subarray(start));
+            callback();
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    _flush(callback) {
+        try {
+            this.decoder.decode();
+            callback();
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    pushSegment(segment) {
+        if (typeof segment === "string")
+            this.decoder.decode();
+        else
+            this.decoder.decode(segment, { stream: true });
+        this.push(segment);
+    }
+}

package/node_modules/toolcraft/node_modules/tiny-stdio-mcp-server/dist/stdio-output.d.ts

@@ -0,0 +1,24 @@
+/** One connection's admitted frames, including its submitted, unsettled write. */
+export declare class StdioOutput {
+    private readonly writable;
+    private readonly maxBytes;
+    private readonly onFailure;
+    private readonly onIdle;
+    private readonly queue;
+    private active;
+    private bytes;
+    private stopped;
+    private failure;
+    private awaitingError;
+    constructor(writable: NodeJS.WritableStream, maxBytes: number, onFailure: (error: unknown) => void, onIdle: () => void);
+    get pending(): number;
+    write(data: string): Promise<void>;
+    abort(error: unknown): void;
+    close(): void;
+    private pump;
+    private advance;
+    private readonly onDrain;
+    private readonly onError;
+    private readonly onClose;
+    private detach;
+}