bunite-core 0.17.1 → 0.17.3

package/src/rpc/renderer.ts

@@ -1,12 +1,12 @@
 import {
+  type AnyCapDef,
+  type ClientOf,
+  type Connection,
   createConnection,
   createFrameTransport,
   createWebSocketPipe,
-  type Connection,
-  type CapDef,
   type Schema,
   type SchemaRoots,
-  type ClientOf,
   type WebSocketLike,
 } from "./index";
 
@@ -22,8 +22,10 @@ export interface BuniteWebGlobal {
 declare global {
   interface Window {
     host?: {
-      bootstrap<C extends CapDef<any, any>>(cap: C): Promise<ClientOf<C>>;
-      bootstrap<R extends SchemaRoots>(schema: Schema<R>): Promise<{ [K in keyof R]: ClientOf<R[K]> }>;
+      bootstrap<C extends AnyCapDef>(cap: C): Promise<ClientOf<C>>;
+      bootstrap<R extends SchemaRoots>(
+        schema: Schema<R>,
+      ): Promise<{ [K in keyof R]: ClientOf<R[K]> }>;
       runtime(): Promise<ClientOf<typeof import("./framework").RuntimeCap>>;
       releaseRef(proxy: unknown): Promise<void>;
       /** Full Connection for renderer-as-server (serve / serveAll / unserve / replace / on). */
@@ -44,7 +46,13 @@ function isNative(): boolean {
 }
 
 function ensureWebConnection(path = "/rpc"): Promise<Connection> {
-  if (_webConn) return Promise.resolve(_webConn);
+  // Drop a closed cached conn so a disconnect (WS close/error → onClose) leads to
+  // a fresh reconnect on the next call, instead of handing back a dead connection.
+  if (_webConn) {
+    if (!_webConn.closed) return Promise.resolve(_webConn);
+    _webConn = null;
+    _webConnPromise = null;
+  }
   // Host-provided shared Connection — cross-bundle reachability for renderer
   // ecosystems (e.g. extension hosts) that bundle bunite-core 0-externals per
   // plugin. Page-author trust applies; bunite policy/attestation still gates.
@@ -61,8 +69,16 @@ function ensureWebConnection(path = "/rpc"): Promise<Connection> {
     const ws = new WebSocket(`${proto}//${location.host}${path}`);
     ws.binaryType = "arraybuffer";
     await new Promise<void>((resolve, reject) => {
-      ws.addEventListener("open", () => resolve(), { once: true });
-      ws.addEventListener("error", () => reject(new Error("web RPC ws connect failed")), { once: true });
+      const onOpen = () => {
+        ws.removeEventListener("error", onError);
+        resolve();
+      };
+      const onError = () => {
+        ws.removeEventListener("open", onOpen);
+        reject(new Error("web RPC ws connect failed"));
+      };
+      ws.addEventListener("open", onOpen, { once: true });
+      ws.addEventListener("error", onError, { once: true });
     });
     const conn = createConnection({
       transport: createFrameTransport(createWebSocketPipe(ws as unknown as WebSocketLike)),
@@ -79,9 +95,11 @@ function ensureWebConnection(path = "/rpc"): Promise<Connection> {
   return attempt;
 }
 
-export function bootstrap<C extends CapDef<any, any>>(cap: C): Promise<ClientOf<C>>;
-export function bootstrap<R extends SchemaRoots>(schema: Schema<R>): Promise<{ [K in keyof R]: ClientOf<R[K]> }>;
-export async function bootstrap(target: CapDef<any, any> | Schema<any>): Promise<unknown> {
+export function bootstrap<C extends AnyCapDef>(cap: C): Promise<ClientOf<C>>;
+export function bootstrap<R extends SchemaRoots>(
+  schema: Schema<R>,
+): Promise<{ [K in keyof R]: ClientOf<R[K]> }>;
+export async function bootstrap(target: AnyCapDef | Schema<any>): Promise<unknown> {
   if (isNative()) {
     if (!window.host?.bootstrap) throw new Error("host preload not ready");
     return (window.host.bootstrap as (t: unknown) => Promise<unknown>)(target);

package/src/rpc/schema.ts

@@ -10,31 +10,37 @@ declare const EXPORTED_CAP_BRAND: unique symbol;
 
 export type ReturnsKind = "type" | "cap" | "capArray" | "capRecord";
 
-export type CapRefToken<C extends CapDef<any, any>> = {
+export type CapRefToken<C extends AnyCapDef> = {
   readonly [CAP_REF_TAG]: true;
   readonly cap: C;
 };
 
-export type CapArrayToken<C extends CapDef<any, any>> = {
+export type CapArrayToken<C extends AnyCapDef> = {
   readonly [CAP_ARRAY_TAG]: true;
   readonly cap: C;
 };
 
-export type CapRecordToken<C extends CapDef<any, any>> = {
+export type CapRecordToken<C extends AnyCapDef> = {
   readonly [CAP_RECORD_TAG]: true;
   readonly cap: C;
 };
 
-export type AnyCapToken<C extends CapDef<any, any> = CapDef<any, any>> =
+export type AnyCapToken<C extends AnyCapDef = AnyCapDef> =
   | CapRefToken<C>
   | CapArrayToken<C>
   | CapRecordToken<C>;
 
-function _cap<C extends CapDef<any, any>>(c: C): CapRefToken<C> {
+function _cap<C extends AnyCapDef>(c: C): CapRefToken<C> {
   return { [CAP_REF_TAG]: true, cap: c };
 }
-_cap.array = <C extends CapDef<any, any>>(c: C): CapArrayToken<C> => ({ [CAP_ARRAY_TAG]: true, cap: c });
-_cap.record = <C extends CapDef<any, any>>(c: C): CapRecordToken<C> => ({ [CAP_RECORD_TAG]: true, cap: c });
+_cap.array = <C extends AnyCapDef>(c: C): CapArrayToken<C> => ({
+  [CAP_ARRAY_TAG]: true,
+  cap: c,
+});
+_cap.record = <C extends AnyCapDef>(c: C): CapRecordToken<C> => ({
+  [CAP_RECORD_TAG]: true,
+  cap: c,
+});
 export const cap = _cap;
 
 export function isCapRef(v: unknown): v is CapRefToken<any> {
@@ -75,15 +81,18 @@ export function isStreamDef(v: unknown): v is StreamDef {
   return typeof v === "object" && v !== null && (v as any)[STREAM_TAG] === true;
 }
 
-export function call<P, C extends CapDef<any, any>>(
-  opts: { returns: CapRefToken<C>; idempotent?: boolean }
-): CallDef<P, CapRefToken<C>>;
-export function call<P, C extends CapDef<any, any>>(
-  opts: { returns: CapArrayToken<C>; idempotent?: boolean }
-): CallDef<P, CapArrayToken<C>>;
-export function call<P, C extends CapDef<any, any>>(
-  opts: { returns: CapRecordToken<C>; idempotent?: boolean }
-): CallDef<P, CapRecordToken<C>>;
+export function call<P, C extends AnyCapDef>(opts: {
+  returns: CapRefToken<C>;
+  idempotent?: boolean;
+}): CallDef<P, CapRefToken<C>>;
+export function call<P, C extends AnyCapDef>(opts: {
+  returns: CapArrayToken<C>;
+  idempotent?: boolean;
+}): CallDef<P, CapArrayToken<C>>;
+export function call<P, C extends AnyCapDef>(opts: {
+  returns: CapRecordToken<C>;
+  idempotent?: boolean;
+}): CallDef<P, CapRecordToken<C>>;
 export function call<P = void, R = void>(opts?: { idempotent?: boolean }): CallDef<P, R>;
 export function call(opts?: { idempotent?: boolean; returns?: AnyCapToken }): CallDef<any, any> {
   return {
@@ -93,7 +102,9 @@ export function call(opts?: { idempotent?: boolean; returns?: AnyCapToken }): Ca
   };
 }
 
-export function stream<P = void, Y = unknown>(opts?: { hint?: Record<string, unknown> }): StreamDef<P, Y> {
+export function stream<P = void, Y = unknown>(opts?: {
+  hint?: Record<string, unknown>;
+}): StreamDef<P, Y> {
   return { [STREAM_TAG]: true, hint: opts?.hint };
 }
 
@@ -104,7 +115,10 @@ export interface DisposalSpec<M extends MethodsRecord = MethodsRecord> {
 
 export type MethodsRecord = Record<string, MethodDef>;
 
-export interface CapDef<M extends MethodsRecord = MethodsRecord, D extends DisposalSpec<M> | undefined = undefined> {
+export interface CapDef<
+  M extends MethodsRecord = MethodsRecord,
+  D extends DisposalSpec<M> | undefined = undefined,
+> {
   readonly [CAP_TAG]: true;
   readonly name: string;
   readonly version?: string;
@@ -112,16 +126,17 @@ export interface CapDef<M extends MethodsRecord = MethodsRecord, D extends Dispo
   readonly disposal: D;
 }
 
+export type AnyCapDef = CapDef<any, any>;
+
 export interface DefineCapOpts<M extends MethodsRecord, D extends DisposalSpec<M> | undefined> {
   version?: string | number;
   disposal?: D;
 }
 
-export function defineCap<M extends MethodsRecord, D extends DisposalSpec<M> | undefined = undefined>(
-  name: string,
-  methods: M,
-  opts?: DefineCapOpts<M, D>
-): CapDef<M, D> {
+export function defineCap<
+  M extends MethodsRecord,
+  D extends DisposalSpec<M> | undefined = undefined,
+>(name: string, methods: M, opts?: DefineCapOpts<M, D>): CapDef<M, D> {
   return {
     [CAP_TAG]: true,
     name,
@@ -136,7 +151,7 @@ export function isCapDef(v: unknown): v is CapDef {
 }
 
 // Schema = grouping sugar (Record<rootName, CapDef>). TS atomicity for serveAll.
-export type SchemaRoots = Record<string, CapDef<any, any>>;
+export type SchemaRoots = Record<string, AnyCapDef>;
 
 export interface Schema<R extends SchemaRoots = SchemaRoots> {
   readonly [SCHEMA_TAG]: true;
@@ -155,7 +170,7 @@ export function isSchema(v: unknown): v is Schema {
   return typeof v === "object" && v !== null && (v as any)[SCHEMA_TAG] === true;
 }
 
-export interface ExportedCap<C extends CapDef<any, any>> {
+export interface ExportedCap<C extends AnyCapDef> {
   readonly [EXPORTED_CAP_BRAND]: true;
   readonly cap: C;
   readonly capId: number;
@@ -168,7 +183,7 @@ export interface CallCtx {
   attestation: Attestation;
   signal: AbortSignal;
   deadline?: number;
-  exportCap<C extends CapDef<any, any>>(capDef: C, impl: ImplOf<C>): ExportedCap<C>;
+  exportCap<C extends AnyCapDef>(capDef: C, impl: ImplOf<C>): ExportedCap<C>;
 }
 
 export interface Attestation {
@@ -184,45 +199,55 @@ export interface Attestation {
 type MaybePromise<T> = T | Promise<T>;
 
 type ServerReturn<R> =
-  R extends CapRefToken<infer C> ? ExportedCap<C> :
-  R extends CapArrayToken<infer C> ? ExportedCap<C>[] :
-  R extends CapRecordToken<infer C> ? Record<string, ExportedCap<C>> :
-  R;
+  R extends CapRefToken<infer C>
+    ? ExportedCap<C>
+    : R extends CapArrayToken<infer C>
+      ? ExportedCap<C>[]
+      : R extends CapRecordToken<infer C>
+        ? Record<string, ExportedCap<C>>
+        : R;
 
 export type ClientReturn<R> =
-  R extends CapRefToken<infer C> ? ClientOf<C> :
-  R extends CapArrayToken<infer C> ?
-    C extends CapDef<any, infer D>
-      ? [D] extends [DisposalSpec] ? ClientOf<C>[] & Disposable
-      : ClientOf<C>[]
-    : ClientOf<C>[] :
-  R extends CapRecordToken<infer C> ? Record<string, ClientOf<C>> :
-  R;
+  R extends CapRefToken<infer C>
+    ? ClientOf<C>
+    : R extends CapArrayToken<infer C>
+      ? C extends CapDef<any, infer D>
+        ? [D] extends [DisposalSpec]
+          ? ClientOf<C>[] & Disposable
+          : ClientOf<C>[]
+        : ClientOf<C>[]
+      : R extends CapRecordToken<infer C>
+        ? Record<string, ClientOf<C>>
+        : R;
 
 export type Stream<T> = AsyncIterable<T> & Disposable & { cancel(): void };
 
-export type ClientOf<T> = T extends CapDef<infer M, infer D>
-  ? {
-      [K in keyof M]: M[K] extends CallDef<infer P, infer R>
-        ? [P] extends [void] ? () => Promise<ClientReturn<R>>
-        : (params: P) => Promise<ClientReturn<R>>
-        : M[K] extends StreamDef<infer P, infer Y>
-          ? [P] extends [void] ? () => Stream<Y>
-          : (params: P) => Stream<Y>
-          : never;
-    } & ([D] extends [DisposalSpec] ? Disposable : {})
-  : never;
-
-export type ImplOf<T> = T extends CapDef<infer M, any>
-  ? {
-      [K in keyof M]: M[K] extends CallDef<infer P, infer R>
-        ? (params: P, ctx: CallCtx) => MaybePromise<ServerReturn<R>>
-        : M[K] extends StreamDef<infer P, infer Y>
-          ? (params: P, ctx: CallCtx) => Stream<Y>
-          : never;
-    }
-  : never;
-
-export function methodKeys(cap: CapDef<any, any>): string[] {
+export type ClientOf<T> =
+  T extends CapDef<infer M, infer D>
+    ? {
+        [K in keyof M]: M[K] extends CallDef<infer P, infer R>
+          ? [P] extends [void]
+            ? () => Promise<ClientReturn<R>>
+            : (params: P) => Promise<ClientReturn<R>>
+          : M[K] extends StreamDef<infer P, infer Y>
+            ? [P] extends [void]
+              ? () => Stream<Y>
+              : (params: P) => Stream<Y>
+            : never;
+      } & ([D] extends [DisposalSpec] ? Disposable : unknown)
+    : never;
+
+export type ImplOf<T> =
+  T extends CapDef<infer M, any>
+    ? {
+        [K in keyof M]: M[K] extends CallDef<infer P, infer R>
+          ? (params: P, ctx: CallCtx) => MaybePromise<ServerReturn<R>>
+          : M[K] extends StreamDef<infer P, infer Y>
+            ? (params: P, ctx: CallCtx) => Stream<Y>
+            : never;
+      }
+    : never;
+
+export function methodKeys(cap: AnyCapDef): string[] {
   return Object.keys(cap.methods);
 }

package/src/rpc/stream.ts

@@ -4,7 +4,10 @@ type Setup<T> = (emit: (chunk: T) => void, signal: AbortSignal) => void | (() =>
 
 class ServerStream<T> implements AsyncIterable<T>, Disposable {
   private readonly buffer: T[] = [];
-  private readonly waiters: Array<{ resolve: (r: IteratorResult<T>) => void; reject: (e: unknown) => void }> = [];
+  private readonly waiters: Array<{
+    resolve: (r: IteratorResult<T>) => void;
+    reject: (e: unknown) => void;
+  }> = [];
   private readonly ctrl = new AbortController();
   private cleanup?: () => void;
   private ended = false;
@@ -36,7 +39,9 @@ class ServerStream<T> implements AsyncIterable<T>, Disposable {
         }
         if (this.failure) throw this.failure;
         if (this.ended) return { value: undefined as unknown as T, done: true };
-        return new Promise<IteratorResult<T>>((resolve, reject) => this.waiters.push({ resolve, reject }));
+        return new Promise<IteratorResult<T>>((resolve, reject) =>
+          this.waiters.push({ resolve, reject }),
+        );
       },
       return: async (): Promise<IteratorResult<T>> => {
         this.dispose();
@@ -57,7 +62,11 @@ class ServerStream<T> implements AsyncIterable<T>, Disposable {
     if (this.ended) return;
     this.ended = true;
     this.ctrl.abort();
-    try { this.cleanup?.(); } catch { /* swallow */ }
+    try {
+      this.cleanup?.();
+    } catch {
+      /* swallow */
+    }
     while (this.waiters.length > 0) {
       const w = this.waiters.shift()!;
       w.resolve({ value: undefined as unknown as T, done: true });

package/src/rpc/transport.ts

@@ -1,10 +1,11 @@
-import { type Frame, createCodec, isFrame } from "./wire";
-import type { Transport } from "./peer";
+import type { CloseInfo, Transport } from "./peer";
+import { createCodec, type Frame, isFrame } from "./wire";
 
 export interface BytesPipe {
   send(bytes: Uint8Array): void;
   setReceive(handler: (bytes: Uint8Array) => void): void;
   close(): void;
+  onClose?(handler: (info?: CloseInfo) => void): void;
 }
 
 export interface FrameTransportOptions {
@@ -14,6 +15,16 @@ export interface FrameTransportOptions {
 export function createFrameTransport(pipe: BytesPipe, opts: FrameTransportOptions = {}): Transport {
   const codec = createCodec();
   let handler: ((frame: Frame) => void) | undefined;
+  let closeHandler: ((info?: CloseInfo) => void) | undefined;
+  let closeFired = false;
+  // Fire once for any close cause — pipe disconnect (WS close/error) or a
+  // protocol error that forces pipe.close() — so the Connection always tears down.
+  const fireClose = (info?: CloseInfo) => {
+    if (closeFired) return;
+    closeFired = true;
+    closeHandler?.(info);
+  };
+  pipe.onClose?.(fireClose);
 
   pipe.setReceive((bytes) => {
     let frame: unknown;
@@ -21,11 +32,13 @@ export function createFrameTransport(pipe: BytesPipe, opts: FrameTransportOption
       frame = codec.unpackr.unpack(bytes);
     } catch (err) {
       opts.onProtocolError?.(`unpack failed: ${err instanceof Error ? err.message : String(err)}`);
+      fireClose();
       pipe.close();
       return;
     }
     if (!isFrame(frame)) {
       opts.onProtocolError?.("malformed frame");
+      fireClose();
       pipe.close();
       return;
     }
@@ -43,39 +56,90 @@ export function createFrameTransport(pipe: BytesPipe, opts: FrameTransportOption
     close() {
       pipe.close();
     },
+    onClose(h) {
+      closeHandler = h;
+    },
   };
 }
 
+type WsMessageEvent = { data: ArrayBuffer | Uint8Array | Blob | string };
+type WsCloseEvent = { code?: number; reason?: string };
+
 export interface WebSocketLike {
   send(data: Uint8Array | ArrayBuffer): unknown;
-  addEventListener(type: "message", listener: (event: { data: ArrayBuffer | Uint8Array | Blob | string }) => void): void;
-  removeEventListener?(type: "message", listener: (event: { data: ArrayBuffer | Uint8Array | Blob | string }) => void): void;
+  addEventListener(type: "message", listener: (event: WsMessageEvent) => void): void;
+  removeEventListener?(type: "message", listener: (event: WsMessageEvent) => void): void;
   close?(): void;
 }
 
+// close/error listeners — real WebSockets have them; kept off the public type so
+// message-only implementations stay assignable.
+type WsLifecycle = {
+  addEventListener(type: "close", listener: (event: WsCloseEvent) => void): void;
+  addEventListener(type: "error", listener: (event: unknown) => void): void;
+  removeEventListener?(type: "close", listener: (event: WsCloseEvent) => void): void;
+  removeEventListener?(type: "error", listener: (event: unknown) => void): void;
+};
+
 export function createWebSocketPipe(ws: WebSocketLike): BytesPipe {
   if ("binaryType" in ws) {
-    try { (ws as { binaryType?: string }).binaryType = "arraybuffer"; } catch { /* readonly in some envs */ }
+    try {
+      (ws as { binaryType?: string }).binaryType = "arraybuffer";
+    } catch {
+      /* readonly in some envs */
+    }
   }
+  const wsLife = ws as WebSocketLike & WsLifecycle;
   let handler: ((bytes: Uint8Array) => void) | undefined;
-  const onMessage = (event: { data: ArrayBuffer | Uint8Array | Blob | string }) => {
+  let closeHandler: ((info?: CloseInfo) => void) | undefined;
+  let closeFired = false;
+  const onMessage = (event: WsMessageEvent) => {
     if (!handler) return;
     const d = event.data;
-    if (d instanceof Uint8Array) { handler(d); return; }
-    if (d instanceof ArrayBuffer) { handler(new Uint8Array(d)); return; }
+    if (d instanceof Uint8Array) {
+      handler(d);
+      return;
+    }
+    if (d instanceof ArrayBuffer) {
+      handler(new Uint8Array(d));
+      return;
+    }
     if (typeof Blob !== "undefined" && d instanceof Blob) {
       void d.arrayBuffer().then((buf) => handler?.(new Uint8Array(buf)));
       return;
     }
   };
+  const detach = () => {
+    ws.removeEventListener?.("message", onMessage);
+    wsLife.removeEventListener?.("close", onClose);
+    wsLife.removeEventListener?.("error", onError);
+  };
+  const fireClose = (info?: CloseInfo) => {
+    if (closeFired) return;
+    closeFired = true;
+    detach();
+    closeHandler?.(info);
+  };
+  const onClose = (event: WsCloseEvent) => fireClose({ code: event?.code, reason: event?.reason });
+  // `error` is usually followed by `close` (which carries code/reason); defer so
+  // close wins, and this still fires for an error with no following close.
+  const onError = () => setTimeout(() => fireClose(), 0);
   ws.addEventListener("message", onMessage);
+  wsLife.addEventListener("close", onClose);
+  wsLife.addEventListener("error", onError);
   return {
-    send(bytes) { ws.send(bytes); },
-    setReceive(h) { handler = h; },
+    send(bytes) {
+      ws.send(bytes);
+    },
+    setReceive(h) {
+      handler = h;
+    },
+    onClose(h) {
+      closeHandler = h;
+    },
     close() {
-      ws.removeEventListener?.("message", onMessage);
+      detach();
       ws.close?.();
     },
   };
 }
-

package/src/rpc/wire.ts

@@ -1,4 +1,4 @@
-import { Packr, Unpackr, addExtension } from "msgpackr";
+import { addExtension, Packr, Unpackr } from "msgpackr";
 import type { IpcStatus } from "./error";
 
 export type u32 = number;
@@ -75,28 +75,41 @@ export function isFrame(value: unknown): value is Frame {
   if (typeof op !== "string" || !OPS.has(op as Frame["op"])) return false;
   switch (op as Frame["op"]) {
     case "hello":
-      return f.v === 1 && (f.mode === "native" || f.mode === "web")
-        && Array.isArray(f.features) && typeof f.maxBytes === "number" && typeof f.origin === "string";
+      return (
+        f.v === 1 &&
+        (f.mode === "native" || f.mode === "web") &&
+        Array.isArray(f.features) &&
+        typeof f.maxBytes === "number" &&
+        typeof f.origin === "string"
+      );
     case "goaway":
       return f.reason === undefined || typeof f.reason === "string";
     case "call":
-      return typeof f.id === "number" && typeof f.method === "string"
-        && typeof f.target === "object" && f.target !== null
-        && (f.target as { kind?: unknown }).kind === "cap"
-        && typeof (f.target as { id?: unknown }).id === "number";
+      return (
+        typeof f.id === "number" &&
+        typeof f.method === "string" &&
+        typeof f.target === "object" &&
+        f.target !== null &&
+        (f.target as { kind?: unknown }).kind === "cap" &&
+        typeof (f.target as { id?: unknown }).id === "number"
+      );
     case "result":
       return typeof f.id === "number" && (f.ok === true || f.ok === false);
     case "cancel":
       return typeof f.id === "number";
     case "stream":
-      return typeof f.id === "number" && typeof f.ev === "string"
-        && (f.ev === "next" || f.ev === "credit" || f.ev === "end" || f.ev === "error");
+      return (
+        typeof f.id === "number" &&
+        typeof f.ev === "string" &&
+        (f.ev === "next" || f.ev === "credit" || f.ev === "end" || f.ev === "error")
+      );
     case "drop":
       return Array.isArray(f.caps);
     case "cap_revoked":
       if (!Array.isArray(f.capIds)) return false;
       for (const id of f.capIds) {
-        if (typeof id !== "number" || !Number.isInteger(id) || id < 0 || id > 0xFFFFFFFF) return false;
+        if (typeof id !== "number" || !Number.isInteger(id) || id < 0 || id > 0xffffffff)
+          return false;
       }
       return true;
   }