@floegence/flowersec-core 0.1.3 → 0.2.1

package/dist/client-connect/connectCore.js

@@ -5,15 +5,13 @@ import { RpcClient } from "../rpc/client.js";
 import { writeStreamHello } from "../streamhello/streamHello.js";
 import { normalizeObserver, nowSeconds } from "../observability/observer.js";
 import { base64urlDecode } from "../utils/base64url.js";
-import { FlowersecError, throwIfAborted } from "../utils/errors.js";
+import { AbortError, FlowersecError, throwIfAborted } from "../utils/errors.js";
 import { WebSocketBinaryTransport, WsCloseError } from "../ws-client/binaryTransport.js";
 import { OriginMismatchError, WsFactoryRequiredError, classifyConnectError, classifyHandshakeError, createWebSocket, waitOpen, withAbortAndTimeout, } from "./common.js";
 import { isTunnelAttachCloseReason } from "./tunnelAttachCloseReason.js";
 export async function connectCore(args) {
     const observer = normalizeObserver(args.opts.observer);
     const signal = args.opts.signal;
-    const connectTimeoutMs = args.opts.connectTimeoutMs ?? 10_000;
-    const handshakeTimeoutMs = args.opts.handshakeTimeoutMs ?? 10_000;
     const connectStart = nowSeconds();
     const origin = args.opts.origin;
     if (origin == null || origin === "") {
@@ -23,6 +21,41 @@ export async function connectCore(args) {
         const code = args.path === "tunnel" ? "missing_tunnel_url" : "missing_ws_url";
         throw new FlowersecError({ path: args.path, stage: "validate", code, message: "missing websocket url" });
     }
+    const invalidOption = (message) => {
+        throw new FlowersecError({ path: args.path, stage: "validate", code: "invalid_option", message });
+    };
+    const connectTimeoutMs = args.opts.connectTimeoutMs ?? 10_000;
+    if (!Number.isFinite(connectTimeoutMs) || connectTimeoutMs < 0) {
+        invalidOption("connectTimeoutMs must be a non-negative number");
+    }
+    const handshakeTimeoutMs = args.opts.handshakeTimeoutMs ?? 10_000;
+    if (!Number.isFinite(handshakeTimeoutMs) || handshakeTimeoutMs < 0) {
+        invalidOption("handshakeTimeoutMs must be a non-negative number");
+    }
+    const keepaliveIntervalMs = args.opts.keepaliveIntervalMs ?? 0;
+    if (!Number.isFinite(keepaliveIntervalMs) || keepaliveIntervalMs < 0) {
+        invalidOption("keepaliveIntervalMs must be a non-negative number");
+    }
+    const clientFeatures = args.opts.clientFeatures ?? 0;
+    if (!Number.isSafeInteger(clientFeatures) || clientFeatures < 0 || clientFeatures > 0xffffffff) {
+        invalidOption("clientFeatures must be a uint32");
+    }
+    const maxHandshakePayload = args.opts.maxHandshakePayload ?? 0;
+    if (!Number.isSafeInteger(maxHandshakePayload) || maxHandshakePayload < 0) {
+        invalidOption("maxHandshakePayload must be a non-negative integer");
+    }
+    const maxRecordBytes = args.opts.maxRecordBytes ?? 0;
+    if (!Number.isSafeInteger(maxRecordBytes) || maxRecordBytes < 0) {
+        invalidOption("maxRecordBytes must be a non-negative integer");
+    }
+    const maxBufferedBytes = args.opts.maxBufferedBytes ?? 0;
+    if (!Number.isSafeInteger(maxBufferedBytes) || maxBufferedBytes < 0) {
+        invalidOption("maxBufferedBytes must be a non-negative integer");
+    }
+    const maxWsQueuedBytes = args.opts.maxWsQueuedBytes ?? 0;
+    if (!Number.isSafeInteger(maxWsQueuedBytes) || maxWsQueuedBytes < 0) {
+        invalidOption("maxWsQueuedBytes must be a non-negative integer");
+    }
     let ws;
     try {
         ws = createWebSocket(args.wsUrl, origin, args.opts.wsFactory);
@@ -39,7 +72,7 @@ export async function connectCore(args) {
     // Install close/error/message listeners before waiting for "open" to avoid a gap where a peer close
     // (for example a tunnel attach rejection with a reason token) can be missed and misclassified as a handshake timeout.
     const transport = new WebSocketBinaryTransport(ws, {
-        ...(args.opts.maxWsQueuedBytes != null && args.opts.maxWsQueuedBytes > 0 ? { maxQueuedBytes: args.opts.maxWsQueuedBytes } : {}),
+        ...(maxWsQueuedBytes > 0 ? { maxQueuedBytes: maxWsQueuedBytes } : {}),
         observer,
     });
     try {
@@ -116,14 +149,11 @@ export async function connectCore(args) {
         const handshakeStart = nowSeconds();
         let secure;
         try {
-            const maxHandshakePayload = args.opts.maxHandshakePayload ?? 0;
-            const maxRecordBytes = args.opts.maxRecordBytes ?? 0;
-            const maxBufferedBytes = args.opts.maxBufferedBytes ?? 0;
             secure = await withAbortAndTimeout(clientHandshake(transport, {
                 channelId: args.channelId,
                 suite,
                 psk,
-                clientFeatures: args.opts.clientFeatures ?? 0,
+                clientFeatures,
                 maxHandshakePayload: maxHandshakePayload > 0 ? maxHandshakePayload : 8 * 1024,
                 maxRecordBytes: maxRecordBytes > 0 ? maxRecordBytes : (1 << 20),
                 ...(maxBufferedBytes > 0 ? { maxBufferedBytes } : {}),
@@ -177,14 +207,7 @@ export async function connectCore(args) {
             secure.close();
             throw new FlowersecError({ path: args.path, stage: "yamux", code: "open_stream_failed", message: "open rpc stream failed", cause: e });
         }
-        const reader = new ByteReader(async () => {
-            try {
-                return await rpcStream.read();
-            }
-            catch {
-                return null;
-            }
-        });
+        const reader = new ByteReader(() => rpcStream.read());
         const readExactly = (n) => reader.readExactly(n);
         const write = (b) => rpcStream.write(b);
         try {
@@ -216,7 +239,6 @@ export async function connectCore(args) {
                 throw new FlowersecError({ path: args.path, stage: "secure", code: "ping_failed", message: "ping failed", cause: e });
             }
         };
-        const keepaliveIntervalMs = Math.max(0, args.opts.keepaliveIntervalMs ?? 0);
         let keepaliveTimer;
         let keepaliveInFlight = false;
         const stopKeepalive = () => {
@@ -225,6 +247,27 @@ export async function connectCore(args) {
             clearInterval(keepaliveTimer);
             keepaliveTimer = undefined;
         };
+        const closeAll = () => {
+            stopKeepalive();
+            try {
+                rpc.close();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                mux.close();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                secure.close();
+            }
+            catch {
+                // ignore
+            }
+        };
         if (keepaliveIntervalMs > 0) {
             keepaliveTimer = setInterval(() => {
                 if (keepaliveInFlight)
@@ -232,12 +275,7 @@ export async function connectCore(args) {
                 keepaliveInFlight = true;
                 ping()
                     .catch(() => {
-                    try {
-                        ws.close();
-                    }
-                    catch {
-                        // ignore
-                    }
+                    closeAll();
                 })
                     .finally(() => {
                     keepaliveInFlight = false;
@@ -252,9 +290,28 @@ export async function connectCore(args) {
             mux,
             rpc,
             ping,
-            openStream: async (kind) => {
+            openStream: async (kind, opts = {}) => {
                 if (kind == null || kind === "")
                     throw new FlowersecError({ path: args.path, stage: "validate", code: "missing_stream_kind", message: "missing stream kind" });
+                if (opts.signal?.aborted) {
+                    throw new FlowersecError({
+                        path: args.path,
+                        stage: "yamux",
+                        code: "canceled",
+                        message: "open stream aborted",
+                        cause: opts.signal.reason,
+                    });
+                }
+                const abortReason = (signal) => {
+                    const r = signal.reason;
+                    if (r instanceof Error)
+                        return r;
+                    if (typeof r === "string" && r !== "")
+                        return new AbortError(r);
+                    return new AbortError("aborted");
+                };
+                const signal = opts.signal;
+                let abortListener;
                 let s;
                 try {
                     s = await mux.openStream();
@@ -262,10 +319,59 @@ export async function connectCore(args) {
                 catch (e) {
                     throw new FlowersecError({ path: args.path, stage: "yamux", code: "open_stream_failed", message: "open stream failed", cause: e });
                 }
+                if (signal != null) {
+                    abortListener = () => {
+                        try {
+                            s.reset(abortReason(signal));
+                        }
+                        catch {
+                            // ignore
+                        }
+                    };
+                    signal.addEventListener("abort", abortListener, { once: true });
+                    if (signal.aborted)
+                        abortListener();
+                }
+                if (signal?.aborted) {
+                    if (abortListener != null)
+                        signal.removeEventListener("abort", abortListener);
+                    try {
+                        await s.close();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    throw new FlowersecError({
+                        path: args.path,
+                        stage: "yamux",
+                        code: "canceled",
+                        message: "open stream aborted",
+                        cause: signal.reason,
+                    });
+                }
                 try {
                     await writeStreamHello((b) => s.write(b), kind);
                 }
                 catch (err) {
+                    if (signal?.aborted) {
+                        if (abortListener != null)
+                            signal.removeEventListener("abort", abortListener);
+                        try {
+                            await s.close();
+                        }
+                        catch {
+                            // ignore
+                        }
+                        throw new FlowersecError({
+                            path: args.path,
+                            stage: "yamux",
+                            code: "canceled",
+                            message: "open stream aborted",
+                            cause: signal.reason,
+                        });
+                    }
+                    if (signal != null && abortListener != null)
+                        signal.removeEventListener("abort", abortListener);
                     try {
                         await s.close();
                     }
@@ -282,12 +388,7 @@ export async function connectCore(args) {
                 }
                 return s;
             },
-            close: () => {
-                stopKeepalive();
-                rpc.close();
-                mux.close();
-                secure.close();
-            },
+            close: closeAll,
         };
     }
     catch (e) {

package/dist/client.d.ts

@@ -7,7 +7,9 @@ export type Client = Readonly<{
     path: ClientPath;
     endpointInstanceId?: string;
     rpc: RpcClient;
-    openStream: (kind: string) => Promise<YamuxStream>;
+    openStream: (kind: string, opts?: Readonly<{
+        signal?: AbortSignal;
+    }>) => Promise<YamuxStream>;
     ping: () => Promise<void>;
     close: () => void;
 }>;

package/dist/framing/index.d.ts

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

package/dist/framing/index.js

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

package/dist/framing/jsonframe.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_MAX_JSON_FRAME_BYTES: number;
+export declare class JsonFramingError extends Error {
+}
+type WriteFn = (b: Uint8Array) => Promise<void>;
+type WriteLike = Readonly<{
+    write: (b: Uint8Array) => Promise<void>;
+}>;
+type ReadExactlyFn = (n: number) => Promise<Uint8Array>;
+type ReadExactlyLike = Readonly<{
+    readExactly: (n: number) => Promise<Uint8Array>;
+}>;
+export declare function writeJsonFrame(write: WriteFn | WriteLike, v: unknown): Promise<void>;
+export declare function readJsonFrame(readExactly: ReadExactlyFn | ReadExactlyLike, maxBytes: number): Promise<unknown>;
+export {};

package/dist/{rpc/framing.js → framing/jsonframe.js}

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

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./utils/base64url.js";
 export * from "./utils/bin.js";
 export * from "./utils/errors.js";
+export * from "./framing/index.js";
+export * from "./streamio/index.js";
 export * from "./e2ee/constants.js";
 export * from "./e2ee/framing.js";
 export * from "./e2ee/transcript.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export * from "./utils/base64url.js";
 export * from "./utils/bin.js";
 export * from "./utils/errors.js";
+export * from "./framing/index.js";
+export * from "./streamio/index.js";
 export * from "./e2ee/constants.js";
 export * from "./e2ee/framing.js";
 export * from "./e2ee/transcript.js";

package/dist/rpc/client.js

@@ -1,5 +1,5 @@
 import { normalizeObserver, nowSeconds } from "../observability/observer.js";
-import { readJsonFrame, writeJsonFrame } from "./framing.js";
+import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.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);
@@ -108,7 +108,7 @@ export class RpcClient {
     async readLoop() {
         try {
             while (!this.closed) {
-                const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, 1 << 20));
+                const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES));
                 if (v.response_to === 0) {
                     // Notification: response_to=0 and request_id=0.
                     if (v.request_id === 0) {

package/dist/rpc/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./framing.js";
 export * from "./caller.js";
 export * from "./client.js";
 export * from "./server.js";

package/dist/rpc/index.js

@@ -1,4 +1,3 @@
-export * from "./framing.js";
 export * from "./caller.js";
 export * from "./client.js";
 export * from "./server.js";

package/dist/rpc/server.js

@@ -1,4 +1,4 @@
-import { readJsonFrame, writeJsonFrame } from "./framing.js";
+import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
 import { assertRpcEnvelope } from "./validate.js";
 // RpcServer dispatches request envelopes to registered handlers.
 export class RpcServer {
@@ -21,7 +21,7 @@ export class RpcServer {
         while (!this.closed) {
             if (signal?.aborted)
                 throw signal.reason ?? new Error("aborted");
-            const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, 1 << 20));
+            const v = assertRpcEnvelope(await readJsonFrame(this.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES));
             if (v.response_to !== 0)
                 continue;
             if (v.request_id === 0) {

package/dist/streamhello/streamHello.js

@@ -1,4 +1,4 @@
-import { readJsonFrame, writeJsonFrame } from "../rpc/framing.js";
+import { readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
 // writeStreamHello sends the initial stream greeting.
 export async function writeStreamHello(write, kind) {
     const h = { kind, v: 1 };

package/dist/streamio/index.d.ts

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

package/dist/streamio/index.js

@@ -0,0 +1,58 @@
+import { AbortError, throwIfAborted } from "../utils/errors.js";
+import { ByteReader } from "../yamux/byteReader.js";
+function abortReasonToError(signal) {
+    const r = signal.reason;
+    if (r instanceof Error)
+        return r;
+    if (typeof r === "string" && r !== "")
+        return new AbortError(r);
+    return new AbortError("aborted");
+}
+function bindAbortToStream(stream, signal) {
+    const onAbort = () => {
+        try {
+            stream.reset(abortReasonToError(signal));
+        }
+        catch {
+            // Best-effort cancel.
+        }
+    };
+    if (signal.aborted) {
+        onAbort();
+        return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+}
+// readMaybe reads the next chunk or null on EOF.
+export async function readMaybe(stream) {
+    return await stream.read();
+}
+// createByteReader adapts a YamuxStream to a ByteReader (EOF is handled by YamuxStream.read()).
+export function createByteReader(stream, opts = {}) {
+    if (opts.signal != null)
+        bindAbortToStream(stream, opts.signal);
+    return new ByteReader(() => stream.read());
+}
+// readExactly reads n bytes (or throws on EOF/error). If signal aborts, the caller is expected to reset/close the stream.
+export async function readExactly(reader, n, opts = {}) {
+    throwIfAborted(opts.signal, "read aborted");
+    return await reader.readExactly(n);
+}
+// readNBytes reads exactly n bytes and returns them as a single contiguous buffer.
+export async function readNBytes(reader, n, opts = {}) {
+    const total = Math.max(0, Math.floor(n));
+    const out = new Uint8Array(total);
+    if (total === 0)
+        return out;
+    const chunkSize = Math.max(1, Math.floor(opts.chunkSize ?? 64 * 1024));
+    let off = 0;
+    while (off < total) {
+        throwIfAborted(opts.signal, "read aborted");
+        const take = Math.min(chunkSize, total - off);
+        const chunk = await reader.readExactly(take);
+        out.set(chunk, off);
+        off += chunk.length;
+        opts.onProgress?.(off);
+    }
+    return out;
+}

package/dist/tunnel-client/connect.js

@@ -105,7 +105,7 @@ export async function connectTunnel(grant, opts) {
         endpoint_instance_id: endpointInstanceId
     };
     const attachJson = JSON.stringify(attach);
-    const keepaliveIntervalMs = opts.keepaliveIntervalMs !== undefined ? Math.max(0, opts.keepaliveIntervalMs) : defaultKeepaliveIntervalMs(idleTimeoutSeconds);
+    const keepaliveIntervalMs = opts.keepaliveIntervalMs ?? defaultKeepaliveIntervalMs(idleTimeoutSeconds);
     return await connectCore({
         path: "tunnel",
         wsUrl: checkedGrant.tunnel_url,
@@ -119,7 +119,13 @@ export async function connectTunnel(grant, opts) {
 function defaultKeepaliveIntervalMs(idleTimeoutSeconds) {
     if (!Number.isFinite(idleTimeoutSeconds) || idleTimeoutSeconds <= 0)
         return 0;
-    const idleMs = idleTimeoutSeconds * 1000;
-    const half = Math.floor(idleMs / 2);
-    return Math.max(500, half);
+    const idleMs = Math.floor(idleTimeoutSeconds * 1000);
+    if (idleMs <= 0)
+        return 0;
+    let interval = Math.floor(idleMs / 2);
+    if (interval < 500)
+        interval = 500;
+    if (interval >= idleMs)
+        interval = Math.floor(idleMs / 2);
+    return interval;
 }

package/dist/yamux/byteReader.js

@@ -1,3 +1,4 @@
+import { StreamEOFError } from "./errors.js";
 // ByteReader buffers incoming chunks and supports exact reads.
 export class ByteReader {
     readChunk;
@@ -15,7 +16,7 @@ export class ByteReader {
         while (this.buffered < n) {
             const chunk = await this.readChunk();
             if (chunk == null)
-                throw new Error("eof");
+                throw new StreamEOFError();
             if (chunk.length === 0)
                 continue;
             this.chunks.push(chunk);

package/dist/yamux/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class StreamEOFError extends Error {
+    constructor(message?: string);
+}
+export declare function isStreamEOFError(e: unknown): e is StreamEOFError;

package/dist/yamux/errors.js

@@ -0,0 +1,10 @@
+// StreamEOFError marks end-of-stream for yamux reads.
+export class StreamEOFError extends Error {
+    constructor(message = "eof") {
+        super(message);
+        this.name = "StreamEOFError";
+    }
+}
+export function isStreamEOFError(e) {
+    return e instanceof StreamEOFError;
+}

package/dist/yamux/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./constants.js";
 export * from "./byteReader.js";
+export * from "./errors.js";
 export * from "./header.js";
 export * from "./session.js";
 export * from "./stream.js";

package/dist/yamux/index.js

@@ -1,5 +1,6 @@
 export * from "./constants.js";
 export * from "./byteReader.js";
+export * from "./errors.js";
 export * from "./header.js";
 export * from "./session.js";
 export * from "./stream.js";

package/dist/yamux/stream.d.ts

@@ -15,7 +15,7 @@ export declare class YamuxStream {
     open(): Promise<void>;
     onData(data: Uint8Array, flags: number): void;
     onWindowUpdate(delta: number, flags: number): void;
-    read(): Promise<Uint8Array>;
+    read(): Promise<Uint8Array | null>;
     write(data: Uint8Array): Promise<void>;
     close(): Promise<void>;
     reset(err: Error): void;

package/dist/yamux/stream.js

@@ -54,7 +54,7 @@ export class YamuxStream {
         this.sendWindow += delta >>> 0;
         this.session.notifySendWindow(this.id);
     }
-    // read resolves with the next data chunk or throws on EOF/reset.
+    // read resolves with the next data chunk, null on EOF, or throws on reset/errors.
     async read() {
         while (true) {
             if (this.error != null)
@@ -66,7 +66,7 @@ export class YamuxStream {
                 return b;
             }
             if (this.state === "closed" || this.state === "remoteClose")
-                throw new Error("eof");
+                return null;
             await new Promise((resolve) => this.readWaiters.push(resolve));
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {
@@ -36,6 +36,14 @@
       "types": "./dist/browser/index.d.ts",
       "default": "./dist/browser/index.js"
     },
+    "./framing": {
+      "types": "./dist/framing/index.d.ts",
+      "default": "./dist/framing/index.js"
+    },
+    "./streamio": {
+      "types": "./dist/streamio/index.d.ts",
+      "default": "./dist/streamio/index.js"
+    },
     "./rpc": {
       "types": "./dist/rpc/index.d.ts",
       "default": "./dist/rpc/index.js"

package/dist/rpc/framing.d.ts

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