@floegence/flowersec-core 0.1.1

package/dist/node/connect.js

@@ -0,0 +1,13 @@
+import { connectDirect } from "../direct-client/connect.js";
+import { connectTunnel } from "../tunnel-client/connect.js";
+import { connect } from "../facade.js";
+import { createNodeWsFactory } from "./wsFactory.js";
+export async function connectNode(input, opts) {
+    return await connect(input, { ...opts, wsFactory: opts.wsFactory ?? createNodeWsFactory() });
+}
+export async function connectTunnelNode(grant, opts) {
+    return await connectTunnel(grant, { ...opts, wsFactory: opts.wsFactory ?? createNodeWsFactory() });
+}
+export async function connectDirectNode(info, opts) {
+    return await connectDirect(info, { ...opts, wsFactory: opts.wsFactory ?? createNodeWsFactory() });
+}

package/dist/node/index.d.ts

@@ -0,0 +1,2 @@
+export { createNodeWsFactory } from "./wsFactory.js";
+export { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";

package/dist/node/index.js

@@ -0,0 +1,2 @@
+export { createNodeWsFactory } from "./wsFactory.js";
+export { connectDirectNode, connectNode, connectTunnelNode } from "./connect.js";

package/dist/node/wsFactory.d.ts

@@ -0,0 +1,2 @@
+import type { WebSocketLike } from "../ws-client/binaryTransport.js";
+export declare function createNodeWsFactory(): (url: string, origin: string) => WebSocketLike;

package/dist/node/wsFactory.js

@@ -0,0 +1,69 @@
+import { createRequire } from "node:module";
+// createNodeWsFactory returns a wsFactory compatible with connectTunnel/connectDirect in Node.js.
+//
+// It uses the "ws" package to set the Origin header explicitly (browsers set Origin automatically).
+export function createNodeWsFactory() {
+    const require = createRequire(import.meta.url);
+    const wsMod = require("ws");
+    const WebSocketCtor = wsMod?.WebSocket ?? wsMod;
+    return (url, origin) => {
+        const raw = new WebSocketCtor(url, { headers: { Origin: origin } });
+        // Map (type -> user listener -> wrapped listener) so removeEventListener works.
+        const listeners = new Map();
+        const addEventListener = (type, listener) => {
+            const wrapped = (...args) => {
+                if (type === "message") {
+                    listener({ data: args[0] });
+                    return;
+                }
+                if (type === "close") {
+                    const code = typeof args[0] === "number" ? args[0] : undefined;
+                    const reason = typeof args[1] === "string"
+                        ? args[1]
+                        : args[1] != null && typeof args[1].toString === "function"
+                            ? args[1].toString()
+                            : undefined;
+                    listener({ code, reason });
+                    return;
+                }
+                listener(args[0]);
+            };
+            let m = listeners.get(type);
+            if (m == null) {
+                m = new Map();
+                listeners.set(type, m);
+            }
+            m.set(listener, wrapped);
+            raw.on(type, wrapped);
+        };
+        const removeEventListener = (type, listener) => {
+            const m = listeners.get(type);
+            const wrapped = m?.get(listener);
+            if (wrapped == null)
+                return;
+            m.delete(listener);
+            raw.off(type, wrapped);
+            if (m.size === 0)
+                listeners.delete(type);
+        };
+        return {
+            get binaryType() {
+                return raw.binaryType;
+            },
+            set binaryType(v) {
+                raw.binaryType = v;
+            },
+            get readyState() {
+                return raw.readyState;
+            },
+            send(data) {
+                raw.send(data);
+            },
+            close(code, reason) {
+                raw.close(code, reason);
+            },
+            addEventListener,
+            removeEventListener,
+        };
+    };
+}

package/dist/observability/index.d.ts

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

package/dist/observability/index.js

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

package/dist/observability/observer.d.ts

@@ -0,0 +1,23 @@
+import type { ClientPath } from "../client.js";
+export type ConnectResult = "ok" | "fail";
+export type ConnectReason = "websocket_error" | "websocket_closed" | "timeout" | "canceled";
+export type AttachResult = "ok" | "fail";
+export type AttachReason = "send_failed" | "too_many_connections" | "expected_attach" | "invalid_attach" | "invalid_token" | "channel_mismatch" | "role_mismatch" | "token_replay" | "replace_rate_limited" | "attach_failed";
+export type HandshakeResult = "ok" | "fail";
+export type HandshakeReason = "auth_tag_mismatch" | "handshake_failed" | "invalid_version" | "timestamp_after_init_exp" | "timestamp_out_of_skew" | "timeout" | "canceled";
+export type WsCloseKind = "local" | "peer_or_error";
+export type WsErrorReason = "error" | "recv_buffer_exceeded" | "unexpected_text_frame" | "unexpected_message_type";
+export type RpcCallResult = "ok" | "rpc_error" | "handler_not_found" | "transport_error" | "canceled";
+export type ClientObserver = {
+    onConnect(path: ClientPath, result: ConnectResult, reason: ConnectReason | undefined, elapsedSeconds: number): void;
+    onAttach(result: AttachResult, reason: AttachReason | undefined): void;
+    onHandshake(path: ClientPath, result: HandshakeResult, reason: HandshakeReason | undefined, elapsedSeconds: number): void;
+    onWsClose(kind: WsCloseKind, code?: number): void;
+    onWsError(reason: WsErrorReason): void;
+    onRpcCall(result: RpcCallResult, elapsedSeconds: number): void;
+    onRpcNotify(): void;
+};
+export type ClientObserverLike = Partial<ClientObserver>;
+export declare const NoopObserver: ClientObserver;
+export declare function normalizeObserver(observer?: ClientObserverLike): ClientObserver;
+export declare function nowSeconds(): number;

package/dist/observability/observer.js

@@ -0,0 +1,28 @@
+export const NoopObserver = {
+    onConnect: () => { },
+    onAttach: () => { },
+    onHandshake: () => { },
+    onWsClose: () => { },
+    onWsError: () => { },
+    onRpcCall: () => { },
+    onRpcNotify: () => { }
+};
+export function normalizeObserver(observer) {
+    if (observer == null)
+        return NoopObserver;
+    return {
+        onConnect: observer.onConnect ?? NoopObserver.onConnect,
+        onAttach: observer.onAttach ?? NoopObserver.onAttach,
+        onHandshake: observer.onHandshake ?? NoopObserver.onHandshake,
+        onWsClose: observer.onWsClose ?? NoopObserver.onWsClose,
+        onWsError: observer.onWsError ?? NoopObserver.onWsError,
+        onRpcCall: observer.onRpcCall ?? NoopObserver.onRpcCall,
+        onRpcNotify: observer.onRpcNotify ?? NoopObserver.onRpcNotify
+    };
+}
+export function nowSeconds() {
+    if (typeof performance !== "undefined" && typeof performance.now === "function") {
+        return performance.now() / 1000;
+    }
+    return Date.now() / 1000;
+}

package/dist/rpc/callError.d.ts

@@ -0,0 +1,5 @@
+export declare class RpcCallError extends Error {
+    readonly code: number;
+    readonly typeId: number;
+    constructor(code: number, message?: string, typeId?: number);
+}

package/dist/rpc/callError.js

@@ -0,0 +1,11 @@
+// RpcCallError represents an RPC-layer error returned in the wire envelope.
+export class RpcCallError extends Error {
+    code;
+    typeId;
+    constructor(code, message, typeId) {
+        super(message ?? "rpc error");
+        this.name = "RpcCallError";
+        this.code = code >>> 0;
+        this.typeId = (typeId ?? 0) >>> 0;
+    }
+}

package/dist/rpc/caller.d.ts

@@ -0,0 +1,8 @@
+import type { RpcError } from "../gen/flowersec/rpc/v1.gen.js";
+export type RpcCaller = {
+    call(typeId: number, payload: unknown, signal?: AbortSignal): Promise<{
+        payload: unknown;
+        error?: RpcError;
+    }>;
+    onNotify(typeId: number, handler: (payload: unknown) => void): () => void;
+};

package/dist/rpc/caller.js

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

package/dist/rpc/client.d.ts

@@ -0,0 +1,22 @@
+import type { RpcError } from "../gen/flowersec/rpc/v1.gen.js";
+import { type ClientObserverLike } from "../observability/observer.js";
+export declare class RpcClient {
+    private readonly readExactly;
+    private readonly write;
+    private nextId;
+    private readonly pending;
+    private readonly notifyHandlers;
+    private closed;
+    private readonly observer;
+    constructor(readExactly: (n: number) => Promise<Uint8Array>, write: (b: Uint8Array) => Promise<void>, opts?: Readonly<{
+        observer?: ClientObserverLike;
+    }>);
+    call(typeId: number, payload: unknown, signal?: AbortSignal): Promise<{
+        payload: unknown;
+        error?: RpcError;
+    }>;
+    close(): void;
+    onNotify(typeId: number, handler: (payload: unknown) => void): () => void;
+    notify(typeId: number, payload: unknown): Promise<void>;
+    private readLoop;
+}

package/dist/rpc/client.js

@@ -0,0 +1,170 @@
+import { normalizeObserver, nowSeconds } from "../observability/observer.js";
+import { readJsonFrame, writeJsonFrame } from "./framing.js";
+import { assertRpcEnvelope } from "./validate.js";
+// Guard against precision loss when encoding request IDs as numbers.
+const MAX_SAFE_REQUEST_ID = BigInt(Number.MAX_SAFE_INTEGER);
+// RpcClient sends request/response envelopes and dispatches notifications.
+export class RpcClient {
+    readExactly;
+    write;
+    // Next request ID (bigint to avoid JS number precision loss).
+    nextId = 1n;
+    // Pending requests keyed by request ID.
+    pending = new Map();
+    // Notification handlers keyed by type ID.
+    notifyHandlers = new Map();
+    // Closed state to stop the read loop and reject calls.
+    closed = false;
+    // Observer for RPC events.
+    observer;
+    constructor(readExactly, write, opts = {}) {
+        this.readExactly = readExactly;
+        this.write = write;
+        this.observer = normalizeObserver(opts.observer);
+        void this.readLoop();
+    }
+    // call sends a request and awaits a response or abort.
+    async call(typeId, payload, signal) {
+        if (this.closed)
+            throw new Error("rpc client closed");
+        if (this.nextId > MAX_SAFE_REQUEST_ID)
+            throw new Error("request id overflow");
+        const start = nowSeconds();
+        const record = (result) => {
+            this.observer.onRpcCall(result, nowSeconds() - start);
+        };
+        const requestId = this.nextId;
+        this.nextId += 1n;
+        const env = {
+            type_id: typeId >>> 0,
+            request_id: Number(requestId),
+            response_to: 0,
+            payload
+        };
+        const p = new Promise((resolve, reject) => {
+            this.pending.set(requestId, { resolve, reject });
+        });
+        try {
+            await writeJsonFrame(this.write, env);
+        }
+        catch (e) {
+            this.pending.delete(requestId);
+            record("transport_error");
+            throw e;
+        }
+        if (signal?.aborted) {
+            this.pending.delete(requestId);
+            record("canceled");
+            throw signal.reason ?? new Error("aborted");
+        }
+        let resp;
+        try {
+            resp = await raceAbort(p, signal);
+        }
+        catch (e) {
+            this.pending.delete(requestId);
+            record(signal?.aborted ? "canceled" : "transport_error");
+            throw e;
+        }
+        const result = rpcResultFromError(resp.error);
+        record(result);
+        if (resp.error == null)
+            return { payload: resp.payload };
+        return { payload: resp.payload, error: resp.error };
+    }
+    // close rejects all pending calls and stops the read loop.
+    close() {
+        this.closed = true;
+        for (const [, p] of this.pending)
+            p.reject(new Error("rpc closed"));
+        this.pending.clear();
+        this.notifyHandlers.clear();
+    }
+    // onNotify registers a handler for incoming notifications.
+    onNotify(typeId, handler) {
+        const tid = typeId >>> 0;
+        const set = this.notifyHandlers.get(tid) ?? new Set();
+        set.add(handler);
+        this.notifyHandlers.set(tid, set);
+        return () => {
+            const s = this.notifyHandlers.get(tid);
+            s?.delete(handler);
+            if (s != null && s.size === 0)
+                this.notifyHandlers.delete(tid);
+        };
+    }
+    // notify sends a one-way notification to the peer.
+    async notify(typeId, payload) {
+        if (this.closed)
+            throw new Error("rpc client closed");
+        const env = {
+            type_id: typeId >>> 0,
+            request_id: 0,
+            response_to: 0,
+            payload
+        };
+        await writeJsonFrame(this.write, env);
+    }
+    async readLoop() {
+        try {
+            while (!this.closed) {
+                const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, 1 << 20));
+                if (v.response_to === 0) {
+                    // Notification: response_to=0 and request_id=0.
+                    if (v.request_id === 0) {
+                        this.observer.onRpcNotify();
+                        const set = this.notifyHandlers.get(v.type_id >>> 0);
+                        if (set != null) {
+                            for (const h of set) {
+                                try {
+                                    h(v.payload);
+                                }
+                                catch {
+                                    // User handlers should not be able to take down the transport read loop.
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                const key = BigInt(v.response_to);
+                const p = this.pending.get(key);
+                if (p != null) {
+                    this.pending.delete(key);
+                    p.resolve(v);
+                }
+            }
+        }
+        catch (e) {
+            this.closed = true;
+            for (const [, p] of this.pending)
+                p.reject(e);
+            this.pending.clear();
+        }
+    }
+}
+// raceAbort resolves p unless the signal aborts first.
+async function raceAbort(p, signal) {
+    if (signal == null)
+        return p;
+    if (signal.aborted)
+        throw signal.reason ?? new Error("aborted");
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason ?? new Error("aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        void p.then((v) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(v);
+        }, (e) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(e);
+        });
+    });
+}
+function rpcResultFromError(err) {
+    if (err == null)
+        return "ok";
+    if (err.code === 404)
+        return "handler_not_found";
+    return "rpc_error";
+}

package/dist/rpc/framing.d.ts

@@ -0,0 +1,4 @@
+export declare class RpcFramingError extends Error {
+}
+export declare function writeJsonFrame(write: (b: Uint8Array) => Promise<void>, v: unknown): Promise<void>;
+export declare function readJsonFrame(readExactly: (n: number) => Promise<Uint8Array>, maxBytes: number): Promise<unknown>;

package/dist/rpc/framing.js

@@ -0,0 +1,24 @@
+import { readU32be, u32be } from "../utils/bin.js";
+const te = new TextEncoder();
+const td = new TextDecoder();
+// RpcFramingError marks malformed or oversized frames.
+export class RpcFramingError extends Error {
+}
+// writeJsonFrame encodes a JSON payload with a 4-byte length prefix.
+export async function writeJsonFrame(write, v) {
+    const json = te.encode(JSON.stringify(v));
+    const hdr = u32be(json.length);
+    const out = new Uint8Array(4 + json.length);
+    out.set(hdr, 0);
+    out.set(json, 4);
+    await write(out);
+}
+// readJsonFrame reads and parses a length-prefixed JSON payload.
+export async function readJsonFrame(readExactly, maxBytes) {
+    const hdr = await readExactly(4);
+    const n = readU32be(hdr, 0);
+    if (maxBytes > 0 && n > maxBytes)
+        throw new RpcFramingError("frame too large");
+    const payload = await readExactly(n);
+    return JSON.parse(td.decode(payload));
+}

package/dist/rpc/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./framing.js";
+export * from "./caller.js";
+export * from "./client.js";
+export * from "./server.js";
+export * from "./callError.js";
+export * from "./typed.js";

package/dist/rpc/index.js

@@ -0,0 +1,6 @@
+export * from "./framing.js";
+export * from "./caller.js";
+export * from "./client.js";
+export * from "./server.js";
+export * from "./callError.js";
+export * from "./typed.js";

package/dist/rpc/server.d.ts

@@ -0,0 +1,15 @@
+import type { RpcError } from "../gen/flowersec/rpc/v1.gen.js";
+export type RpcHandler = (payload: unknown) => Promise<{
+    payload: unknown;
+    error?: RpcError;
+}>;
+export declare class RpcServer {
+    private readonly readExactly;
+    private readonly write;
+    private readonly handlers;
+    private closed;
+    constructor(readExactly: (n: number) => Promise<Uint8Array>, write: (b: Uint8Array) => Promise<void>);
+    register(typeId: number, h: RpcHandler): void;
+    serve(signal?: AbortSignal): Promise<void>;
+    close(): void;
+}

package/dist/rpc/server.js

@@ -0,0 +1,67 @@
+import { readJsonFrame, writeJsonFrame } from "./framing.js";
+import { assertRpcEnvelope } from "./validate.js";
+// RpcServer dispatches request envelopes to registered handlers.
+export class RpcServer {
+    readExactly;
+    write;
+    // Registered handlers keyed by type ID.
+    handlers = new Map();
+    // Closed flag to stop the serve loop.
+    closed = false;
+    constructor(readExactly, write) {
+        this.readExactly = readExactly;
+        this.write = write;
+    }
+    // register binds a handler to a type ID.
+    register(typeId, h) {
+        this.handlers.set(typeId >>> 0, h);
+    }
+    // serve handles request/response frames until closed or aborted.
+    async serve(signal) {
+        while (!this.closed) {
+            if (signal?.aborted)
+                throw signal.reason ?? new Error("aborted");
+            const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, 1 << 20));
+            if (v.response_to !== 0)
+                continue;
+            if (v.request_id === 0) {
+                const h = this.handlers.get(v.type_id >>> 0);
+                if (h != null) {
+                    try {
+                        await h(v.payload);
+                    }
+                    catch {
+                        // Keep the serve loop alive on notification handler errors.
+                    }
+                }
+                continue;
+            }
+            const h = this.handlers.get(v.type_id >>> 0);
+            let out;
+            if (h == null) {
+                out = { payload: null, error: { code: 404, message: "handler not found" } };
+            }
+            else {
+                try {
+                    out = await h(v.payload);
+                }
+                catch {
+                    // Keep the serve loop alive on request handler errors.
+                    out = { payload: null, error: { code: 500, message: "internal error" } };
+                }
+            }
+            const resp = {
+                type_id: v.type_id,
+                request_id: 0,
+                response_to: v.request_id,
+                payload: out.payload,
+                ...(out.error != null ? { error: out.error } : {})
+            };
+            await writeJsonFrame(this.write, resp);
+        }
+    }
+    // close stops the serve loop.
+    close() {
+        this.closed = true;
+    }
+}

package/dist/rpc/typed.d.ts

@@ -0,0 +1,5 @@
+import type { RpcCaller } from "./caller.js";
+export declare function callTyped<TResp>(rpc: RpcCaller, typeId: number, req: unknown, opts?: Readonly<{
+    signal?: AbortSignal;
+    assert?: (v: unknown) => TResp;
+}>): Promise<TResp>;

package/dist/rpc/typed.js

@@ -0,0 +1,9 @@
+import { RpcCallError } from "./callError.js";
+export async function callTyped(rpc, typeId, req, opts = {}) {
+    const resp = await rpc.call(typeId, req, opts.signal);
+    if (resp.error != null)
+        throw new RpcCallError(resp.error.code, resp.error.message, typeId);
+    if (opts.assert != null)
+        return opts.assert(resp.payload);
+    return resp.payload;
+}

package/dist/rpc/validate.d.ts

@@ -0,0 +1,2 @@
+import type { RpcEnvelope } from "../gen/flowersec/rpc/v1.gen.js";
+export declare function assertRpcEnvelope(v: unknown): RpcEnvelope;

package/dist/rpc/validate.js

@@ -0,0 +1,27 @@
+import { isSafeU32Number, isSafeU64Number } from "../utils/number.js";
+// assertRpcEnvelope validates numeric fields that are u32/u64 in the IDL.
+//
+// The wire format is JSON, so JS numbers are used. For u64 we enforce the safe integer range
+// to avoid silent precision loss on request/response correlation.
+export function assertRpcEnvelope(v) {
+    if (typeof v !== "object" || v == null)
+        throw new Error("bad rpc envelope");
+    const o = v;
+    if (!isSafeU32Number(o.type_id))
+        throw new Error("bad rpc envelope: type_id");
+    if (!isSafeU64Number(o.request_id))
+        throw new Error("bad rpc envelope: request_id");
+    if (!isSafeU64Number(o.response_to))
+        throw new Error("bad rpc envelope: response_to");
+    // payload: unknown (JSON)
+    if (o.error != null) {
+        if (typeof o.error !== "object" || o.error == null)
+            throw new Error("bad rpc envelope: error");
+        if (!isSafeU32Number(o.error.code))
+            throw new Error("bad rpc envelope: error.code");
+        const msg = o.error.message;
+        if (msg !== undefined && typeof msg !== "string")
+            throw new Error("bad rpc envelope: error.message");
+    }
+    return o;
+}

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

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

package/dist/rpc-proxy/index.js

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

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

@@ -0,0 +1,13 @@
+import type { RpcClient } from "../rpc/client.js";
+export declare class RpcProxy {
+    private client;
+    private readonly notifyHandlers;
+    attach(client: RpcClient): void;
+    detach(): void;
+    onNotify(typeId: number, handler: (payload: unknown) => void): () => void;
+    call(typeId: number, payload: unknown, signal?: AbortSignal): Promise<{
+        payload: unknown;
+        error?: import("../gen/flowersec/rpc/v1.gen.js").RpcError;
+    }>;
+    notify(typeId: number, payload: unknown): Promise<void>;
+}

package/dist/rpc-proxy/rpcProxy.js

@@ -0,0 +1,59 @@
+// RpcProxy allows handlers to survive client reattachment.
+export class RpcProxy {
+    // Active client connection (null when detached).
+    client = null;
+    // Persisted notification handlers across reattachments.
+    notifyHandlers = new Map();
+    // attach wires existing notification handlers to a new client.
+    attach(client) {
+        this.detach();
+        this.client = client;
+        for (const [typeId, handlers] of this.notifyHandlers) {
+            for (const [h, state] of handlers) {
+                state.unsub = client.onNotify(typeId, h);
+            }
+        }
+    }
+    // detach unwires handlers from the current client.
+    detach() {
+        for (const [, handlers] of this.notifyHandlers) {
+            for (const [, state] of handlers) {
+                state.unsub?.();
+                delete state.unsub;
+            }
+        }
+        this.client = null;
+    }
+    // onNotify registers handlers that will be rebound on reattach.
+    onNotify(typeId, handler) {
+        const tid = typeId >>> 0;
+        const handlers = this.notifyHandlers.get(tid) ?? new Map();
+        if (!this.notifyHandlers.has(tid))
+            this.notifyHandlers.set(tid, handlers);
+        if (!handlers.has(handler)) {
+            const state = {};
+            if (this.client != null)
+                state.unsub = this.client.onNotify(tid, handler);
+            handlers.set(handler, state);
+        }
+        return () => {
+            const state = handlers.get(handler);
+            state?.unsub?.();
+            handlers.delete(handler);
+            if (handlers.size === 0)
+                this.notifyHandlers.delete(tid);
+        };
+    }
+    // call forwards the RPC call to the attached client.
+    async call(typeId, payload, signal) {
+        if (this.client == null)
+            throw new Error("rpc proxy is not attached");
+        return await this.client.call(typeId, payload, signal);
+    }
+    // notify forwards a one-way notification to the attached client.
+    async notify(typeId, payload) {
+        if (this.client == null)
+            throw new Error("rpc proxy is not attached");
+        await this.client.notify(typeId, payload);
+    }
+}

package/dist/streamhello/index.d.ts

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

package/dist/streamhello/index.js

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

package/dist/streamhello/streamHello.d.ts

@@ -0,0 +1,3 @@
+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>;