@floegence/flowersec-core 0.27.0 → 2.0.0

package/dist/proxy/controllerWindow.js

@@ -1,384 +0,0 @@
-import { PROXY_WINDOW_FETCH_MSG_TYPE, PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE, PROXY_WINDOW_STREAM_END_MSG_TYPE, PROXY_WINDOW_STREAM_RESET_MSG_TYPE, PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE, PROXY_WINDOW_WS_ERROR_MSG_TYPE, PROXY_WINDOW_WS_BIDIRECTIONAL_ACK_CAPABILITY, PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE, PROXY_WINDOW_WS_OPEN_MSG_TYPE, } from "./windowBridgeProtocol.js";
-function normalizeOrigins(origins) {
-    const out = [];
-    const seen = new Set();
-    for (const origin of origins) {
-        const normalized = String(origin ?? "").trim();
-        if (normalized === "" || seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    return out;
-}
-function cloneChunk(chunk) {
-    const out = new Uint8Array(chunk.byteLength);
-    out.set(chunk);
-    return out.buffer;
-}
-function normalizeCapabilityNonce(value) {
-    if (value == null)
-        return "";
-    const s = String(value);
-    if (s === "")
-        return "";
-    if (s.trim() !== s || /[\s\u0000-\u001f\u007f]/.test(s)) {
-        throw new Error("capabilityNonce must not contain whitespace or control characters");
-    }
-    return s;
-}
-function requireBridgeCapability(expectedSource, capabilityNonce) {
-    if (expectedSource == null && capabilityNonce === "") {
-        throw new Error("expectedSource or capabilityNonce is required");
-    }
-}
-function hasExpectedCapability(data, capabilityNonce) {
-    if (capabilityNonce === "")
-        return true;
-    if (data == null || typeof data !== "object")
-        return false;
-    return data.capabilityNonce === capabilityNonce;
-}
-function withTrustedExternalOrigin(req, rawOrigin) {
-    let externalOrigin;
-    try {
-        const url = new URL(rawOrigin);
-        if (url.protocol === "http:" || url.protocol === "https:") {
-            externalOrigin = url.origin;
-        }
-    }
-    catch {
-        // Opaque and invalid origins must not become upstream authority metadata.
-    }
-    const sanitized = { ...req };
-    delete sanitized.external_origin;
-    return externalOrigin === undefined
-        ? sanitized
-        : { ...sanitized, external_origin: externalOrigin };
-}
-function validWriteId(value) {
-    return Number.isSafeInteger(value) && Number(value) > 0;
-}
-function bridgeWebSocket(runtime, msg, port, onTerminal) {
-    const capabilities = Array.isArray(msg.capabilities)
-        ? msg.capabilities.filter((value) => typeof value === "string")
-        : [];
-    if (!capabilities.includes(PROXY_WINDOW_WS_BIDIRECTIONAL_ACK_CAPABILITY)) {
-        try {
-            port.postMessage({
-                type: PROXY_WINDOW_WS_ERROR_MSG_TYPE,
-                message: "proxy Window bridge requires bidirectional stream acknowledgements",
-            });
-        }
-        catch {
-            // Best-effort.
-        }
-        finally {
-            port.close();
-        }
-        onTerminal();
-        return { dispose: () => { }, isTerminal: () => true };
-    }
-    const ac = new AbortController();
-    let terminal = false;
-    let terminalError = null;
-    let acceptingWrites = true;
-    let stream = null;
-    let pendingInboundWriteId = null;
-    let pendingOutboundAcknowledgement = null;
-    let nextWriteId = 1;
-    const maxBufferedBytes = runtime.limits.maxWsBufferedAmountBytes ?? 4 * (1 << 20);
-    let terminalNotified = false;
-    const notifyTerminal = () => {
-        if (terminalNotified)
-            return;
-        terminalNotified = true;
-        onTerminal();
-    };
-    const closePort = () => {
-        try {
-            port.close();
-        }
-        catch {
-            // Best-effort.
-        }
-    };
-    const failBridge = (error, notifyPeer = true) => {
-        if (terminal)
-            return;
-        terminal = true;
-        acceptingWrites = false;
-        const err = error instanceof Error ? error : new Error(String(error));
-        terminalError = err;
-        pendingInboundWriteId = null;
-        pendingOutboundAcknowledgement?.reject(err);
-        pendingOutboundAcknowledgement = null;
-        if (stream != null) {
-            void Promise.resolve(stream.reset(err)).catch(() => {
-                // The bridge error is already delivered through the terminal response.
-            });
-        }
-        try {
-            ac.abort(err.message);
-        }
-        catch {
-            // Best-effort.
-        }
-        if (notifyPeer) {
-            try {
-                port.postMessage({
-                    type: PROXY_WINDOW_STREAM_RESET_MSG_TYPE,
-                    message: err.message,
-                });
-            }
-            catch {
-                // Best-effort.
-            }
-        }
-        closePort();
-        notifyTerminal();
-    };
-    const failProtocol = (message) => {
-        failBridge(new Error(`proxy Window stream protocol error: ${message}`));
-    };
-    const postChunkAndWait = async (chunk) => {
-        if (chunk.byteLength > maxBufferedBytes) {
-            throw new Error("proxy WebSocket inbound chunk exceeded the buffer limit");
-        }
-        if (!Number.isSafeInteger(nextWriteId)) {
-            throw new Error("proxy Window stream write identifier space exhausted");
-        }
-        if (pendingOutboundAcknowledgement != null) {
-            throw new Error("proxy Window stream already has an unacknowledged outbound chunk");
-        }
-        const writeId = nextWriteId++;
-        const ab = cloneChunk(chunk);
-        await new Promise((resolve, reject) => {
-            pendingOutboundAcknowledgement = { writeId, resolve, reject };
-            try {
-                port.postMessage({
-                    type: PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE,
-                    data: ab,
-                    writeId,
-                }, [ab]);
-            }
-            catch (error) {
-                pendingOutboundAcknowledgement = null;
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-    };
-    port.onmessage = (ev) => {
-        const data = ev.data;
-        if (data == null || typeof data !== "object")
-            return;
-        const type = typeof data.type === "string" ? data.type : "";
-        if (stream == null) {
-            if (type === PROXY_WINDOW_STREAM_RESET_MSG_TYPE) {
-                const message = String(data.message ?? "stream reset");
-                failBridge(new Error(message), false);
-            }
-            else if (type === PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE
-                || type === PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE
-                || type === PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE) {
-                failProtocol("received stream traffic before the websocket opened");
-            }
-            return;
-        }
-        switch (type) {
-            case PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE: {
-                if (!acceptingWrites)
-                    return;
-                const chunkMessage = data;
-                const raw = chunkMessage.data;
-                if (!(raw instanceof ArrayBuffer) || !validWriteId(chunkMessage.writeId)) {
-                    failProtocol("invalid stream chunk");
-                    return;
-                }
-                if (pendingInboundWriteId != null) {
-                    failProtocol("received more than one unacknowledged chunk");
-                    return;
-                }
-                if (raw.byteLength > maxBufferedBytes) {
-                    failBridge(new Error("proxy WebSocket outbound buffer exceeded"));
-                    return;
-                }
-                const writeId = chunkMessage.writeId;
-                const chunk = new Uint8Array(raw);
-                pendingInboundWriteId = writeId;
-                void stream.write(chunk)
-                    .then(() => {
-                    if (terminal)
-                        return;
-                    if (pendingInboundWriteId !== writeId) {
-                        failProtocol("completed write does not match the pending chunk");
-                        return;
-                    }
-                    pendingInboundWriteId = null;
-                    port.postMessage({
-                        type: PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE,
-                        writeId,
-                    });
-                })
-                    .catch((error) => failBridge(error));
-                return;
-            }
-            case PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE: {
-                if (!acceptingWrites)
-                    return;
-                if (pendingInboundWriteId != null) {
-                    failProtocol("stream closed before the pending chunk was acknowledged");
-                    return;
-                }
-                acceptingWrites = false;
-                terminal = true;
-                const closeError = new Error("stream is closed");
-                pendingInboundWriteId = null;
-                pendingOutboundAcknowledgement?.reject(closeError);
-                pendingOutboundAcknowledgement = null;
-                void Promise.resolve(stream.close()).catch(() => {
-                    // The peer already closed its bridge endpoint.
-                });
-                closePort();
-                notifyTerminal();
-                return;
-            }
-            case PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE: {
-                const writeId = data.writeId;
-                const pending = pendingOutboundAcknowledgement;
-                if (!validWriteId(writeId) || pending == null || pending.writeId !== writeId) {
-                    failProtocol("unexpected stream write acknowledgement");
-                    return;
-                }
-                pendingOutboundAcknowledgement = null;
-                pending.resolve();
-                return;
-            }
-            case PROXY_WINDOW_STREAM_RESET_MSG_TYPE: {
-                const message = String(data.message ?? "stream reset");
-                failBridge(new Error(message), false);
-                return;
-            }
-            default:
-                return;
-        }
-    };
-    port.start?.();
-    void (async () => {
-        try {
-            const wsOpts = {
-                signal: ac.signal,
-                ...(msg.protocols === undefined ? {} : { protocols: msg.protocols }),
-            };
-            const opened = await runtime.openWebSocketStream(msg.path, wsOpts);
-            if (terminal) {
-                await Promise.resolve(opened.stream.reset(terminalError ?? new Error("proxy controller Window bridge is closed")));
-                return;
-            }
-            stream = opened.stream;
-            port.postMessage({
-                type: PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE,
-                protocol: opened.protocol,
-                capabilities: [PROXY_WINDOW_WS_BIDIRECTIONAL_ACK_CAPABILITY],
-            });
-            while (!terminal) {
-                const chunk = await stream.read();
-                if (chunk == null) {
-                    terminal = true;
-                    acceptingWrites = false;
-                    port.postMessage({ type: PROXY_WINDOW_STREAM_END_MSG_TYPE });
-                    closePort();
-                    notifyTerminal();
-                    return;
-                }
-                await postChunkAndWait(chunk);
-            }
-        }
-        catch (error) {
-            if (terminal)
-                return;
-            const message = error instanceof Error ? error.message : String(error);
-            if (stream == null) {
-                terminal = true;
-                acceptingWrites = false;
-                terminalError = error instanceof Error ? error : new Error(message);
-                try {
-                    port.postMessage({ type: PROXY_WINDOW_WS_ERROR_MSG_TYPE, message });
-                }
-                finally {
-                    closePort();
-                    notifyTerminal();
-                }
-                return;
-            }
-            failBridge(error);
-        }
-    })();
-    return {
-        dispose: (error) => failBridge(error),
-        isTerminal: () => terminal,
-    };
-}
-export function registerProxyControllerWindow(opts) {
-    const allowedOrigins = normalizeOrigins(opts.allowedOrigins);
-    if (allowedOrigins.length === 0) {
-        throw new Error("allowedOrigins is required");
-    }
-    const capabilityNonce = normalizeCapabilityNonce(opts.capabilityNonce);
-    requireBridgeCapability(opts.expectedSource, capabilityNonce);
-    const activeWebSocketBridges = new Set();
-    let disposed = false;
-    const targetWindow = opts.targetWindow ?? globalThis.window;
-    if (targetWindow == null) {
-        throw new Error("targetWindow is not available");
-    }
-    const onMessage = (ev) => {
-        const eventOrigin = String(ev.origin ?? "").trim();
-        if (!allowedOrigins.includes(eventOrigin))
-            return;
-        if (opts.expectedSource != null && ev.source !== opts.expectedSource)
-            return;
-        const data = ev.data;
-        if (data == null || typeof data !== "object")
-            return;
-        if (!hasExpectedCapability(data, capabilityNonce))
-            return;
-        const type = typeof data.type === "string" ? data.type : "";
-        const port = ev.ports?.[0];
-        if (!port)
-            return;
-        switch (type) {
-            case PROXY_WINDOW_FETCH_MSG_TYPE: {
-                const msg = data;
-                opts.runtime.dispatchFetch(withTrustedExternalOrigin(msg.req, eventOrigin), port);
-                return;
-            }
-            case PROXY_WINDOW_WS_OPEN_MSG_TYPE: {
-                if (disposed)
-                    return;
-                let bridge = null;
-                bridge = bridgeWebSocket(opts.runtime, data, port, () => {
-                    if (bridge != null)
-                        activeWebSocketBridges.delete(bridge);
-                });
-                if (!bridge.isTerminal())
-                    activeWebSocketBridges.add(bridge);
-                return;
-            }
-            default:
-                return;
-        }
-    };
-    targetWindow.addEventListener("message", onMessage);
-    return {
-        dispose: () => {
-            if (disposed)
-                return;
-            disposed = true;
-            targetWindow.removeEventListener("message", onMessage);
-            const error = new Error("proxy controller Window bridge is disposed");
-            for (const bridge of [...activeWebSocketBridges])
-                bridge.dispose(error);
-        },
-    };
-}

package/dist/proxy/cookieJar.d.ts

@@ -1,7 +0,0 @@
-export declare class CookieJar {
-    private readonly cookies;
-    private nextCreatedAtSeq;
-    setCookie(setCookieHeader: string, requestPath?: string): void;
-    updateFromSetCookieHeaders(headers: readonly string[], requestPath?: string): void;
-    getCookieHeader(path: string): string;
-}

package/dist/proxy/cookieJar.js

@@ -1,136 +0,0 @@
-function nowMs() {
-    return Date.now();
-}
-function parseCookieNameValue(s) {
-    const idx = s.indexOf("=");
-    if (idx <= 0)
-        return null;
-    const name = s.slice(0, idx).trim();
-    const value = s.slice(idx + 1).trim();
-    if (name === "")
-        return null;
-    return { name, value };
-}
-function cookieStorageKey(name, path) {
-    return `${name}\u0000${path}`;
-}
-function requestPathOnly(path) {
-    const raw = path.trim();
-    if (!raw.startsWith("/"))
-        return "/";
-    const q = raw.indexOf("?");
-    const out = q >= 0 ? raw.slice(0, q) : raw;
-    return out === "" ? "/" : out;
-}
-function defaultCookiePathFromRequestPath(requestPath) {
-    const path = requestPathOnly(requestPath);
-    if (path === "/")
-        return "/";
-    const lastSlash = path.lastIndexOf("/");
-    if (lastSlash <= 0)
-        return "/";
-    return path.slice(0, lastSlash);
-}
-function normalizeCookiePath(pathAttr, requestPath) {
-    const path = pathAttr?.trim() ?? "";
-    if (path === "" || !path.startsWith("/"))
-        return defaultCookiePathFromRequestPath(requestPath);
-    return path;
-}
-function pathMatchesCookiePath(requestPath, cookiePath) {
-    const path = requestPathOnly(requestPath);
-    if (cookiePath === "/")
-        return true;
-    if (path === cookiePath)
-        return true;
-    if (!path.startsWith(cookiePath))
-        return false;
-    if (cookiePath.endsWith("/"))
-        return true;
-    return path.charAt(cookiePath.length) === "/";
-}
-function compareCookiesForHeader(a, b) {
-    const pathLenDiff = b.path.length - a.path.length;
-    if (pathLenDiff !== 0)
-        return pathLenDiff;
-    return a.createdAtSeq - b.createdAtSeq;
-}
-export class CookieJar {
-    cookies = new Map();
-    nextCreatedAtSeq = 0;
-    setCookie(setCookieHeader, requestPath = "/") {
-        const raw = setCookieHeader.trim();
-        if (raw === "")
-            return;
-        const parts = raw.split(";").map((p) => p.trim()).filter((p) => p !== "");
-        if (parts.length === 0)
-            return;
-        const nv = parseCookieNameValue(parts[0] ?? "");
-        if (nv == null)
-            return;
-        let pathAttr;
-        let expiresAtMs;
-        let maxAgeSeen = false;
-        for (let i = 1; i < parts.length; i++) {
-            const p = parts[i];
-            const lower = p.toLowerCase();
-            if (lower.startsWith("path=")) {
-                const v = p.slice("path=".length).trim();
-                if (v !== "")
-                    pathAttr = v;
-                continue;
-            }
-            if (lower.startsWith("max-age=")) {
-                const v = p.slice("max-age=".length).trim();
-                const n = Number.parseInt(v, 10);
-                if (!Number.isFinite(n))
-                    continue;
-                maxAgeSeen = true;
-                expiresAtMs = n <= 0 ? 0 : nowMs() + n * 1000;
-                continue;
-            }
-            if (lower.startsWith("expires=")) {
-                if (maxAgeSeen)
-                    continue;
-                const v = p.slice("expires=".length).trim();
-                const t = Date.parse(v);
-                if (!Number.isFinite(t))
-                    continue;
-                expiresAtMs = t;
-                continue;
-            }
-        }
-        const path = normalizeCookiePath(pathAttr, requestPath);
-        const key = cookieStorageKey(nv.name, path);
-        if (expiresAtMs != null && expiresAtMs <= nowMs()) {
-            this.cookies.delete(key);
-            return;
-        }
-        const createdAtSeq = this.cookies.get(key)?.createdAtSeq ?? this.nextCreatedAtSeq++;
-        if (expiresAtMs == null) {
-            this.cookies.set(key, { name: nv.name, value: nv.value, path, createdAtSeq });
-        }
-        else {
-            this.cookies.set(key, { name: nv.name, value: nv.value, path, expiresAtMs, createdAtSeq });
-        }
-    }
-    updateFromSetCookieHeaders(headers, requestPath = "/") {
-        for (const h of headers)
-            this.setCookie(h, requestPath);
-    }
-    getCookieHeader(path) {
-        const now = nowMs();
-        const matched = [];
-        for (const [key, c] of this.cookies.entries()) {
-            if (c.expiresAtMs != null && c.expiresAtMs <= now) {
-                this.cookies.delete(key);
-                continue;
-            }
-            if (!pathMatchesCookiePath(path, c.path))
-                continue;
-            matched.push(c);
-        }
-        matched.sort(compareCookiesForHeader);
-        return matched.map((c) => `${c.name}=${c.value}`).join("; ");
-    }
-}

package/dist/proxy/headerPolicy.d.ts

@@ -1,14 +0,0 @@
-import type { Header } from "./types.js";
-export declare function normalizeHeaderName(name: string): string;
-export declare function isValidHeaderName(name: string): boolean;
-export declare function isSafeHeaderValue(value: string): boolean;
-export type FilterHeadersOptions = Readonly<{
-    extraAllowed?: readonly string[];
-}>;
-export declare function filterRequestHeaders(input: readonly Header[], opts?: FilterHeadersOptions): Header[];
-export type FilterResponseResult = Readonly<{
-    passthrough: Header[];
-    setCookie: string[];
-}>;
-export declare function filterResponseHeaders(input: readonly Header[], opts?: FilterHeadersOptions): FilterResponseResult;
-export declare function filterWsOpenHeaders(input: readonly Header[], opts?: FilterHeadersOptions): Header[];

package/dist/proxy/headerPolicy.js

@@ -1,134 +0,0 @@
-const DEFAULT_REQUEST_HEADER_ALLOWLIST = new Set([
-    "accept",
-    "accept-language",
-    "cache-control",
-    "content-type",
-    "if-match",
-    "if-modified-since",
-    "if-none-match",
-    "if-unmodified-since",
-    "origin",
-    "pragma",
-    "range",
-    "x-requested-with"
-]);
-const DEFAULT_RESPONSE_HEADER_ALLOWLIST = new Set([
-    "cache-control",
-    "content-disposition",
-    "content-encoding",
-    "content-language",
-    "content-security-policy",
-    "content-security-policy-report-only",
-    "content-type",
-    "cross-origin-embedder-policy",
-    "cross-origin-opener-policy",
-    "cross-origin-resource-policy",
-    "etag",
-    "expires",
-    "last-modified",
-    "location",
-    "permissions-policy",
-    "pragma",
-    "referrer-policy",
-    "vary",
-    "www-authenticate",
-    "set-cookie",
-    "x-content-type-options",
-    "x-frame-options"
-]);
-const DEFAULT_WS_HEADER_ALLOWLIST = new Set(["sec-websocket-protocol", "cookie"]);
-export function normalizeHeaderName(name) {
-    return name.trim().toLowerCase();
-}
-export function isValidHeaderName(name) {
-    // Minimal RFC 7230 token validation; keep strict to avoid smuggling bugs.
-    for (let i = 0; i < name.length; i++) {
-        const c = name.charCodeAt(i);
-        const isAlpha = c >= 0x61 && c <= 0x7a;
-        const isDigit = c >= 0x30 && c <= 0x39;
-        if (isAlpha || isDigit)
-            continue;
-        // ! # $ % & ' * + - . ^ _ ` | ~
-        if (c === 0x21 || c === 0x23 || c === 0x24 || c === 0x25 || c === 0x26 || c === 0x27)
-            continue;
-        if (c === 0x2a || c === 0x2b || c === 0x2d || c === 0x2e)
-            continue;
-        if (c === 0x5e || c === 0x5f || c === 0x60 || c === 0x7c || c === 0x7e)
-            continue;
-        return false;
-    }
-    return name.length > 0;
-}
-export function isSafeHeaderValue(value) {
-    return !value.includes("\r") && !value.includes("\n");
-}
-function buildExtraAllowedSet(extraAllowed) {
-    if (extraAllowed == null || extraAllowed.length === 0)
-        return null;
-    const s = new Set();
-    for (const n of extraAllowed) {
-        const nn = normalizeHeaderName(n);
-        if (nn !== "" && isValidHeaderName(nn))
-            s.add(nn);
-    }
-    return s;
-}
-function isAllowed(allow, extra, name) {
-    return allow.has(name) || (extra != null && extra.has(name));
-}
-export function filterRequestHeaders(input, opts = {}) {
-    const extra = buildExtraAllowedSet(opts.extraAllowed);
-    const out = [];
-    for (const h of input) {
-        const name = normalizeHeaderName(h.name);
-        if (name === "" || !isValidHeaderName(name))
-            continue;
-        if (!isSafeHeaderValue(h.value))
-            continue;
-        // Never forward these from the client runtime.
-        if (name === "host" || name === "authorization")
-            continue;
-        // Cookie is injected by the runtime CookieJar (not copied from browser cookie store).
-        if (name === "cookie")
-            continue;
-        if (!isAllowed(DEFAULT_REQUEST_HEADER_ALLOWLIST, extra, name))
-            continue;
-        out.push({ name, value: h.value });
-    }
-    return out;
-}
-export function filterResponseHeaders(input, opts = {}) {
-    const extra = buildExtraAllowedSet(opts.extraAllowed);
-    const passthrough = [];
-    const setCookie = [];
-    for (const h of input) {
-        const name = normalizeHeaderName(h.name);
-        if (name === "" || !isValidHeaderName(name))
-            continue;
-        if (!isSafeHeaderValue(h.value))
-            continue;
-        if (!isAllowed(DEFAULT_RESPONSE_HEADER_ALLOWLIST, extra, name))
-            continue;
-        if (name === "set-cookie") {
-            setCookie.push(h.value);
-            continue;
-        }
-        passthrough.push({ name, value: h.value });
-    }
-    return { passthrough, setCookie };
-}
-export function filterWsOpenHeaders(input, opts = {}) {
-    const extra = buildExtraAllowedSet(opts.extraAllowed);
-    const out = [];
-    for (const h of input) {
-        const name = normalizeHeaderName(h.name);
-        if (name === "" || !isValidHeaderName(name))
-            continue;
-        if (!isSafeHeaderValue(h.value))
-            continue;
-        if (!isAllowed(DEFAULT_WS_HEADER_ALLOWLIST, extra, name))
-            continue;
-        out.push({ name, value: h.value });
-    }
-    return out;
-}

package/dist/proxy/portStream.d.ts

@@ -1,5 +0,0 @@
-import type { YamuxStream } from "../yamux/stream.js";
-export declare function createMessagePortBackedStream(port: MessagePort, opts?: Readonly<{
-    maxBufferedBytes?: number;
-    onTerminal?: () => void;
-}>): YamuxStream;