@source-repo/rpc 3.0.0

package/dist/RPC/Messages.d.ts

@@ -0,0 +1,108 @@
+import { Payload } from './Core.js';
+/**
+ * The RPC message vocabulary, in a module of its own because both the handlers and the transports
+ * need it. A transport whose wire format is structured - MQTT 5 carries the method, correlation
+ * and reply address as packet properties - has to know what a call, a result, an error and an
+ * event are in order to map them.
+ */
+export declare enum RpcMessageType {
+    CallInstanceMethod = "POST",
+    success = "SUCCESS",
+    error = "ERROR",
+    event = "EVENT"
+}
+export interface RpcMessage extends Payload {
+    type: RpcMessageType;
+}
+export interface RpcCallInstanceMethodPayload extends RpcMessage {
+    id: string;
+    path: string;
+    method: string;
+    params: unknown[];
+    /**
+     * Contract version the caller was built against, when it has a schema. The server compares it
+     * with the version it serves and refuses only when the two are structurally incompatible.
+     */
+    version?: string;
+    /**
+     * How many milliseconds the caller will still be waiting, measured when it sent this. A server
+     * that finds the budget spent answers `Timeout` instead of running the method.
+     *
+     * A duration, not a moment. An absolute deadline would be exact if every peer agreed on the
+     * time, and one of the peers here is a browser page whose clock belongs to whoever is sitting
+     * at it - so a wrong clock would refuse every command it sent, which is a worse failure than
+     * the one this prevents. The receiver stamps arrival by its own clock and counts from there,
+     * and on MQTT 5 the broker's own expiry accounts for the part of the journey it queued.
+     */
+    ttl?: number;
+    /**
+     * Names the command this call *is*, as opposed to `id`, which names this attempt at it.
+     *
+     * Two attempts at one command carry one key, which is what lets a server with a durable
+     * idempotency store answer the second from the first's outcome instead of running it again.
+     * Absent means the request id is the key, which still covers a redelivery of the same packet
+     * but not an operator pressing the button a second time - those are different attempts.
+     */
+    idempotencyKey?: string;
+}
+export type RpcErrorCode = 'ClassNotFound' | 'MethodNotFound' | 'Exception' | 'Timeout' | 'TransportError' | 'Unauthorized' | 'Forbidden' | 'InvalidParams' | 'IncompatibleVersion'
+/**
+ * The call was sent and its outcome is not known: it may have run, it may not, and nothing here
+ * can tell which.
+ *
+ * Distinct from `TransportError`, which is the honest answer when a request never left - a
+ * failed encode, a closed link, a broker that refused the publish. The difference is the whole
+ * point. "It failed" invites a retry; "I do not know" says to go and look, and for a
+ * non-repeatable command that distinction is the difference between one pump start and two.
+ */
+ | 'UnknownOutcome';
+/**
+ * What a method does to the world, which decides what a caller may do about an uncertain answer.
+ *
+ * Most RPC systems make it easy to call a function and leave this to prose. On a plant it is the
+ * distinction that matters: retrying a read costs a round trip, and retrying a start costs a second
+ * start.
+ *
+ * - `query` changes nothing, so it can be repeated at will.
+ * - `idempotent-command` changes something, but arriving twice leaves the same state as arriving
+ *   once - `setSetpoint(1200)`, `close()`, anything that assigns rather than accumulates.
+ * - `non-repeatable-command` must not be sent again on an uncertain answer, because a second
+ *   arrival is a second effect - `dispense()`, `advanceBatch()`, `resetTotaliser()`.
+ *
+ * Undeclared means undeclared. The library will not guess a method is safe to repeat, and will not
+ * pretend a read is dangerous either; what it does instead is refuse to *silently* do anything that
+ * depends on knowing.
+ */
+export type RpcMethodSemantics = 'query' | 'idempotent-command' | 'non-repeatable-command';
+/** Increasing order of what a repeat costs, so a contract change can be judged against it. */
+export declare const SEMANTICS_RISK: {
+    [semantics in RpcMethodSemantics]: number;
+};
+/**
+ * A remote error flattened into something that survives MsgPack/JSON encoding.
+ * An Error instance keeps `message` and `stack` on non-enumerable properties, so encoding one
+ * directly yields an empty object - it has to be copied onto a plain object first.
+ */
+export interface RpcRemoteError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+export declare const toRemoteError: (e: unknown) => RpcRemoteError;
+export interface RpcErrorPayload extends RpcMessage {
+    /** Id of the originating request, so the caller's pending promise can be settled. */
+    id: string;
+    code: RpcErrorCode;
+    error?: RpcRemoteError;
+}
+export interface RpcSuccessPayload extends RpcMessage {
+    id: string;
+    result: unknown;
+}
+export interface RpcEventPayload extends RpcMessage {
+    event: string;
+    params: unknown[];
+    /** Instance the event came from. Lets a wire format name the emitter, as MQTT 5 does. */
+    path?: string;
+}
+//# sourceMappingURL=Messages.d.ts.map

package/dist/RPC/Messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messages.d.ts","sourceRoot":"","sources":["../../src/RPC/Messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC;;;;;GAKG;AAEH,oBAAY,cAAc;IACtB,kBAAkB,SAAS;IAC3B,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;CAClB;AAED,MAAM,WAAW,UAAW,SAAQ,OAAO;IACvC,IAAI,EAAE,cAAc,CAAA;CACvB;AAED,MAAM,WAAW,4BAA6B,SAAQ,UAAU;IAC5D,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,MAAM,YAAY,GAClB,eAAe,GACf,gBAAgB,GAChB,WAAW,GACX,SAAS,GACT,gBAAgB,GAChB,cAAc,GACd,WAAW,GACX,eAAe,GACf,qBAAqB;AACvB;;;;;;;;GAQG;GACD,gBAAgB,CAAA;AAEtB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,oBAAoB,GAAG,wBAAwB,CAAA;AAE1F,8FAA8F;AAC9F,eAAO,MAAM,cAAc,EAAE;KAAG,SAAS,IAAI,kBAAkB,GAAG,MAAM;CAIvE,CAAA;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,aAAa,MAAO,OAAO,KAAG,cAQ1C,CAAA;AAED,MAAM,WAAW,eAAgB,SAAQ,UAAU;IAC/C,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,YAAY,CAAA;IAClB,KAAK,CAAC,EAAE,cAAc,CAAA;CACzB;AACD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACjD,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,OAAO,CAAA;CAClB;AACD,MAAM,WAAW,eAAgB,SAAQ,UAAU;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,EAAE,CAAA;IACjB,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,CAAA;CAChB"}

package/dist/RPC/Messages.js

@@ -0,0 +1,30 @@
+/**
+ * The RPC message vocabulary, in a module of its own because both the handlers and the transports
+ * need it. A transport whose wire format is structured - MQTT 5 carries the method, correlation
+ * and reply address as packet properties - has to know what a call, a result, an error and an
+ * event are in order to map them.
+ */
+export var RpcMessageType;
+(function (RpcMessageType) {
+    RpcMessageType["CallInstanceMethod"] = "POST";
+    RpcMessageType["success"] = "SUCCESS";
+    RpcMessageType["error"] = "ERROR";
+    RpcMessageType["event"] = "EVENT";
+})(RpcMessageType || (RpcMessageType = {}));
+/** Increasing order of what a repeat costs, so a contract change can be judged against it. */
+export const SEMANTICS_RISK = {
+    query: 0,
+    'idempotent-command': 1,
+    'non-repeatable-command': 2
+};
+export const toRemoteError = (e) => {
+    if (e instanceof Error)
+        return { name: e.name, message: e.message, stack: e.stack };
+    if (e && typeof e === 'object') {
+        const candidate = e;
+        if (typeof candidate.message === 'string')
+            return { name: typeof candidate.name === 'string' ? candidate.name : 'Error', message: candidate.message };
+    }
+    return { name: 'Error', message: String(e) };
+};
+//# sourceMappingURL=Messages.js.map

package/dist/RPC/Messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messages.js","sourceRoot":"","sources":["../../src/RPC/Messages.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,MAAM,CAAN,IAAY,cAKX;AALD,WAAY,cAAc;IACtB,6CAA2B,CAAA;IAC3B,qCAAmB,CAAA;IACnB,iCAAe,CAAA;IACf,iCAAe,CAAA;AACnB,CAAC,EALW,cAAc,KAAd,cAAc,QAKzB;AA8ED,8FAA8F;AAC9F,MAAM,CAAC,MAAM,cAAc,GAAkD;IACzE,KAAK,EAAE,CAAC;IACR,oBAAoB,EAAE,CAAC;IACvB,wBAAwB,EAAE,CAAC;CAC9B,CAAA;AAaD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAU,EAAkB,EAAE;IACxD,IAAI,CAAC,YAAY,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAA;IACnF,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,CAA0C,CAAA;QAC5D,IAAI,OAAO,SAAS,CAAC,OAAO,KAAK,QAAQ;YACrC,OAAO,EAAE,IAAI,EAAE,OAAO,SAAS,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,CAAA;IAClH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAA;AAChD,CAAC,CAAA"}

package/dist/RPC/Rpc.d.ts

@@ -0,0 +1,51 @@
+import type { ExposeOptions } from './RpcServerHandler.js';
+/**
+ * The Source RPC port. An unconfigured server listens here, an unconfigured client dials here, and
+ * `source-rpc broker` runs a bus here.
+ *
+ * Having one number rather than three is the whole of the argument: a well-known port is what lets
+ * `mqtt://broker:1883` and `http://bus:7843` both be written from memory, and what makes a port map
+ * in a compose file readable without a comment on each line.
+ *
+ * 7843 rather than anything in the 80xx range, which is where a developer's other work already
+ * lives - 8080, 8081, 8085 are taken on any machine that has been used for a while, and a default
+ * that collides on the laptop is a default nobody keeps. This is quiet ground: high enough to need
+ * no privilege, low enough to stay clear of the ephemeral range, and not the neighbour of anything
+ * that would be mistaken for it.
+ */
+export declare const defaultWebSocketPort = 7843;
+/**
+ * Where anything that serves a browser puts its HTTP port. `source-rpc console` defaults here.
+ *
+ * Adjacent to the RPC port rather than derived by an offset: they are read together, and 7843/7844
+ * is one thing to remember. A single process needs only one of them - the console serves its page
+ * and its RPC on the same listener - so the second number is for running a bus and a console on one
+ * host, which is the ordinary case.
+ */
+export declare const defaultWebPort: number;
+/**
+ * The same two services with TLS: `rpc-tls` and `console-tls`.
+ *
+ * A thousand above their plaintext counterparts, deliberately **not** adjacent to them. The last
+ * two digits still match, so 7843/8843 is one number to remember with a rule attached - but no
+ * range covers both, and `allow 7843:7846` is the rule somebody writes at the end of a long day. A
+ * firewall that meant to publish only the encrypted port should not be able to open the other one
+ * by fencepost. MQTT draws the same line for the same reason, 1883 against 8883, so the habit
+ * transfers.
+ *
+ * These say where to *find* a service, not what any process must do. A port carries TLS because it
+ * was given a certificate, never because of its number - see `--cert`/`--key` in the CLI, which
+ * moves to these ports when it is given the material and stays put when it is not.
+ */
+export declare const defaultSecureWebSocketPort: number;
+export declare const defaultSecureWebPort: number;
+export interface IManageRpc {
+    exposeClassInstance(instance: object, name?: string, options?: number | ExposeOptions): void;
+    exposeClass<T>(constructor: new (...args: unknown[]) => T, aliasName?: string): void;
+    exposeObject(obj: object, name: string): void;
+    expose(methodName: string, method: () => void): void;
+    createRpcInstance(className: string, instanceName?: string, ...args: unknown[]): Promise<string | undefined>;
+}
+export declare const isEventFunction: (prop: string) => prop is "addListener" | "emit" | "getMaxListeners" | "off" | "on" | "once" | "prependListener" | "prependOnceListener" | "removeAllListeners" | "removeListener" | "setMaxListeners";
+export declare const isPromiseFunction: (prop: string) => prop is "catch" | "then";
+//# sourceMappingURL=Rpc.d.ts.map

package/dist/RPC/Rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rpc.d.ts","sourceRoot":"","sources":["../../src/RPC/Rpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,QAA2B,CAAA;AAEtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B,QAA8B,CAAA;AACrE,eAAO,MAAM,oBAAoB,QAAwB,CAAA;AAEzD,MAAM,WAAW,UAAU;IACvB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAAA;IAC5F,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACpF,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7C,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IACpD,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAC/G;AAED,eAAO,MAAM,eAAe,SAAU,MAAM,yLAYd,CAAA;AAE9B,eAAO,MAAM,iBAAiB,SAAU,MAAM,6BAAwC,CAAA"}

package/dist/RPC/Rpc.js

@@ -0,0 +1,54 @@
+/**
+ * The Source RPC port. An unconfigured server listens here, an unconfigured client dials here, and
+ * `source-rpc broker` runs a bus here.
+ *
+ * Having one number rather than three is the whole of the argument: a well-known port is what lets
+ * `mqtt://broker:1883` and `http://bus:7843` both be written from memory, and what makes a port map
+ * in a compose file readable without a comment on each line.
+ *
+ * 7843 rather than anything in the 80xx range, which is where a developer's other work already
+ * lives - 8080, 8081, 8085 are taken on any machine that has been used for a while, and a default
+ * that collides on the laptop is a default nobody keeps. This is quiet ground: high enough to need
+ * no privilege, low enough to stay clear of the ephemeral range, and not the neighbour of anything
+ * that would be mistaken for it.
+ */
+export const defaultWebSocketPort = 7843;
+/**
+ * Where anything that serves a browser puts its HTTP port. `source-rpc console` defaults here.
+ *
+ * Adjacent to the RPC port rather than derived by an offset: they are read together, and 7843/7844
+ * is one thing to remember. A single process needs only one of them - the console serves its page
+ * and its RPC on the same listener - so the second number is for running a bus and a console on one
+ * host, which is the ordinary case.
+ */
+export const defaultWebPort = defaultWebSocketPort + 1;
+/**
+ * The same two services with TLS: `rpc-tls` and `console-tls`.
+ *
+ * A thousand above their plaintext counterparts, deliberately **not** adjacent to them. The last
+ * two digits still match, so 7843/8843 is one number to remember with a rule attached - but no
+ * range covers both, and `allow 7843:7846` is the rule somebody writes at the end of a long day. A
+ * firewall that meant to publish only the encrypted port should not be able to open the other one
+ * by fencepost. MQTT draws the same line for the same reason, 1883 against 8883, so the habit
+ * transfers.
+ *
+ * These say where to *find* a service, not what any process must do. A port carries TLS because it
+ * was given a certificate, never because of its number - see `--cert`/`--key` in the CLI, which
+ * moves to these ports when it is given the material and stays put when it is not.
+ */
+export const defaultSecureWebSocketPort = defaultWebSocketPort + 1000;
+export const defaultSecureWebPort = defaultWebPort + 1000;
+export const isEventFunction = (prop) => prop === 'on' ||
+    prop === 'addListener' ||
+    prop === 'prependListener' ||
+    prop === 'once' ||
+    prop === 'prependOnceListener' ||
+    prop === 'off' ||
+    prop === 'removeListener' ||
+    prop === 'emit' ||
+    prop === 'removeListener' ||
+    prop === 'removeAllListeners' ||
+    prop === 'setMaxListeners' ||
+    prop === 'getMaxListeners';
+export const isPromiseFunction = (prop) => prop === 'then' || prop === 'catch';
+//# sourceMappingURL=Rpc.js.map

package/dist/RPC/Rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rpc.js","sourceRoot":"","sources":["../../src/RPC/Rpc.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAA;AAExC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,GAAG,CAAC,CAAA;AAEtD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,oBAAoB,GAAG,IAAI,CAAA;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,cAAc,GAAG,IAAI,CAAA;AAUzD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,IAAY,EAAE,EAAE,CAC5C,IAAI,KAAK,IAAI;IACb,IAAI,KAAK,aAAa;IACtB,IAAI,KAAK,iBAAiB;IAC1B,IAAI,KAAK,MAAM;IACf,IAAI,KAAK,qBAAqB;IAC9B,IAAI,KAAK,KAAK;IACd,IAAI,KAAK,gBAAgB;IACzB,IAAI,KAAK,MAAM;IACf,IAAI,KAAK,gBAAgB;IACzB,IAAI,KAAK,oBAAoB;IAC7B,IAAI,KAAK,iBAAiB;IAC1B,IAAI,KAAK,iBAAiB,CAAA;AAE9B,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,OAAO,CAAA"}

package/dist/RPC/RpcClientHandler.d.ts

@@ -0,0 +1,129 @@
+import { MessageModule, Message, GenericModule } from './Core.js';
+import { RpcErrorCode, RpcMessage } from './RpcServerHandler.js';
+export declare const defaultCallTimeout = 10000;
+/**
+ * Identifies one subscription: which peer, which exposed instance, which event.
+ *
+ * Handlers used to be registered under the bare event name, so a client watching `alarm` on two
+ * namespaces - or on two peers over one MQTT transport - delivered each event to all of them. An
+ * empty source matches any peer, for a proxy created without a target.
+ */
+export declare const subscriptionKey: (source: string, namespace: string, event: string) => string;
+export declare class RpcError extends Error {
+    code: RpcErrorCode;
+    /** Stack trace from the remote peer, when it sent one. */
+    remoteStack?: string | undefined;
+    constructor(code: RpcErrorCode, message?: string, 
+    /** Stack trace from the remote peer, when it sent one. */
+    remoteStack?: string | undefined);
+}
+export interface RpcClientEmitter extends MessageModule<Message<RpcMessage>, RpcMessage, Message<RpcMessage>, RpcMessage> {
+    on(event: string, handler: (_event: string, params: unknown[]) => void): this;
+    emit(event: string, params: unknown[]): boolean;
+    removeListener(event: string, handler: (params: unknown[]) => void): this;
+}
+export type PromiseResolver<T> = {
+    resolve: (result: T) => void;
+    reject: (reason?: unknown) => void;
+};
+/** What a caller can say about one call that the library cannot work out for itself. */
+export interface RpcCallOptions {
+    /**
+     * Names the command, so a second attempt at it is recognised as the same one.
+     *
+     * The case this exists for: an operator presses "start pump", the answer is `UnknownOutcome`,
+     * and they press it again. Without a key those are two commands and a server with a durable
+     * idempotency store will run both. With one they are two attempts at a command that runs once,
+     * and the second gets the first's answer.
+     *
+     * It has to come from whatever identifies the operator's intent - a work order, a batch step, a
+     * button press id. A value generated per attempt would defeat the purpose, since that is what
+     * the request id already is.
+     */
+    idempotencyKey?: string;
+}
+/** A proxy with per-call options attached. See `$with` on a proxy. */
+export type WithOptions<T> = {
+    $with(options: RpcCallOptions): T;
+};
+export declare class RpcClientHandler extends MessageModule<Message<RpcMessage>, RpcMessage, Message<RpcMessage>, RpcMessage> implements RpcClientEmitter {
+    callTimeout: number;
+    responsePromiseMap: Map<string, PromiseResolver<unknown>>;
+    responseTimeoutMap: Map<string, NodeJS.Timeout>;
+    /** Contract versions this client was built against, by namespace, declared on each call. */
+    schemaVersions?: {
+        [namespace: string]: string | undefined;
+    };
+    /** Remote subscriptions held by this client, replayed by resubscribe() after a reconnect. */
+    subscriptions: Map<string, {
+        remote?: string;
+        instanceName: string;
+        event: string;
+    }>;
+    eventEmitter: {
+        [index: string]: unknown;
+    };
+    constructor(name: string, sources?: GenericModule<unknown, unknown, Message, RpcMessage>[], callTimeout?: number);
+    receive(message: Message<RpcMessage>, source?: string, target?: string): Promise<void>;
+    /**
+     * Routes an event to the handlers registered for that peer and that instance, rather than to
+     * everything listening for the name.
+     */
+    private deliverEvent;
+    /**
+     * Run one subscriber without letting it unwind into the transport that delivered the event.
+     *
+     * These are application callbacks reached from a transport's inbound loop, so a handler that
+     * threw propagated all the way back out and became an unhandled rejection - one subscriber's
+     * bug ending the process for everything else the client was doing.
+     */
+    private deliverSafely;
+    /**
+     * Re-issue every remote subscription this client holds. Called after the transport reconnects:
+     * if the server kept its state the calls are no-ops on its side, and if the server restarted
+     * they rebuild it. Either way the outgoing frames re-identify this client to the server, which
+     * is what makes server-pushed events addressable again.
+     */
+    resubscribe(): Promise<number>;
+    /**
+     * Reject every in-flight call. A reply to a call that was in flight when the link dropped can
+     * no longer reach us, so failing now beats making every caller wait out the full timeout.
+     *
+     * How it failed depends on whether the request got out. One that never left cannot have run, and
+     * `TransportError` says so; one that was published and never answered may have run, and only
+     * `UnknownOutcome` is true of it. Reporting both the same way was the library telling callers
+     * that a command had failed when what it knew was that it had lost track of it.
+     */
+    failPendingCalls(reason: string): void;
+    /**
+     * Requests this client handed to a transport without it complaining.
+     *
+     * Not proof of delivery - nothing here can have that - but proof that the frame left, which is
+     * the line between a command that certainly did not run and one that might have.
+     */
+    private sentRequests;
+    /** Detach a pending call and cancel its timeout. Returns undefined if it already settled. */
+    private takePending;
+    /**
+     * Call a method on the RPC server.
+     * @param method The method to call.
+     * @param additionalParameter The (optional) additionalParameter to include. See the JsonRpc class for more details.
+     * @param params
+     */
+    call(remote: string | undefined, instanceName: string, method: string, ...params: unknown[]): Promise<unknown>;
+    /**
+     * Call with per-call options. `call` is this with none.
+     *
+     * The only option so far is the idempotency key, which is the one thing a caller can say that
+     * the library cannot work out for itself: whether this is a new command or another go at one it
+     * has already sent.
+     */
+    callWith(options: RpcCallOptions, remote: string | undefined, instanceName: string, method: string, ...params: unknown[]): Promise<unknown>;
+    /**
+     * Create a proxy object - a sort of wrapper for calling methods and listening for events.
+     * @param name Name of an existing instance on the server instance. If in the form "name: Class" an instance of type Class will be created
+     * on the server if it does not already exist.
+     */
+    proxy<T>(name: string, remote?: string, options?: RpcCallOptions): T & WithOptions<T>;
+}
+//# sourceMappingURL=RpcClientHandler.d.ts.map

package/dist/RPC/RpcClientHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcClientHandler.d.ts","sourceRoot":"","sources":["../../src/RPC/RpcClientHandler.ts"],"names":[],"mappings":"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"}