@lesomnus/grpc-dgram 0.0.1

package/dist/conn-DTWG9vIx.d.mts

@@ -0,0 +1,331 @@
+import { a as MethodDesc, h as Metadata, n as CallOptions } from "./desc-BMF2FBqk.mjs";
+//#region src/timing.d.ts
+interface Timing {
+  callMs?: number;
+  livenessMs?: number;
+  retransmitMs?: number;
+  tombstoneMs?: number;
+  holdMs?: number;
+}
+interface ResolvedTiming {
+  callMs: number;
+  livenessMs: number;
+  retransmitMs: number;
+  tombstoneMs: number;
+  holdMs: number;
+  probeMs: number;
+  tickMs: number;
+}
+//#endregion
+//#region src/limits.d.ts
+declare enum DropPolicy {
+  Newest = 0,
+  Oldest = 1
+}
+interface RxBufferConfig {
+  size?: number;
+  policy?: DropPolicy;
+}
+interface ResolvedRxConfig {
+  size: number;
+  policy: DropPolicy;
+}
+interface Limits {
+  maxTombstones?: number;
+  maxTombstoneBytes?: number;
+  maxDeadPeers?: number;
+  maxPendingResets?: number;
+  maxLiveCalls?: number;
+  maxRepliesPerRTI?: number;
+}
+//#endregion
+//#region src/status.d.ts
+declare enum Code {
+  OK = 0,
+  CANCELLED = 1,
+  UNKNOWN = 2,
+  INVALID_ARGUMENT = 3,
+  DEADLINE_EXCEEDED = 4,
+  NOT_FOUND = 5,
+  ALREADY_EXISTS = 6,
+  PERMISSION_DENIED = 7,
+  RESOURCE_EXHAUSTED = 8,
+  FAILED_PRECONDITION = 9,
+  ABORTED = 10,
+  OUT_OF_RANGE = 11,
+  UNIMPLEMENTED = 12,
+  INTERNAL = 13,
+  UNAVAILABLE = 14,
+  DATA_LOSS = 15,
+  UNAUTHENTICATED = 16
+}
+declare class StatusError extends Error {
+  readonly code: Code;
+  readonly desc: string;
+  constructor(code: Code, desc: string);
+}
+declare function statusError(code: Code, desc: string): StatusError;
+declare class MessageTooLargeError extends Error {
+  constructor(message?: string);
+}
+declare function isMessageTooLarge(err: unknown): boolean;
+declare function toStatusError(err: unknown): StatusError;
+declare function abortCause(signal: AbortSignal): StatusError;
+//#endregion
+//#region src/wire.d.ts
+declare const FlagOpen = 1;
+declare const FlagClose = 2;
+declare const FlagReset = 4;
+declare const FlagPing = 8;
+declare const FlagWindow = 16;
+declare const FlagCompressed = 32;
+declare const SHAPE_MASK: number;
+interface Any {
+  typeUrl: string;
+  value: Uint8Array;
+}
+interface Frame {
+  epoch: number;
+  sid: number;
+  seq: number;
+  flags: number;
+  method: string;
+  codec: string;
+  timeoutMs?: number;
+  payload?: Uint8Array;
+  code?: number;
+  desc: string;
+  header?: Metadata;
+  trailer?: Metadata;
+  peerEpoch: number;
+  window: number;
+  compressor: string;
+  details?: Any[];
+}
+declare function frame(init?: Partial<Frame>): Frame;
+declare const isOpen: (f: Frame) => boolean;
+declare const isClose: (f: Frame) => boolean;
+declare const isReset: (f: Frame) => boolean;
+declare const isPing: (f: Frame) => boolean;
+declare const isWindow: (f: Frame) => boolean;
+declare const isCompressed: (f: Frame) => boolean;
+declare const shapeOf: (f: Frame) => number;
+declare const hasUnknownFlags: (f: Frame) => boolean;
+declare function legalShape(shape: number): boolean;
+declare const isTerminal: (f: Frame) => boolean;
+declare const isHalfClose: (f: Frame) => boolean;
+declare const isData: (f: Frame) => boolean;
+declare const isHeaderFrame: (f: Frame) => boolean;
+declare function frameStatus(f: Frame): StatusError;
+declare function setFrameError(f: Frame, err: unknown): void;
+declare function resetFor(f: Frame): Frame;
+declare function encodeFrame(f: Frame): Uint8Array;
+declare function decodeFrame(data: Uint8Array): Frame;
+declare function encodeEnvelop(frames: readonly Frame[]): Uint8Array;
+declare function decodeEnvelop(data: Uint8Array): Frame[];
+//#endregion
+//#region src/seam.d.ts
+interface FrameContext {
+  peer?: unknown;
+  reliable?: boolean;
+  signal?: AbortSignal;
+}
+interface FrameHandler {
+  handle(frame: Frame, ctx?: FrameContext): void | Promise<void>;
+}
+interface TransportInfo {
+  reliable(): boolean;
+}
+interface ConnAttacher {
+  attachConn(conn: Conn): void;
+}
+declare function hasTransportInfo(tx: FrameHandler): tx is FrameHandler & TransportInfo;
+declare function hasConnAttacher(tx: FrameHandler): tx is FrameHandler & ConnAttacher;
+declare function unpack(frames: readonly Frame[], h: FrameHandler, ctx?: FrameContext): Promise<void>;
+//#endregion
+//#region src/util.d.ts
+declare const W_INIT = 32;
+declare const DEFAULT_STALL_MS = 30000;
+declare const DEFAULT_MAX_RECV_MSG_SIZE: number;
+declare const DEFAULT_MAX_SEND_MSG_SIZE = 2147483647;
+interface Compressor {
+  compress(data: Uint8Array): Uint8Array | Promise<Uint8Array>;
+  decompress(data: Uint8Array, maxBytes: number): Uint8Array | Promise<Uint8Array>;
+}
+declare function getCompressor(name: string): Compressor | undefined;
+//#endregion
+//#region src/conn.d.ts
+declare class EndOfStreamError extends Error {
+  constructor();
+}
+interface FlowTiming extends Timing {
+  stallMs?: number;
+}
+interface CallConfig<Req = unknown, Res = unknown> extends CallOptions<Req, Res> {
+  compressor?: string;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+}
+interface ConnOptions {
+  reliable?: boolean;
+  timing?: FlowTiming;
+  rxBuffer?: RxBufferConfig;
+  limits?: Limits;
+  compressor?: string;
+  maxRecvMsgSize?: number;
+  maxSendMsgSize?: number;
+  compressors?: Record<string, Compressor>;
+  defaultCallOptions?: CallConfig;
+}
+interface CallInfo {
+  compressorName: string;
+  compressor: Compressor | undefined;
+  maxRecv: number;
+  maxSend: number;
+  stallMs: number;
+}
+type DetailedStatusError = StatusError & {
+  details?: readonly Any[];
+};
+declare function statusDetails(err: unknown): readonly Any[] | undefined;
+declare class Conn {
+  readonly epoch: number;
+  private readonly tx;
+  private readonly mode;
+  private readonly rxCfg;
+  private readonly limits;
+  private readonly defaults;
+  private readonly compressor;
+  private readonly compressors;
+  private readonly maxRecv;
+  private readonly maxSend;
+  private readonly stallMs;
+  private readonly ss;
+  private readonly tombs;
+  private readonly resetAt;
+  private sidNext;
+  private exhausted;
+  private closed;
+  private lastRx;
+  private lastTx;
+  private lastPing;
+  private readonly sw;
+  constructor(tx: FrameHandler, opts?: ConnOptions);
+  get reliable(): boolean;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(err?: unknown): void;
+  invoke<Req, Res>(desc: MethodDesc<Req, Res>, req: Req, opts?: CallConfig<Req, Res>): Promise<Res>;
+  newStream<Req, Res>(desc: MethodDesc<Req, Res>, opts?: CallConfig<Req, Res>): ClientStream<Req, Res>;
+  private resolveCall;
+  private createStream;
+  /** @internal */
+  get timing(): ResolvedTiming;
+  /** @internal */
+  get isReliable(): boolean;
+  /** @internal */
+  get streamRxCfg(): ResolvedRxConfig;
+  /** @internal */
+  transmit(f: Frame): Promise<void>;
+  /** @internal */
+  noteRx(): void;
+  /** @internal */
+  retire(s: ClientStream<unknown, unknown>): void;
+  private clearTombAbort;
+  private sendReset;
+  private failAll;
+  /** @internal */
+  kickSweep(): void;
+  private hasWork;
+  private sweep;
+}
+declare class ClientStream<Req, Res> {
+  readonly sid: number;
+  private readonly conn;
+  private readonly desc;
+  private readonly reqCodec;
+  private readonly resCodec;
+  private readonly codecName;
+  private readonly openHdr;
+  private readonly ci;
+  private readonly flowTx;
+  private readonly flowRx;
+  private readonly rxSize;
+  private readonly callerSignal;
+  private signalDispose;
+  private deadlineTimer;
+  private deadlineFired;
+  private readonly timeoutCause;
+  /** @internal */
+  deadlineAt: number | undefined;
+  private readonly txSeq;
+  private txOpened;
+  private txClosed;
+  /** @internal */
+  abortFrame: Frame | undefined;
+  private retxOpen;
+  private retxClose;
+  private retxAt;
+  private retxIval;
+  private lastRx;
+  private lastTx;
+  private lastProbe;
+  private readonly rxWin;
+  private srvEpoch;
+  private srvEpochSet;
+  private readonly rxq;
+  private readonly rxPolicy;
+  private rxDropped;
+  private rxHeader;
+  private trailerMd;
+  private readonly hdrLatch;
+  private readonly done;
+  private term;
+  private termErr;
+  private termPayloadDelivered;
+  /** @internal */
+  constructor(conn: Conn, desc: MethodDesc<Req, Res>, sid: number, opts: CallConfig<Req, Res>, ci: CallInfo, timeoutCause: StatusError | undefined);
+  /** @internal */
+  arm(opts: CallOptions<Req, Res>): void;
+  /** @internal */
+  handleRx(f: Frame, ctx: FrameContext): Promise<void>;
+  private grantWindow;
+  private recvInto;
+  private latchHeader;
+  private noteValidatedRx;
+  private openFrame;
+  private nextFrame;
+  /** @internal */
+  sendOpen(): Promise<void>;
+  /** @internal */
+  sendRaw(m: Req): Promise<void>;
+  private undoRefused;
+  send(m: Req): Promise<void>;
+  closeSend(): void;
+  recv(): Promise<Res | undefined>;
+  private recvBuffered;
+  private terminalRecv;
+  [Symbol.asyncIterator](): AsyncIterator<Res>;
+  header(): Promise<Metadata | undefined>;
+  trailer(): Metadata | undefined;
+  latchedHeader(): Metadata | undefined;
+  cancel(): void;
+  private abortFromCtx;
+  private sendAbort;
+  private finishTerm;
+  /** @internal */
+  finishLocal(err: StatusError): void;
+  /** @internal */
+  abandon(): void;
+  /** @internal */
+  finishReset(): void;
+  private release;
+  /** @internal */
+  transmit(f: Frame): Promise<void>;
+  private scheduleRetx;
+  /** @internal */
+  sweepRetx(now: number, capMs: number): Frame[];
+  /** @internal */
+  probeDue(now: number, probeMs: number): Frame | undefined;
+}
+//#endregion
+export { StatusError as $, decodeEnvelop as A, isHalfClose as B, FlagCompressed as C, FlagWindow as D, FlagReset as E, frameStatus as F, isTerminal as G, isOpen as H, hasUnknownFlags as I, resetFor as J, isWindow as K, isClose as L, encodeEnvelop as M, encodeFrame as N, Frame as O, frame as P, MessageTooLargeError as Q, isCompressed as R, FlagClose as S, FlagPing as T, isPing as U, isHeaderFrame as V, isReset as W, shapeOf as X, setFrameError as Y, Code as Z, TransportInfo as _, EndOfStreamError as a, Limits as at, unpack as b, Compressor as c, Timing as ct, DEFAULT_STALL_MS as d, abortCause as et, W_INIT as f, FrameHandler as g, FrameContext as h, DetailedStatusError as i, DropPolicy as it, decodeFrame as j, SHAPE_MASK as k, DEFAULT_MAX_RECV_MSG_SIZE as l, ConnAttacher as m, Conn as n, statusError as nt, FlowTiming as o, RxBufferConfig as ot, getCompressor as p, legalShape as q, ConnOptions as r, toStatusError as rt, statusDetails as s, ResolvedTiming as st, ClientStream as t, isMessageTooLarge as tt, DEFAULT_MAX_SEND_MSG_SIZE as u, hasConnAttacher as v, FlagOpen as w, Any as x, hasTransportInfo as y, isData as z };

package/dist/desc-BMF2FBqk.d.mts

@@ -0,0 +1,72 @@
+//#region src/metadata.d.ts
+type Metadata = Record<string, string[]>;
+declare const isBinaryKey: (key: string) => boolean;
+declare function metadataJoin(a: Metadata | undefined, b: Metadata | undefined): Metadata | undefined;
+declare function cloneMetadata(md: Metadata): Metadata;
+declare function encodeBase64(bytes: Uint8Array): string;
+declare function decodeBase64(s: string): Uint8Array;
+declare function validateMetadata(md: Metadata | undefined): void;
+declare function validateMetadataPair(key: string, values: readonly string[]): void;
+//#endregion
+//#region src/desc.d.ts
+interface PayloadCodec<T> {
+  marshal(value: T): Uint8Array;
+  unmarshal(data: Uint8Array): T;
+}
+interface MethodDesc<Req = unknown, Res = unknown> {
+  readonly path: string;
+  readonly clientStreams: boolean;
+  readonly serverStreams: boolean;
+  readonly request: PayloadCodec<Req>;
+  readonly response: PayloadCodec<Res>;
+  readonly requestSchema?: unknown;
+  readonly responseSchema?: unknown;
+}
+type UnaryDesc<Req, Res> = MethodDesc<Req, Res> & {
+  clientStreams: false;
+  serverStreams: false;
+};
+type ServerStreamingDesc<Req, Res> = MethodDesc<Req, Res> & {
+  clientStreams: false;
+  serverStreams: true;
+};
+type ClientStreamingDesc<Req, Res> = MethodDesc<Req, Res> & {
+  clientStreams: true;
+  serverStreams: false;
+};
+type BidiDesc<Req, Res> = MethodDesc<Req, Res> & {
+  clientStreams: true;
+  serverStreams: true;
+};
+type DescInit<Req, Res> = {
+  request: PayloadCodec<Req>;
+  response: PayloadCodec<Res>;
+  requestSchema?: unknown;
+  responseSchema?: unknown;
+};
+declare function unaryMethod<Req, Res>(path: string, init: DescInit<Req, Res>): UnaryDesc<Req, Res>;
+declare function serverStreamingMethod<Req, Res>(path: string, init: DescInit<Req, Res>): ServerStreamingDesc<Req, Res>;
+declare function clientStreamingMethod<Req, Res>(path: string, init: DescInit<Req, Res>): ClientStreamingDesc<Req, Res>;
+declare function bidiMethod<Req, Res>(path: string, init: DescInit<Req, Res>): BidiDesc<Req, Res>;
+declare function isUnary(desc: MethodDesc<unknown, unknown>): boolean;
+interface NamedCodec {
+  resolve(desc: MethodDesc<unknown, unknown>): {
+    request: PayloadCodec<unknown>;
+    response: PayloadCodec<unknown>;
+  };
+}
+interface ForcedCodec<Req = unknown, Res = unknown> {
+  name: string;
+  request: PayloadCodec<Req>;
+  response: PayloadCodec<Res>;
+}
+interface CallOptions<Req = unknown, Res = unknown> {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  metadata?: Metadata;
+  codec?: ForcedCodec<Req, Res>;
+  onHeader?: (md: Metadata | undefined) => void;
+  onTrailer?: (md: Metadata | undefined) => void;
+}
+//#endregion
+export { validateMetadataPair as S, decodeBase64 as _, MethodDesc as a, metadataJoin as b, ServerStreamingDesc as c, clientStreamingMethod as d, isUnary as f, cloneMetadata as g, Metadata as h, ForcedCodec as i, UnaryDesc as l, unaryMethod as m, CallOptions as n, NamedCodec as o, serverStreamingMethod as p, ClientStreamingDesc as r, PayloadCodec as s, BidiDesc as t, bidiMethod as u, encodeBase64 as v, validateMetadata as x, isBinaryKey as y };

package/dist/index.d.mts

@@ -0,0 +1,27 @@
+import { $ as StatusError, A as decodeEnvelop, B as isHalfClose, C as FlagCompressed, D as FlagWindow, E as FlagReset, F as frameStatus, G as isTerminal, H as isOpen, I as hasUnknownFlags, J as resetFor, K as isWindow, L as isClose, M as encodeEnvelop, N as encodeFrame, O as Frame, P as frame, Q as MessageTooLargeError, R as isCompressed, S as FlagClose, T as FlagPing, U as isPing, V as isHeaderFrame, W as isReset, X as shapeOf, Y as setFrameError, Z as Code, _ as TransportInfo, a as EndOfStreamError, at as Limits, b as unpack, c as Compressor, ct as Timing, d as DEFAULT_STALL_MS, et as abortCause, f as W_INIT, g as FrameHandler, h as FrameContext, i as DetailedStatusError, it as DropPolicy, j as decodeFrame, k as SHAPE_MASK, l as DEFAULT_MAX_RECV_MSG_SIZE, m as ConnAttacher, n as Conn, nt as statusError, o as FlowTiming, ot as RxBufferConfig, p as getCompressor, q as legalShape, r as ConnOptions, rt as toStatusError, s as statusDetails, t as ClientStream, tt as isMessageTooLarge, u as DEFAULT_MAX_SEND_MSG_SIZE, v as hasConnAttacher, w as FlagOpen, x as Any, y as hasTransportInfo, z as isData } from "./conn-DTWG9vIx.mjs";
+import { S as validateMetadataPair, _ as decodeBase64, a as MethodDesc, b as metadataJoin, c as ServerStreamingDesc, d as clientStreamingMethod, f as isUnary, g as cloneMetadata, h as Metadata, i as ForcedCodec, l as UnaryDesc, m as unaryMethod, n as CallOptions, o as NamedCodec, p as serverStreamingMethod, r as ClientStreamingDesc, s as PayloadCodec, t as BidiDesc, u as bidiMethod, v as encodeBase64, x as validateMetadata, y as isBinaryKey } from "./desc-BMF2FBqk.mjs";
+import { a as ServerOptions, c as ServerWriter, i as ServerContext, l as UnaryHandler, n as ClientStreamingHandler, o as ServerReader, r as Server, s as ServerStreamingHandler, t as BidiHandler } from "./server-xIr1mwqq.mjs";
+//#region src/seq.d.ts
+declare const W_FWD = 4096;
+declare const K_LOUD = 3;
+declare class TxSeq {
+  private v;
+  next(): number;
+  undo(seq: number): void;
+}
+declare enum RxVerdict {
+  Accept = 0,
+  Dup = 1,
+  Beyond = 2,
+  DataLoss = 3,
+  ProtocolError = 4
+}
+declare class RxWindow {
+  l: number;
+  strict: boolean;
+  private beyondN;
+  private beyondLast;
+  check(seq: number): RxVerdict;
+}
+//#endregion
+export { type Any, type BidiDesc, type BidiHandler, type CallOptions, ClientStream, type ClientStreamingDesc, type ClientStreamingHandler, Code, type Compressor, Conn, type ConnAttacher, type ConnOptions, DEFAULT_MAX_RECV_MSG_SIZE, DEFAULT_MAX_SEND_MSG_SIZE, DEFAULT_STALL_MS, type DetailedStatusError, DropPolicy, EndOfStreamError, FlagClose, FlagCompressed, FlagOpen, FlagPing, FlagReset, FlagWindow, type FlowTiming, type ForcedCodec, type Frame, type FrameContext, type FrameHandler, K_LOUD, type Limits, MessageTooLargeError, type Metadata, type MethodDesc, type NamedCodec, type PayloadCodec, type RxBufferConfig, RxVerdict, RxWindow, SHAPE_MASK, Server, type ServerContext, type ServerOptions, type ServerReader, type ServerStreamingDesc, type ServerStreamingHandler, type ServerWriter, StatusError, type Timing, type TransportInfo, TxSeq, type UnaryDesc, type UnaryHandler, W_FWD, W_INIT, abortCause, bidiMethod, clientStreamingMethod, cloneMetadata, decodeBase64, decodeEnvelop, decodeFrame, encodeBase64, encodeEnvelop, encodeFrame, frame, frameStatus, getCompressor, hasConnAttacher, hasTransportInfo, hasUnknownFlags, isBinaryKey, isClose, isCompressed, isData, isHalfClose, isHeaderFrame, isMessageTooLarge, isOpen, isPing, isReset, isTerminal, isUnary, isWindow, legalShape, metadataJoin, resetFor, serverStreamingMethod, setFrameError, shapeOf, statusDetails, statusError, toStatusError, unaryMethod, unpack, validateMetadata, validateMetadataPair };