@floegence/flowersec-core 2.5.3 → 3.0.0

package/dist/proxy/windowBridge.js

@@ -39,12 +39,17 @@ export class MessagePortByteStream {
         if (this.terminalError !== undefined)
             throw this.terminalError;
         return await new Promise((resolve, reject) => {
-            const waiter = { resolve, reject };
+            const cleanup = () => options.signal?.removeEventListener("abort", onAbort);
+            const waiter = {
+                resolve: (value) => { cleanup(); resolve(value); },
+                reject: (error) => { cleanup(); reject(error); },
+            };
             const onAbort = () => {
                 const index = this.readWaiters.indexOf(waiter);
-                if (index >= 0)
-                    this.readWaiters.splice(index, 1);
-                reject(new SessionError("canceled"));
+                if (index < 0)
+                    return;
+                this.readWaiters.splice(index, 1);
+                waiter.reject(new SessionError("canceled"));
             };
             options.signal?.addEventListener("abort", onAbort, { once: true });
             this.readWaiters.push(waiter);
@@ -66,17 +71,19 @@ export class MessagePortByteStream {
         const copy = data.slice();
         this.buffered += copy.length;
         await new Promise((resolve, reject) => {
+            const onAbort = () => this.settleWrite(id, new SessionError("canceled"));
             this.writeWaiters.set(id, {
-                resolve: () => { this.buffered -= copy.length; resolve(); },
-                reject: (error) => { this.buffered -= copy.length; reject(error); },
+                bytes: copy.length,
+                ...(options.signal === undefined ? {} : { signal: options.signal, onAbort }),
+                resolve,
+                reject,
             });
+            options.signal?.addEventListener("abort", onAbort, { once: true });
             try {
                 this.port.postMessage({ type: "chunk", id, data: copy.buffer }, [copy.buffer]);
             }
             catch {
-                this.writeWaiters.delete(id);
-                this.buffered -= copy.length;
-                reject(new SessionError("operation_failed"));
+                this.settleWrite(id, new SessionError("operation_failed"));
             }
         });
         return data.length;
@@ -130,11 +137,7 @@ export class MessagePortByteStream {
             return;
         }
         if (message.type === "ack" && Number.isSafeInteger(message.id)) {
-            const waiter = this.writeWaiters.get(message.id);
-            if (waiter !== undefined) {
-                this.writeWaiters.delete(message.id);
-                waiter.resolve();
-            }
+            this.settleWrite(message.id);
             return;
         }
         if (message.type === "end") {
@@ -159,9 +162,8 @@ export class MessagePortByteStream {
         this.readBuffered = 0;
         for (const waiter of this.readWaiters.splice(0))
             waiter.resolve(null);
-        for (const waiter of this.writeWaiters.values())
-            waiter.reject(new SessionError("closed"));
-        this.writeWaiters.clear();
+        for (const id of [...this.writeWaiters.keys()])
+            this.settleWrite(id, new SessionError("closed"));
         this.port.close();
     }
     fail(error) {
@@ -173,11 +175,22 @@ export class MessagePortByteStream {
         this.readBuffered = 0;
         for (const waiter of this.readWaiters.splice(0))
             waiter.reject(error);
-        for (const waiter of this.writeWaiters.values())
-            waiter.reject(error);
-        this.writeWaiters.clear();
+        for (const id of [...this.writeWaiters.keys()])
+            this.settleWrite(id, error);
         this.port.close();
     }
+    settleWrite(id, error) {
+        const waiter = this.writeWaiters.get(id);
+        if (waiter === undefined)
+            return;
+        this.writeWaiters.delete(id);
+        waiter.signal?.removeEventListener("abort", waiter.onAbort);
+        this.buffered = Math.max(0, this.buffered - waiter.bytes);
+        if (error === undefined)
+            waiter.resolve();
+        else
+            waiter.reject(error);
+    }
 }
 function bridgeLimits(maxWsFrameBytes, maxWsBufferedAmountBytes) {
     const wsFrame = maxWsFrameBytes ?? SDK_DEFAULTS.proxy.maxWsFrameBytes;
@@ -279,33 +292,65 @@ export function registerProxyAppWindow(options) {
         dispose: () => { disposed = true; },
     });
 }
-async function bridgeStreams(runtimeStream, port) {
+async function bridgeStreams(runtimeStream, port, signal) {
     const bridge = new MessagePortByteStream(port);
+    const controller = new AbortController();
+    let resetTask;
+    const resetBoth = () => {
+        resetTask ??= Promise.allSettled([
+            Promise.resolve().then(async () => await runtimeStream.reset()),
+            Promise.resolve().then(async () => await bridge.reset()),
+        ]);
+        return resetTask;
+    };
+    const abort = () => {
+        controller.abort(signal?.reason ?? new SessionError("canceled"));
+        void resetBoth();
+    };
+    if (signal?.aborted === true)
+        abort();
+    else
+        signal?.addEventListener("abort", abort, { once: true });
     const left = (async () => {
         while (true) {
-            const chunk = await runtimeStream.read();
+            const chunk = await runtimeStream.read({ signal: controller.signal });
             if (chunk === null) {
                 await bridge.closeWrite();
                 return;
             }
-            await bridge.write(chunk);
+            await bridge.write(chunk, { signal: controller.signal });
         }
-    })();
+    })().catch((error) => { controller.abort(error); void resetBoth(); throw error; });
     const right = (async () => {
         while (true) {
-            const chunk = await bridge.read();
+            const chunk = await bridge.read({ signal: controller.signal });
             if (chunk === null) {
                 await runtimeStream.closeWrite();
                 return;
             }
             let offset = 0;
             while (offset < chunk.length)
-                offset += await runtimeStream.write(chunk.subarray(offset));
+                offset += await runtimeStream.write(chunk.subarray(offset), { signal: controller.signal });
         }
-    })();
-    await Promise.all([left, right]);
-    await runtimeStream.close();
-    await bridge.close();
+    })().catch((error) => { controller.abort(error); void resetBoth(); throw error; });
+    try {
+        const settled = await Promise.allSettled([left, right]);
+        const failure = settled.find((result) => result.status === "rejected");
+        if (failure !== undefined) {
+            await resetBoth();
+            throw failure.reason;
+        }
+        try {
+            await Promise.all([runtimeStream.close(), bridge.close()]);
+        }
+        catch (error) {
+            await resetBoth();
+            throw error;
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
+    }
 }
 export function registerProxyControllerWindow(options) {
     const target = options.targetWindow ?? globalThis.window;
@@ -315,6 +360,7 @@ export function registerProxyControllerWindow(options) {
     }
     const nonce = capability(options.capabilityNonce);
     let disposed = false;
+    const active = new Set();
     const onMessage = (event) => {
         if (disposed || !allowed.has(event.origin) || (options.expectedSource !== undefined && event.source !== options.expectedSource))
             return;
@@ -331,6 +377,7 @@ export function registerProxyControllerWindow(options) {
             void (async () => {
                 let canceled = false;
                 const openController = new AbortController();
+                active.add(openController);
                 port.onmessage = (message) => {
                     if (message.data?.type === "reset" ||
                         message.data?.type === "close") {
@@ -349,17 +396,30 @@ export function registerProxyControllerWindow(options) {
                         return;
                     }
                     port.postMessage({ type: WEBSOCKET_ACK_MESSAGE, ok: true, protocol: opened.protocol });
-                    await bridgeStreams(opened.stream, port);
+                    await bridgeStreams(opened.stream, port, openController.signal);
                 }
                 catch {
-                    port.postMessage({ type: WEBSOCKET_ACK_MESSAGE, ok: false });
+                    try {
+                        port.postMessage({ type: WEBSOCKET_ACK_MESSAGE, ok: false });
+                    }
+                    catch { /* Port is already closed. */ }
                     port.close();
                 }
+                finally {
+                    active.delete(openController);
+                }
             })();
         }
     };
     target.addEventListener("message", onMessage);
-    return Object.freeze({ dispose: () => { disposed = true; target.removeEventListener("message", onMessage); } });
+    return Object.freeze({
+        dispose: () => {
+            disposed = true;
+            target.removeEventListener("message", onMessage);
+            for (const controller of active)
+                controller.abort(new SessionError("closed"));
+        },
+    });
 }
 export async function registerProxyAppWindowWithServiceWorkerControl(options) {
     await registerServiceWorkerAndEnsureControl({

package/dist/proxy/wsPatch.d.ts

@@ -4,6 +4,7 @@ export type WebSocketPatchOptions = Readonly<{
     shouldProxy?: (url: URL) => boolean;
     maxWsFrameBytes?: number;
     maxWsBufferedAmountBytes?: number;
+    closeHandshakeTimeoutMs?: number;
 }>;
 export declare function installWebSocketPatch(options: WebSocketPatchOptions): Readonly<{
     uninstall(): void;

package/dist/proxy/wsPatch.js

@@ -64,6 +64,7 @@ export function installWebSocketPatch(options) {
     const runtimeLimits = options.runtime.limits;
     const maxFrameBytes = limit("maxWsFrameBytes", options.maxWsFrameBytes, runtimeLimits.maxWsFrameBytes ?? 1024 * 1024);
     const maxBufferedBytes = limit("maxWsBufferedAmountBytes", options.maxWsBufferedAmountBytes, runtimeLimits.maxWsBufferedAmountBytes ?? 4 * 1024 * 1024);
+    const closeHandshakeTimeoutMs = limit("closeHandshakeTimeoutMs", options.closeHandshakeTimeoutMs, 5_000);
     const shouldProxy = options.shouldProxy ?? ((url) => {
         const location = globalThis.location;
         if (location?.hostname === undefined || location.hostname === "")
@@ -95,6 +96,7 @@ export function installWebSocketPatch(options) {
         abort = new AbortController();
         stream;
         writes = Promise.resolve();
+        closeTimer;
         constructor(input, protocols) {
             const url = new URL(String(input), globalThis.location?.href);
             if (!shouldProxy(url))
@@ -152,12 +154,17 @@ export function installWebSocketPatch(options) {
             const reasonBytes = encoder.encode(reason);
             if (reasonBytes.length > 123)
                 throw new DOMException("WebSocket close reason is too long", "SyntaxError");
+            if (this.readyState === ProxyWebSocket.CONNECTING || this.stream === undefined) {
+                this.fail();
+                return;
+            }
             this.readyState = ProxyWebSocket.CLOSING;
             const payload = code === undefined ? new Uint8Array() : new Uint8Array([...u16be(code), ...reasonBytes]);
-            this.writes = this.writes.then(async () => {
-                if (this.stream !== undefined)
-                    await writeFrame(this.stream, 8, payload, maxFrameBytes);
-            }).catch(() => undefined).finally(() => this.abort.abort());
+            const stream = this.stream;
+            this.closeTimer = setTimeout(() => this.fail(), closeHandshakeTimeoutMs);
+            this.writes = this.writes
+                .then(async () => await writeFrame(stream, 8, payload, maxFrameBytes))
+                .catch(() => this.fail());
         }
         async connect(url, protocols) {
             try {
@@ -183,10 +190,19 @@ export function installWebSocketPatch(options) {
                     this.writes = this.writes.then(async () => await writeFrame(stream, 10, frame.payload, maxFrameBytes)).catch(() => this.fail());
                 }
                 else if (frame.opcode === 8) {
+                    if (frame.payload.length === 1)
+                        throw new Error("invalid WebSocket close frame");
                     const code = frame.payload.length >= 2 ? readU16(frame.payload) : 1000;
                     const reason = frame.payload.length > 2 ? decoder.decode(frame.payload.subarray(2)) : "";
-                    this.readyState = ProxyWebSocket.CLOSED;
-                    this.emit("close", new CloseEvent("close", { code, reason, wasClean: true }));
+                    const peerInitiated = this.readyState === ProxyWebSocket.OPEN;
+                    this.readyState = ProxyWebSocket.CLOSING;
+                    if (this.closeTimer !== undefined)
+                        clearTimeout(this.closeTimer);
+                    if (peerInitiated) {
+                        this.writes = this.writes.then(async () => await writeFrame(stream, 8, frame.payload, maxFrameBytes));
+                    }
+                    await this.writes;
+                    this.completeClose(code, reason);
                     return;
                 }
                 else if (frame.opcode === 1) {
@@ -211,12 +227,29 @@ export function installWebSocketPatch(options) {
         fail() {
             if (this.readyState === ProxyWebSocket.CLOSED)
                 return;
+            if (this.closeTimer !== undefined)
+                clearTimeout(this.closeTimer);
             this.readyState = ProxyWebSocket.CLOSED;
             this.bufferedAmount = 0;
             this.emit("error", new Event("error"));
             this.emit("close", new CloseEvent("close", { code: 1006, reason: "proxy WebSocket failed", wasClean: false }));
+            const stream = this.stream;
+            this.stream = undefined;
+            this.abort.abort();
+            void stream?.reset().catch(() => undefined);
+        }
+        completeClose(code, reason) {
+            if (this.readyState === ProxyWebSocket.CLOSED)
+                return;
+            if (this.closeTimer !== undefined)
+                clearTimeout(this.closeTimer);
+            this.readyState = ProxyWebSocket.CLOSED;
+            this.bufferedAmount = 0;
+            this.emit("close", new CloseEvent("close", { code, reason, wasClean: true }));
+            const stream = this.stream;
             this.stream = undefined;
             this.abort.abort();
+            void stream?.close().catch(() => stream.reset().catch(() => undefined));
         }
     }
     globalThis.WebSocket = ProxyWebSocket;

package/dist/public/streamHandlers.d.ts

@@ -18,3 +18,6 @@ export declare class StreamHandlers {
     handleStream(kind: string, handler: StreamHandler): void;
     serve(session: Session, options?: OperationOptions): Promise<void>;
 }
+/** Explicit-compatibility application-stream handlers. */
+export declare class LegacyStreamHandlers extends StreamHandlers {
+}

package/dist/public/streamHandlers.js

@@ -11,6 +11,7 @@ export class HandlerRegistrationError extends Error {
     }
 }
 const streamHandlerStates = new WeakMap();
+const RESERVED_RPC_KINDS = new Set(["flowersec.rpc.v2", "flowersec.rpc.v3"]);
 /** Carrier-neutral application-stream handlers for any established Session. */
 export class StreamHandlers {
     constructor(options = {}) {
@@ -22,6 +23,7 @@ export class StreamHandlers {
         }
         streamHandlerStates.set(this, {
             maxConcurrentStreams: maximum,
+            reservedRPCKinds: RESERVED_RPC_KINDS,
             streams: new Map(),
             frozen: false,
         });
@@ -36,6 +38,9 @@ export class StreamHandlers {
         await serveFrozenStreamHandlers(freezeStreamHandlers(this), session, options, async () => await session.close());
     }
 }
+/** Explicit-compatibility application-stream handlers. */
+export class LegacyStreamHandlers extends StreamHandlers {
+}
 function mutableStreamHandlerState(handlers) {
     const state = streamHandlerStates.get(handlers);
     if (state === undefined)
@@ -50,7 +55,7 @@ function registerIntoState(state, entries) {
     const pending = new Set();
     for (const [kind, handler] of entries) {
         if (!validApplicationStreamKind(kind) ||
-            kind === "flowersec.rpc.v2" ||
+            state.reservedRPCKinds.has(kind) ||
             typeof handler !== "function") {
             throw new HandlerRegistrationError("invalid_handler");
         }

package/dist/rpc/client.js

@@ -1,5 +1,5 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
-import { assertRpcEnvelope } from "./validate.js";
+import { assertRpcEnvelope, assertRpcTypeId } 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.
@@ -25,12 +25,13 @@ export class RpcClient {
     async call(typeId, payload, signal) {
         if (this.closed)
             throw new Error("rpc client closed");
+        const validatedTypeId = assertRpcTypeId(typeId);
         if (this.nextId > MAX_SAFE_REQUEST_ID)
             throw new Error("request id overflow");
         const requestId = this.nextId;
         this.nextId += 1n;
         const env = {
-            type_id: typeId >>> 0,
+            type_id: validatedTypeId,
             request_id: Number(requestId),
             response_to: 0,
             payload
@@ -39,7 +40,7 @@ export class RpcClient {
             this.pending.set(requestId, { resolve, reject });
         });
         try {
-            await writeJsonFrame(this.write, env);
+            await writeJsonFrame(this.write, env, DEFAULT_MAX_JSON_FRAME_BYTES);
         }
         catch (e) {
             this.pending.delete(requestId);
@@ -71,7 +72,7 @@ export class RpcClient {
     }
     // onNotify registers a handler for incoming notifications.
     onNotify(typeId, handler) {
-        const tid = typeId >>> 0;
+        const tid = assertRpcTypeId(typeId);
         const set = this.notifyHandlers.get(tid) ?? new Set();
         set.add(handler);
         this.notifyHandlers.set(tid, set);
@@ -86,13 +87,14 @@ export class RpcClient {
     async notify(typeId, payload) {
         if (this.closed)
             throw new Error("rpc client closed");
+        const validatedTypeId = assertRpcTypeId(typeId);
         const env = {
-            type_id: typeId >>> 0,
+            type_id: validatedTypeId,
             request_id: 0,
             response_to: 0,
             payload
         };
-        await writeJsonFrame(this.write, env);
+        await writeJsonFrame(this.write, env, DEFAULT_MAX_JSON_FRAME_BYTES);
     }
     async readLoop() {
         try {
@@ -101,7 +103,7 @@ export class RpcClient {
                 if (v.response_to === 0) {
                     // Notification: response_to=0 and request_id=0.
                     if (v.request_id === 0) {
-                        const set = this.notifyHandlers.get(v.type_id >>> 0);
+                        const set = this.notifyHandlers.get(v.type_id);
                         if (set != null) {
                             for (const h of set) {
                                 try {

package/dist/rpc/server.js

@@ -1,5 +1,5 @@
 import { DEFAULT_MAX_JSON_FRAME_BYTES, readJsonFrame, writeJsonFrame } from "../framing/jsonframe.js";
-import { assertRpcEnvelope, assertRpcError } from "./validate.js";
+import { assertRpcEnvelope, assertRpcError, assertRpcTypeId } from "./validate.js";
 import { SDK_DEFAULTS } from "../defaults.js";
 const DEFAULT_RPC_SERVER_OPTIONS = Object.freeze({
     maxConcurrentRequests: SDK_DEFAULTS.rpc.maxConcurrentRequests,
@@ -10,13 +10,13 @@ export class RpcRouter {
     handlers = new Map();
     notifyHandlers = new Map();
     register(typeId, handler) {
-        this.handlers.set(typeId >>> 0, handler);
+        this.handlers.set(assertRpcTypeId(typeId), handler);
     }
     handler(typeId) {
-        return this.handlers.get(typeId >>> 0);
+        return this.handlers.get(assertRpcTypeId(typeId));
     }
     onNotify(typeId, handler) {
-        const normalized = typeId >>> 0;
+        const normalized = assertRpcTypeId(typeId);
         const handlers = this.notifyHandlers.get(normalized) ?? new Set();
         handlers.add(handler);
         this.notifyHandlers.set(normalized, handlers);
@@ -27,7 +27,7 @@ export class RpcRouter {
         };
     }
     async dispatchNotification(typeId, payload) {
-        const normalized = typeId >>> 0;
+        const normalized = assertRpcTypeId(typeId);
         const requestHandler = this.handlers.get(normalized);
         if (requestHandler !== undefined)
             await requestHandler(payload);
@@ -76,7 +76,7 @@ export class RpcServer {
         if (this.closed)
             throw new Error("rpc server closed");
         await this.writeEnvelope({
-            type_id: typeId >>> 0,
+            type_id: assertRpcTypeId(typeId),
             request_id: 0,
             response_to: 0,
             payload,
@@ -93,6 +93,7 @@ export class RpcServer {
             return await new Promise(() => undefined);
         }));
         let failure;
+        const aborted = abortPromise(signal);
         try {
             while (!this.closed) {
                 if (signal?.aborted)
@@ -101,6 +102,7 @@ export class RpcServer {
                     readJsonFrame(this.transport.readExactly, DEFAULT_MAX_JSON_FRAME_BYTES),
                     this.terminalSignal.then((error) => { throw error; }),
                     workerFailure,
+                    ...(aborted === undefined ? [] : [aborted.promise]),
                 ]);
                 const v = assertRpcEnvelope(next);
                 if (v.response_to !== 0)
@@ -126,6 +128,9 @@ export class RpcServer {
             failure = err;
             this.terminalError = err;
         }
+        finally {
+            aborted?.cleanup();
+        }
         let closeError;
         try {
             this.close(failure ?? this.terminalError ?? new Error("rpc server closed"));
@@ -173,19 +178,23 @@ export class RpcServer {
             if (work == null)
                 return;
             const v = work.envelope;
-            const h = this.router.handler(v.type_id);
-            let out;
-            if (h == null)
-                out = { payload: null, error: { code: 404, message: "handler not found" } };
-            else {
-                try {
-                    out = await h(v.payload);
-                }
-                catch {
-                    out = { payload: null, error: { code: 500, message: "internal error" } };
-                }
-            }
             try {
+                const h = this.router.handler(v.type_id);
+                let out;
+                if (h == null)
+                    out = { payload: null, error: { code: 404, message: "handler not found" } };
+                else {
+                    const outcome = await Promise.race([
+                        Promise.resolve().then(() => h(v.payload)).then((value) => ({ kind: "completed", value }), () => ({
+                            kind: "completed",
+                            value: { payload: null, error: { code: 500, message: "internal error" } },
+                        })),
+                        this.terminalSignal.then(() => ({ kind: "terminated" })),
+                    ]);
+                    if (outcome.kind === "terminated")
+                        return;
+                    out = outcome.value;
+                }
                 if (this.closed)
                     return;
                 await this.writeResponse(v, out);
@@ -201,7 +210,12 @@ export class RpcServer {
             if (work == null)
                 return;
             const v = work.envelope;
-            await this.router.dispatchNotification(v.type_id, v.payload);
+            const completed = await Promise.race([
+                Promise.resolve().then(() => this.router.dispatchNotification(v.type_id, v.payload)).then(() => true),
+                this.terminalSignal.then(() => false),
+            ]);
+            if (!completed)
+                return;
         }
     }
     async nextWork(queue, waiters) {
@@ -236,7 +250,7 @@ export class RpcServer {
         await this.writeEnvelope(resp);
     }
     async writeEnvelope(envelope) {
-        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, envelope));
+        const write = this.writeChain.then(() => writeJsonFrame(this.transport.write, envelope, DEFAULT_MAX_JSON_FRAME_BYTES));
         this.writeChain = write;
         try {
             await write;
@@ -247,6 +261,16 @@ export class RpcServer {
         }
     }
 }
+function abortPromise(signal) {
+    if (signal === undefined || signal.aborted)
+        return undefined;
+    let onAbort;
+    const promise = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason ?? new Error("aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    return { promise, cleanup: () => signal.removeEventListener("abort", onAbort) };
+}
 function positiveInteger(value, name) {
     if (!Number.isSafeInteger(value) || value <= 0)
         throw new RangeError(`${name} must be a positive integer`);

package/dist/rpc/validate.d.ts

@@ -1,3 +1,4 @@
 import type { RpcEnvelope, RpcError } from "./wire.js";
 export declare function assertRpcEnvelope(v: unknown): RpcEnvelope;
+export declare function assertRpcTypeId(value: unknown): number;
 export declare function assertRpcError(value: unknown): RpcError;

package/dist/rpc/validate.js

@@ -6,21 +6,33 @@ const strictDecoder = new TextDecoder("utf-8", { fatal: true });
 // 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)
+    if (typeof v !== "object" || v == null || Array.isArray(v))
         throw new Error("bad rpc envelope");
     const o = v;
-    if (!isSafeU32Number(o.type_id))
-        throw new Error("bad rpc envelope: type_id");
+    const keys = Object.keys(o);
+    if (keys.some((key) => key !== "type_id" && key !== "request_id" && key !== "response_to" && key !== "payload" && key !== "error")) {
+        throw new Error("bad rpc envelope: shape");
+    }
+    if (!Object.prototype.hasOwnProperty.call(o, "payload"))
+        throw new Error("bad rpc envelope: payload");
+    assertRpcTypeId(o.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 (o.request_id !== 0 && o.response_to !== 0)
+        throw new Error("bad rpc envelope: request/response shape");
+    if (o.error != null && o.response_to === 0)
+        throw new Error("bad rpc envelope: error shape");
+    if (o.error != null)
         assertRpcError(o.error);
-    }
     return o;
 }
+export function assertRpcTypeId(value) {
+    if (!isSafeU32Number(value) || value === 0)
+        throw new RangeError("RPC typeId must be a non-zero u32 integer");
+    return value;
+}
 export function assertRpcError(value) {
     if (typeof value !== "object" || value == null)
         throw new Error("bad rpc envelope: error");

package/dist/v2/index.d.ts

@@ -0,0 +1,14 @@
+export type { ByteStream, IncomingStream, JsonObject, JsonPrimitive, JsonValue, OperationOptions, RpcPeer, RpcResult, SessionErrorCode, StreamOpenOptions, UnreliableMessageChannel, UnreliableMessageSendOptions, UnreliableMessageSendResult, SessionTermination, Session, } from "../public/contract.js";
+export { SessionError, UnreliableMessageError } from "../public/contract.js";
+export { createStreamMetadata, StreamMetadataError } from "../public/streamMetadata.js";
+export type { StreamMetadata } from "../public/streamMetadata.js";
+export { HandlerRegistrationError, LegacyStreamHandlers as StreamHandlers, } from "../public/streamHandlers.js";
+export type { StreamHandler, StreamHandlerOptions, } from "../public/streamHandlers.js";
+export { ArtifactLeaseError, createArtifactLease, } from "../public/artifactLease.js";
+export type { ArtifactLease } from "../public/artifactLease.js";
+export { Artifact, ArtifactError, parseArtifact } from "../public/artifact.js";
+export type { ArtifactErrorCode } from "../public/artifact.js";
+export type { ConnectErrorCode } from "../public/connectError.js";
+export { ConnectError } from "../public/connectError.js";
+export { ConnectionControllerError } from "../connectionController.js";
+export type { ArtifactSource, ArtifactSourceResult, ConnectionController, ConnectionControllerFailure, ConnectionControllerOptions, ConnectionSnapshot, ConnectionState, RetryDisposition, } from "../connectionController.js";

package/dist/v2/index.js

@@ -0,0 +1,7 @@
+export { SessionError, UnreliableMessageError } from "../public/contract.js";
+export { createStreamMetadata, StreamMetadataError } from "../public/streamMetadata.js";
+export { HandlerRegistrationError, LegacyStreamHandlers as StreamHandlers, } from "../public/streamHandlers.js";
+export { ArtifactLeaseError, createArtifactLease, } from "../public/artifactLease.js";
+export { Artifact, ArtifactError, parseArtifact } from "../public/artifact.js";
+export { ConnectError } from "../public/connectError.js";
+export { ConnectionControllerError } from "../connectionController.js";