@floegence/flowersec-core 0.26.0 → 2.0.0

package/dist/proxy/windowBridgeProtocol.d.ts

@@ -1,65 +0,0 @@
-import type { Header } from "./types.js";
-export declare const PROXY_WINDOW_FETCH_FORWARD_MSG_TYPE = "flowersec-proxy:window_fetch";
-export declare const PROXY_WINDOW_FETCH_MSG_TYPE = "flowersec-proxy:fetch";
-export declare const PROXY_WINDOW_WS_OPEN_MSG_TYPE = "flowersec-proxy:ws_open";
-export declare const PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE = "flowersec-proxy:ws_open_ack";
-export declare const PROXY_WINDOW_WS_BIDIRECTIONAL_ACK_CAPABILITY = "stream_bidirectional_ack_v2";
-export declare const PROXY_WINDOW_WS_ERROR_MSG_TYPE = "flowersec-proxy:ws_error";
-export declare const PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE = "flowersec-proxy:stream_chunk";
-export declare const PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE = "flowersec-proxy:stream_write_ack";
-export declare const PROXY_WINDOW_STREAM_END_MSG_TYPE = "flowersec-proxy:stream_end";
-export declare const PROXY_WINDOW_STREAM_RESET_MSG_TYPE = "flowersec-proxy:stream_reset";
-export declare const PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE = "flowersec-proxy:stream_close";
-export type ProxyWindowFetchRequest = Readonly<{
-    id: string;
-    method: string;
-    path: string;
-    headers: readonly Header[];
-    external_origin?: string;
-    response_flow_control?: "chunk_credit_v1";
-    body?: ArrayBuffer;
-}>;
-export type ProxyWindowFetchForwardMsg = Readonly<{
-    type: typeof PROXY_WINDOW_FETCH_FORWARD_MSG_TYPE;
-    req: ProxyWindowFetchRequest;
-}>;
-export type ProxyWindowFetchMsg = Readonly<{
-    type: typeof PROXY_WINDOW_FETCH_MSG_TYPE;
-    req: ProxyWindowFetchRequest;
-    capabilityNonce?: string;
-}>;
-export type ProxyWindowWsOpenMsg = Readonly<{
-    type: typeof PROXY_WINDOW_WS_OPEN_MSG_TYPE;
-    path: string;
-    protocols?: readonly string[];
-    capabilities: readonly string[];
-    capabilityNonce?: string;
-}>;
-export type ProxyWindowWsOpenAckMsg = Readonly<{
-    type: typeof PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE;
-    protocol: string;
-    capabilities: readonly string[];
-}>;
-export type ProxyWindowWsErrorMsg = Readonly<{
-    type: typeof PROXY_WINDOW_WS_ERROR_MSG_TYPE;
-    message: string;
-}>;
-export type ProxyWindowStreamChunkMsg = Readonly<{
-    type: typeof PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE;
-    data: ArrayBuffer;
-    writeId: number;
-}>;
-export type ProxyWindowStreamWriteAckMsg = Readonly<{
-    type: typeof PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE;
-    writeId: number;
-}>;
-export type ProxyWindowStreamEndMsg = Readonly<{
-    type: typeof PROXY_WINDOW_STREAM_END_MSG_TYPE;
-}>;
-export type ProxyWindowStreamResetMsg = Readonly<{
-    type: typeof PROXY_WINDOW_STREAM_RESET_MSG_TYPE;
-    message: string;
-}>;
-export type ProxyWindowStreamCloseMsg = Readonly<{
-    type: typeof PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE;
-}>;

package/dist/proxy/windowBridgeProtocol.js

@@ -1,11 +0,0 @@
-export const PROXY_WINDOW_FETCH_FORWARD_MSG_TYPE = "flowersec-proxy:window_fetch";
-export const PROXY_WINDOW_FETCH_MSG_TYPE = "flowersec-proxy:fetch";
-export const PROXY_WINDOW_WS_OPEN_MSG_TYPE = "flowersec-proxy:ws_open";
-export const PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE = "flowersec-proxy:ws_open_ack";
-export const PROXY_WINDOW_WS_BIDIRECTIONAL_ACK_CAPABILITY = "stream_bidirectional_ack_v2";
-export const PROXY_WINDOW_WS_ERROR_MSG_TYPE = "flowersec-proxy:ws_error";
-export const PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE = "flowersec-proxy:stream_chunk";
-export const PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE = "flowersec-proxy:stream_write_ack";
-export const PROXY_WINDOW_STREAM_END_MSG_TYPE = "flowersec-proxy:stream_end";
-export const PROXY_WINDOW_STREAM_RESET_MSG_TYPE = "flowersec-proxy:stream_reset";
-export const PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE = "flowersec-proxy:stream_close";

package/dist/reconnect/artifactControlplane.d.ts

@@ -1,16 +0,0 @@
-import type { ConnectArtifact } from "../connect/artifact.js";
-import { type RequestConnectArtifactInput, type RequestEntryConnectArtifactInput } from "../controlplane/index.js";
-export type ArtifactAcquireContext = Readonly<{
-    traceId?: string;
-    signal?: AbortSignal;
-}>;
-export type ArtifactSource = Readonly<{
-    kind: "once";
-    artifact: ConnectArtifact;
-}> | Readonly<{
-    kind: "refreshable";
-    acquire: (context: ArtifactAcquireContext) => Promise<ConnectArtifact>;
-}>;
-export declare function createControlplaneArtifactSource(input: RequestConnectArtifactInput | RequestEntryConnectArtifactInput): ArtifactSource;
-export declare function createArtifactResolver(source: ArtifactSource): (context: ArtifactAcquireContext) => Promise<ConnectArtifact>;
-export declare function updateTraceId(current: string | undefined, artifact: ConnectArtifact): string | undefined;

package/dist/reconnect/artifactControlplane.js

@@ -1,35 +0,0 @@
-import { requestConnectArtifact, requestEntryConnectArtifact, } from "../controlplane/index.js";
-export function createControlplaneArtifactSource(input) {
-    return {
-        kind: "refreshable",
-        acquire: async ({ traceId, signal }) => {
-            const correlation = traceId === undefined ? input.correlation : { traceId };
-            if ("entryTicket" in input) {
-                return await requestEntryConnectArtifact({
-                    ...input,
-                    ...(correlation === undefined ? {} : { correlation }),
-                    ...(signal === undefined ? {} : { signal }),
-                });
-            }
-            return await requestConnectArtifact({
-                ...input,
-                ...(correlation === undefined ? {} : { correlation }),
-                ...(signal === undefined ? {} : { signal }),
-            });
-        },
-    };
-}
-export function createArtifactResolver(source) {
-    let consumed = false;
-    return async (context) => {
-        if (source.kind === "refreshable")
-            return await source.acquire(context);
-        if (consumed)
-            throw new Error("one-time artifact source has already been consumed");
-        consumed = true;
-        return source.artifact;
-    };
-}
-export function updateTraceId(current, artifact) {
-    return artifact.correlation?.trace_id ?? current;
-}

package/dist/reconnect/index.d.ts

@@ -1,36 +0,0 @@
-import type { Client } from "../client.js";
-import { type ClientObserverLike } from "../observability/observer.js";
-export type { ArtifactAcquireContext, ArtifactSource } from "./artifactControlplane.js";
-export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
-export type ConnectionStatus = "disconnected" | "connecting" | "connected" | "error";
-export type AutoReconnectConfig = Readonly<{
-    enabled?: boolean;
-    maxAttempts?: number;
-    initialDelayMs?: number;
-    maxDelayMs?: number;
-    factor?: number;
-    jitterRatio?: number;
-}>;
-export type ReconnectState = Readonly<{
-    status: ConnectionStatus;
-    error: Error | null;
-    client: Client | null;
-}>;
-export type ReconnectListener = (state: ReconnectState) => void;
-export type ConnectOnce = (args: Readonly<{
-    signal: AbortSignal;
-    observer: ClientObserverLike;
-}>) => Promise<Client>;
-export type ConnectConfig = Readonly<{
-    connectOnce: ConnectOnce;
-    observer?: ClientObserverLike;
-    autoReconnect?: AutoReconnectConfig;
-}>;
-export type ReconnectManager = Readonly<{
-    state: () => ReconnectState;
-    subscribe: (listener: ReconnectListener) => () => void;
-    connect: (config: ConnectConfig) => Promise<void>;
-    connectIfNeeded: (config: ConnectConfig) => Promise<void>;
-    disconnect: () => void;
-}>;
-export declare function createReconnectManager(): ReconnectManager;

package/dist/reconnect/index.js

@@ -1,388 +0,0 @@
-import { getClientTermination } from "../client-connect/termination.js";
-import { emitObserverDiagnostic, withObserverContext } from "../observability/observer.js";
-import { SDK_DEFAULTS } from "../defaults.js";
-import { AbortError, FlowersecError } from "../utils/errors.js";
-export { createArtifactResolver, createControlplaneArtifactSource } from "./artifactControlplane.js";
-function normalizeAutoReconnect(cfg) {
-    const settings = {
-        enabled: cfg?.enabled === true,
-        maxAttempts: cfg?.enabled === true ? (cfg.maxAttempts ?? SDK_DEFAULTS.reconnect.maxAttempts) : 1,
-        initialDelayMs: cfg?.initialDelayMs ?? SDK_DEFAULTS.reconnect.initialDelayMs,
-        maxDelayMs: cfg?.maxDelayMs ?? SDK_DEFAULTS.reconnect.maxDelayMs,
-        factor: cfg?.factor ?? SDK_DEFAULTS.reconnect.factor,
-        jitterRatio: cfg?.jitterRatio ?? SDK_DEFAULTS.reconnect.jitterRatio,
-    };
-    if (!Number.isSafeInteger(settings.maxAttempts) || settings.maxAttempts < 1) {
-        throw new TypeError("autoReconnect.maxAttempts must be a positive integer");
-    }
-    if (!Number.isFinite(settings.initialDelayMs) || settings.initialDelayMs < 0) {
-        throw new TypeError("autoReconnect.initialDelayMs must be a non-negative finite number");
-    }
-    if (!Number.isFinite(settings.maxDelayMs) || settings.maxDelayMs < 0) {
-        throw new TypeError("autoReconnect.maxDelayMs must be a non-negative finite number");
-    }
-    if (!Number.isFinite(settings.factor) || settings.factor < 1) {
-        throw new TypeError("autoReconnect.factor must be a finite number greater than or equal to one");
-    }
-    if (!Number.isFinite(settings.jitterRatio) || settings.jitterRatio < 0 || settings.jitterRatio > 1) {
-        throw new TypeError("autoReconnect.jitterRatio must be a finite number between zero and one");
-    }
-    return settings;
-}
-function backoffDelayMs(attemptIndex, cfg) {
-    const base = Math.min(cfg.maxDelayMs, cfg.initialDelayMs * Math.pow(cfg.factor, attemptIndex));
-    const jitter = cfg.jitterRatio <= 0 ? 0 : base * cfg.jitterRatio * (Math.random() * 2 - 1);
-    return Math.max(0, Math.round(base + jitter));
-}
-const TERMINAL_RECONNECT_CODES = new Set([
-    "invalid_input",
-    "invalid_option",
-    "role_mismatch",
-    "transport_policy_denied",
-    "invalid_psk",
-    "invalid_suite",
-    "missing_grant",
-    "missing_connect_info",
-    "missing_tunnel_url",
-    "missing_ws_url",
-    "missing_channel_id",
-    "missing_token",
-    "missing_init_exp",
-]);
-function isTerminalConnectError(error) {
-    if (error instanceof AbortError || error.name === "AbortError")
-        return true;
-    return error instanceof FlowersecError && (error.code === "canceled" || TERMINAL_RECONNECT_CODES.has(error.code));
-}
-function isSameConfig(a, b) {
-    if (a == null)
-        return false;
-    if (a.connectOnce !== b.connectOnce)
-        return false;
-    if (a.observer !== b.observer)
-        return false;
-    const aa = normalizeAutoReconnect(a.autoReconnect);
-    const bb = normalizeAutoReconnect(b.autoReconnect);
-    return (aa.enabled === bb.enabled &&
-        aa.maxAttempts === bb.maxAttempts &&
-        aa.initialDelayMs === bb.initialDelayMs &&
-        aa.maxDelayMs === bb.maxDelayMs &&
-        aa.factor === bb.factor &&
-        aa.jitterRatio === bb.jitterRatio);
-}
-export function createReconnectManager() {
-    let s = { status: "disconnected", error: null, client: null };
-    const listeners = new Set();
-    const setState = (next) => {
-        s = next;
-        for (const fn of listeners) {
-            try {
-                fn(s);
-            }
-            catch {
-                // ignore listener errors
-            }
-        }
-    };
-    let token = 0;
-    let active = null;
-    let activeConnectPromise = null;
-    let retryTimer = null;
-    let retryResolve = null;
-    let attemptAbort = null;
-    let attemptSeq = 0;
-    const cancelRetrySleep = () => {
-        if (retryTimer) {
-            clearTimeout(retryTimer);
-            retryTimer = null;
-        }
-        retryResolve?.();
-        retryResolve = null;
-    };
-    const abortActiveAttempt = () => {
-        attemptAbort?.abort("canceled");
-        attemptAbort = null;
-    };
-    const closeClient = (value) => {
-        if (value == null)
-            return null;
-        try {
-            value.close();
-            return null;
-        }
-        catch (error) {
-            return asError(error);
-        }
-    };
-    const sleep = (ms) => new Promise((resolve) => {
-        retryResolve = resolve;
-        retryTimer = setTimeout(() => {
-            retryTimer = null;
-            retryResolve = null;
-            resolve();
-        }, ms);
-    });
-    const finishWithError = (cfg, error, currentAttemptSeq) => {
-        setState({ status: "error", error, client: null });
-        emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq: currentAttemptSeq }), {
-            path: "auto",
-            stage: "reconnect",
-            code_domain: "event",
-            code: "reconnect_exhausted",
-            result: "fail",
-        });
-    };
-    const scheduleRetry = async (t, cfg, error, settings, failedAttemptIndex, currentAttemptSeq) => {
-        if (t !== token || active !== cfg)
-            return false;
-        setState({ status: "connecting", error, client: null });
-        emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq: currentAttemptSeq }), {
-            path: "auto",
-            stage: "reconnect",
-            code_domain: "event",
-            code: "reconnect_scheduled",
-            result: "retry",
-        });
-        await sleep(backoffDelayMs(failedAttemptIndex, settings));
-        return t === token && active === cfg;
-    };
-    const disconnectInternal = () => {
-        cancelRetrySleep();
-        abortActiveAttempt();
-        active = null;
-        activeConnectPromise = null;
-        token += 1;
-        attemptSeq = 0;
-        const closeError = closeClient(s.client);
-        if (closeError != null) {
-            setState({ status: "error", error: closeError, client: null });
-            throw closeError;
-        }
-        setState({ status: "disconnected", error: null, client: null });
-    };
-    const startReconnect = (t, cfg, error) => {
-        if (t !== token)
-            return;
-        if (active !== cfg)
-            return;
-        if (s.status !== "connected")
-            return;
-        const ar = normalizeAutoReconnect(cfg.autoReconnect);
-        if (!ar.enabled) {
-            const closeError = closeClient(s.client);
-            const finalError = closeError == null
-                ? error
-                : new AggregateError([error, closeError], "reconnect termination and client close failed");
-            setState({ status: "error", error: finalError, client: null });
-            return;
-        }
-        // Restart the connection loop in the background.
-        cancelRetrySleep();
-        abortActiveAttempt();
-        const closeError = closeClient(s.client);
-        if (closeError != null) {
-            setState({
-                status: "error",
-                error: new AggregateError([error, closeError], "reconnect termination and client close failed"),
-                client: null,
-            });
-            return;
-        }
-        token += 1;
-        const nextToken = token;
-        const reconnectPromise = startConnectLoop(nextToken, cfg, error);
-        void reconnectPromise.catch(() => {
-            // connectWithRetry updates state; keep errors observable via state().
-        });
-    };
-    const createObserver = (t, cfg, currentAttemptSeq) => {
-        const user = cfg.observer;
-        return withObserverContext({
-            onConnect: (...args) => user?.onConnect?.(...args),
-            onAttach: (...args) => user?.onAttach?.(...args),
-            onHandshake: (...args) => user?.onHandshake?.(...args),
-            onWsClose: (kind, code) => {
-                user?.onWsClose?.(kind, code);
-                if (kind === "peer_or_error") {
-                    startReconnect(t, cfg, new Error(`WebSocket closed (${code ?? "unknown"})`));
-                }
-            },
-            onWsError: (reason) => {
-                user?.onWsError?.(reason);
-                startReconnect(t, cfg, new Error(`WebSocket error: ${reason}`));
-            },
-            onRpcCall: (...args) => user?.onRpcCall?.(...args),
-            onRpcNotify: (...args) => user?.onRpcNotify?.(...args),
-            onDiagnosticEvent: (event) => {
-                user?.onDiagnosticEvent?.(event);
-                if (event.code === "liveness_timeout") {
-                    startReconnect(t, cfg, new Error("liveness timeout"));
-                }
-            },
-        }, {
-            attemptSeq: currentAttemptSeq,
-        });
-    };
-    const connectOnce = async (t, cfg, currentAttemptSeq) => {
-        abortActiveAttempt();
-        attemptAbort = new AbortController();
-        return await cfg.connectOnce({ signal: attemptAbort.signal, observer: createObserver(t, cfg, currentAttemptSeq) ?? {} });
-    };
-    const connectWithRetry = async (t, cfg, initialFailure) => {
-        const ar = normalizeAutoReconnect(cfg.autoReconnect);
-        let attempts = 0;
-        if (initialFailure != null) {
-            if (isTerminalConnectError(initialFailure)) {
-                finishWithError(cfg, initialFailure, attemptSeq);
-                throw initialFailure;
-            }
-            if (!await scheduleRetry(t, cfg, initialFailure, ar, 0, attemptSeq))
-                return;
-        }
-        for (;;) {
-            if (t !== token)
-                return;
-            if (active !== cfg)
-                return;
-            attempts += 1;
-            attemptSeq += 1;
-            emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq }), {
-                path: "auto",
-                stage: "reconnect",
-                code_domain: "event",
-                code: attempts === 1 ? "reconnect_attempt" : "reconnect_retry_attempt",
-                result: "retry",
-            });
-            try {
-                const client = await connectOnce(t, cfg, attemptSeq);
-                if (t !== token) {
-                    const closeError = closeClient(client);
-                    if (closeError != null)
-                        throw new ReconnectCleanupError(closeError);
-                    return;
-                }
-                if (active !== cfg) {
-                    const closeError = closeClient(client);
-                    if (closeError != null)
-                        throw new ReconnectCleanupError(closeError);
-                    return;
-                }
-                setState({ status: "connected", client, error: null });
-                const termination = getClientTermination(client);
-                if (termination != null) {
-                    void termination.then(({ error }) => {
-                        if (s.client !== client)
-                            return;
-                        startReconnect(t, cfg, error);
-                    }, (error) => {
-                        if (s.client !== client)
-                            return;
-                        startReconnect(t, cfg, asError(error));
-                    });
-                }
-                emitObserverDiagnostic(withObserverContext(cfg.observer, { attemptSeq }), {
-                    path: "auto",
-                    stage: "reconnect",
-                    code_domain: "event",
-                    code: "reconnect_connected",
-                    result: "ok",
-                });
-                return;
-            }
-            catch (err) {
-                if (err instanceof ReconnectCleanupError)
-                    throw err.cleanupError;
-                const e = err instanceof Error ? err : new Error(String(err));
-                if (t !== token)
-                    return;
-                if (active !== cfg)
-                    return;
-                const canRetry = ar.enabled && attempts < ar.maxAttempts && !isTerminalConnectError(e);
-                if (!canRetry) {
-                    finishWithError(cfg, e, attemptSeq);
-                    throw e;
-                }
-                if (!await scheduleRetry(t, cfg, e, ar, attempts - 1, attemptSeq))
-                    return;
-            }
-        }
-    };
-    const startConnectLoop = (t, cfg, initialFailure) => {
-        let resolveLoop;
-        let rejectLoop;
-        const loop = new Promise((resolve, reject) => {
-            resolveLoop = resolve;
-            rejectLoop = reject;
-        });
-        let promise;
-        promise = loop.finally(() => {
-            if (activeConnectPromise === promise)
-                activeConnectPromise = null;
-        });
-        activeConnectPromise = promise;
-        void connectWithRetry(t, cfg, initialFailure).then(resolveLoop, rejectLoop);
-        return promise;
-    };
-    const connect = async (cfg) => {
-        normalizeAutoReconnect(cfg.autoReconnect);
-        cancelRetrySleep();
-        abortActiveAttempt();
-        token += 1;
-        const t = token;
-        active = cfg;
-        attemptSeq = 0;
-        const closeError = closeClient(s.client);
-        if (closeError != null) {
-            active = null;
-            setState({ status: "error", error: closeError, client: null });
-            throw closeError;
-        }
-        const connectPromise = startConnectLoop(t, cfg, null);
-        setState({ status: "connecting", error: null, client: null });
-        await connectPromise;
-    };
-    const connectIfNeeded = async (cfg) => {
-        if (isSameConfig(active, cfg)) {
-            if (activeConnectPromise) {
-                await activeConnectPromise;
-                return;
-            }
-            if (s.status === "connected" && s.client)
-                return;
-        }
-        await connect(cfg);
-    };
-    const disconnect = () => {
-        disconnectInternal();
-    };
-    return {
-        state: () => s,
-        subscribe: (listener) => {
-            listeners.add(listener);
-            // Push the current state immediately for convenience.
-            try {
-                listener(s);
-            }
-            catch {
-                // ignore
-            }
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        connect,
-        connectIfNeeded,
-        disconnect,
-    };
-}
-class ReconnectCleanupError extends Error {
-    cleanupError;
-    constructor(cleanupError) {
-        super("reconnect cleanup failed", { cause: cleanupError });
-        this.cleanupError = cleanupError;
-        this.name = "ReconnectCleanupError";
-    }
-}
-function asError(value) {
-    return value instanceof Error ? value : new Error(String(value));
-}

package/dist/rpc-proxy/index.d.ts

@@ -1 +0,0 @@
-export * from "./rpcProxy.js";

package/dist/rpc-proxy/index.js

@@ -1 +0,0 @@
-export * from "./rpcProxy.js";

package/dist/rpc-proxy/rpcProxy.d.ts

@@ -1 +0,0 @@
-export { RpcProxy, RpcProxyDetachedError } from "../rpc/rpcProxy.js";

package/dist/rpc-proxy/rpcProxy.js

@@ -1 +0,0 @@
-export { RpcProxy, RpcProxyDetachedError } from "../rpc/rpcProxy.js";

package/dist/streamhello/index.d.ts

@@ -1 +0,0 @@
-export * from "./streamHello.js";

package/dist/streamhello/index.js

@@ -1 +0,0 @@
-export * from "./streamHello.js";

package/dist/streamhello/streamHello.d.ts

@@ -1,3 +0,0 @@
-import type { StreamHello } from "../gen/flowersec/rpc/v1.gen.js";
-export declare function writeStreamHello(write: (b: Uint8Array) => Promise<void>, kind: string): Promise<void>;
-export declare function readStreamHello(readExactly: (n: number) => Promise<Uint8Array>): Promise<StreamHello>;

package/dist/streamhello/streamHello.js

@@ -1,13 +0,0 @@
-import { readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
-// writeStreamHello sends the initial stream greeting.
-export async function writeStreamHello(write, kind) {
-    const h = { kind, v: 1 };
-    await writeJsonFrame(write, h);
-}
-// readStreamHello reads and validates the stream greeting.
-export async function readStreamHello(readExactly) {
-    const h = (await readJsonFrame(readExactly, 8 * 1024));
-    if (h.v !== 1 || typeof h.kind !== "string" || h.kind.length === 0)
-        throw new Error("bad StreamHello");
-    return h;
-}

package/dist/streamio/index.d.ts

@@ -1,32 +0,0 @@
-import type { Client } from "../client.js";
-import { ByteReader } from "../yamux/byteReader.js";
-import type { YamuxStream } from "../yamux/stream.js";
-export declare function readMaybe(stream: YamuxStream): Promise<Uint8Array | null>;
-export declare function createByteReader(stream: YamuxStream, opts?: Readonly<{
-    signal?: AbortSignal;
-}>): ByteReader;
-export declare function readExactly(reader: ByteReader, n: number, opts?: Readonly<{
-    signal?: AbortSignal;
-}>): Promise<Uint8Array>;
-export type ReadNBytesOptions = Readonly<{
-    chunkSize?: number;
-    signal?: AbortSignal;
-    onProgress?: (read: number) => void;
-}>;
-export declare function readNBytes(reader: ByteReader, n: number, opts?: ReadNBytesOptions): Promise<Uint8Array>;
-export type JsonFrameChannel = Readonly<{
-    stream: YamuxStream;
-    reader: ByteReader;
-    writeFrame: (value: unknown) => Promise<void>;
-    readFrame: <T = unknown>(opts?: Readonly<{
-        maxBytes?: number;
-        assert?: (value: unknown) => T;
-    }>) => Promise<T>;
-    close: () => Promise<void>;
-}>;
-export type JsonFrameChannelOptions = Readonly<{
-    signal?: AbortSignal;
-    maxJsonFrameBytes?: number;
-}>;
-export declare function createJsonFrameChannel(stream: YamuxStream, opts?: JsonFrameChannelOptions): JsonFrameChannel;
-export declare function openJsonFrameChannel(client: Pick<Client, "openStream">, kind: string, opts?: JsonFrameChannelOptions): Promise<JsonFrameChannel>;