bunite-core 0.17.1 → 0.17.2

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). */
@@ -62,7 +64,9 @@ function ensureWebConnection(path = "/rpc"): Promise<Connection> {
     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 });
+      ws.addEventListener("error", () => reject(new Error("web RPC ws connect failed")), {
+        once: true,
+      });
     });
     const conn = createConnection({
       transport: createFrameTransport(createWebSocketPipe(ws as unknown as WebSocketLike)),
@@ -79,9 +83,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,5 +1,5 @@
-import { type Frame, createCodec, isFrame } from "./wire";
 import type { Transport } from "./peer";
+import { createCodec, type Frame, isFrame } from "./wire";
 
 export interface BytesPipe {
   send(bytes: Uint8Array): void;
@@ -48,21 +48,37 @@ export function createFrameTransport(pipe: BytesPipe, opts: FrameTransportOption
 
 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: { data: ArrayBuffer | Uint8Array | Blob | string }) => void,
+  ): void;
+  removeEventListener?(
+    type: "message",
+    listener: (event: { data: ArrayBuffer | Uint8Array | Blob | string }) => void,
+  ): void;
   close?(): 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 */
+    }
   }
   let handler: ((bytes: Uint8Array) => void) | undefined;
   const onMessage = (event: { data: ArrayBuffer | Uint8Array | Blob | string }) => {
     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;
@@ -70,12 +86,15 @@ export function createWebSocketPipe(ws: WebSocketLike): BytesPipe {
   };
   ws.addEventListener("message", onMessage);
   return {
-    send(bytes) { ws.send(bytes); },
-    setReceive(h) { handler = h; },
+    send(bytes) {
+      ws.send(bytes);
+    },
+    setReceive(h) {
+      handler = h;
+    },
     close() {
       ws.removeEventListener?.("message", onMessage);
       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;
   }