@zudojs/rpc 1.3.0 → 1.4.0

package/dist/rpc/transport/codec/rpcCodec.helper.js

@@ -0,0 +1,40 @@
+import { createSerializer } from "@zudojs/serialization";
+import { DEFAULT_RPC_HTTP_MAX_BODY_BYTES, MAX_RPC_FRAME_DEPTH, } from "../../constants/rpcConstants.core.js";
+/**
+ * Creates the default frame serializer: `@zudojs/serialization` JSON with
+ * size and depth limits, so decoding an untrusted frame is bounded.
+ */
+export function createRPCJsonSerializer(options = {}) {
+    return createSerializer("json", {
+        maxSize: options.maxSize ?? DEFAULT_RPC_HTTP_MAX_BODY_BYTES,
+        maxDepth: options.maxDepth ?? MAX_RPC_FRAME_DEPTH,
+        preserveTypes: options.preserveTypes ?? false,
+    });
+}
+/**
+ * Determines whether a decoded value has the shape of an
+ * {@link RPCResponse}: a string `id`, a boolean `success`, and — when
+ * present — an `error` with string `code` and `message`.
+ *
+ * Transports check this before handing a peer's reply to the client, so
+ * a proxy's HTML error page or a truncated body is reported as a
+ * transport failure instead of being read as a result.
+ */
+export function isRPCResponseFrame(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const frame = value;
+    if (typeof frame.id !== "string" || typeof frame.success !== "boolean") {
+        return false;
+    }
+    if (frame.success) {
+        return true;
+    }
+    const error = frame.error;
+    return (typeof error === "object" &&
+        error !== null &&
+        typeof error.code === "string" &&
+        typeof error.message === "string");
+}
+//# sourceMappingURL=rpcCodec.helper.js.map

package/dist/rpc/transport/http/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTTP transport over the web-standard Fetch API: a client transport that
+ * POSTs frames with `fetch`, a `(request: Request) => Promise<Response>`
+ * server handler any HTTP server can mount, and the wire-code to HTTP
+ * status map they share.
+ */
+export type { RPCHttpHeaders, RPCHttpTransportOptions, } from "./rpcHttpTransport.core.js";
+export { createRPCHttpTransport } from "./rpcHttpTransport.core.js";
+export type { RPCFetchHandlerOptions } from "./rpcFetchHandler.core.js";
+export { createRPCFetchHandler } from "./rpcFetchHandler.core.js";
+export { RPC_HTTP_STATUS, rpcHttpStatus } from "./rpcHttpStatus.helper.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rpc/transport/http/index.js

@@ -0,0 +1,10 @@
+/**
+ * HTTP transport over the web-standard Fetch API: a client transport that
+ * POSTs frames with `fetch`, a `(request: Request) => Promise<Response>`
+ * server handler any HTTP server can mount, and the wire-code to HTTP
+ * status map they share.
+ */
+export { createRPCHttpTransport } from "./rpcHttpTransport.core.js";
+export { createRPCFetchHandler } from "./rpcFetchHandler.core.js";
+export { RPC_HTTP_STATUS, rpcHttpStatus } from "./rpcHttpStatus.helper.js";
+//# sourceMappingURL=index.js.map

package/dist/rpc/transport/http/rpcFetchHandler.core.d.ts

@@ -0,0 +1,36 @@
+import type { RPCAuthContext } from "../../context/rpcContext.type.js";
+import type { RPCFrameHandler } from "../memory/rpcMemoryTransport.core.js";
+import type { RPCFrameSerializer } from "../codec/rpcCodec.helper.js";
+/** Options for {@link createRPCFetchHandler}. */
+export interface RPCFetchHandlerOptions {
+    /**
+     * Derives trusted identity from the HTTP request (verify a bearer token,
+     * read an mTLS peer, look up a session). The result reaches middleware
+     * and handlers as `context.auth`. Throw an `RPCAuthenticationError` to
+     * refuse the call; any other error is answered as an internal error.
+     */
+    readonly auth?: (request: Request) => RPCAuthContext | undefined | Promise<RPCAuthContext | undefined>;
+    /** Frame serializer. Must match the clients'. Defaults to plain JSON. */
+    readonly serializer?: RPCFrameSerializer;
+    /** Largest request body accepted, in bytes. */
+    readonly maxBodyBytes?: number;
+    /** Receives failures answered with the generic internal error. */
+    readonly onInternalError?: (error: unknown, requestId: string) => void;
+}
+/**
+ * Creates a web-standard handler, `(request: Request) => Promise<Response>`,
+ * that serves an `RPCServer` over HTTP. Mount it on any server that speaks
+ * the Fetch API (`@zudojs/http`, Node's `http` via an adapter, Bun, Deno,
+ * edge runtimes) at one POST endpoint.
+ *
+ * Every reply is an RPC frame: a request that is not POST, not JSON,
+ * oversized, or unparseable is answered with an `RPC_INVALID_REQUEST` or
+ * `RPC_DESERIALIZATION_ERROR` frame, never an HTML page. Stack traces and
+ * internal messages never leave the process — the server replaces them
+ * with `INTERNAL_ERROR_MESSAGE`, and this handler does the same for
+ * failures of its own (a result that cannot be serialized, a throwing
+ * `auth` hook). The call runs under `request.signal`: a client that
+ * disconnects cancels the procedure (its `context.signal` aborts).
+ */
+export declare function createRPCFetchHandler(server: RPCFrameHandler, options?: RPCFetchHandlerOptions): (request: Request) => Promise<Response>;
+//# sourceMappingURL=rpcFetchHandler.core.d.ts.map

package/dist/rpc/transport/http/rpcFetchHandler.core.js

@@ -0,0 +1,97 @@
+import { createRPCJsonSerializer } from "../codec/rpcCodec.helper.js";
+import { readBoundedBody } from "../codec/rpcBody.helper.js";
+import { createRPCErrorResponse } from "../../types/rpcResponse.type.js";
+import { mapRPCError } from "../../server/rpcErrorMapping.helper.js";
+import { DEFAULT_RPC_HTTP_MAX_BODY_BYTES, INTERNAL_ERROR_MESSAGE, MAX_RPC_REQUEST_ID_LENGTH, } from "../../constants/rpcConstants.core.js";
+import { rpcHttpStatus } from "./rpcHttpStatus.helper.js";
+const JSON_TYPE = /^application\/(?:[\w.+-]+\+)?json(?:\s*;|$)/i;
+/**
+ * Creates a web-standard handler, `(request: Request) => Promise<Response>`,
+ * that serves an `RPCServer` over HTTP. Mount it on any server that speaks
+ * the Fetch API (`@zudojs/http`, Node's `http` via an adapter, Bun, Deno,
+ * edge runtimes) at one POST endpoint.
+ *
+ * Every reply is an RPC frame: a request that is not POST, not JSON,
+ * oversized, or unparseable is answered with an `RPC_INVALID_REQUEST` or
+ * `RPC_DESERIALIZATION_ERROR` frame, never an HTML page. Stack traces and
+ * internal messages never leave the process — the server replaces them
+ * with `INTERNAL_ERROR_MESSAGE`, and this handler does the same for
+ * failures of its own (a result that cannot be serialized, a throwing
+ * `auth` hook). The call runs under `request.signal`: a client that
+ * disconnects cancels the procedure (its `context.signal` aborts).
+ */
+export function createRPCFetchHandler(server, options = {}) {
+    const serializer = options.serializer ?? createRPCJsonSerializer();
+    const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_RPC_HTTP_MAX_BODY_BYTES;
+    const reply = (frame, extra) => {
+        let text;
+        let status = rpcHttpStatus(frame);
+        try {
+            text = serializer.serialize(frame);
+        }
+        catch (error) {
+            options.onInternalError?.(error, frame.id);
+            const fallback = createRPCErrorResponse(frame.id, {
+                code: "RPC_SERIALIZATION_ERROR",
+                message: INTERNAL_ERROR_MESSAGE,
+            });
+            text = serializer.serialize(fallback);
+            status = rpcHttpStatus(fallback);
+        }
+        return new Response(text, {
+            status,
+            headers: {
+                "content-type": "application/json; charset=utf-8",
+                "cache-control": "no-store",
+                "x-content-type-options": "nosniff",
+                ...extra,
+            },
+        });
+    };
+    const refuse = (code, message, extra) => reply(createRPCErrorResponse("", { code, message }), extra);
+    return async (request) => {
+        if (request.method !== "POST") {
+            return refuse("RPC_INVALID_REQUEST", "RPC requests must use POST.", { allow: "POST" });
+        }
+        if (!JSON_TYPE.test(request.headers.get("content-type") ?? "")) {
+            return refuse("RPC_INVALID_REQUEST", "RPC requests must be sent as application/json.");
+        }
+        const body = await readBoundedBody(request, maxBodyBytes);
+        if (!body.ok) {
+            return refuse("RPC_INVALID_REQUEST", body.reason === "too-large"
+                ? `RPC request body exceeds ${maxBodyBytes} bytes.`
+                : "RPC request body could not be read.");
+        }
+        let frame;
+        try {
+            frame = serializer.deserialize(body.text);
+        }
+        catch {
+            return refuse("RPC_DESERIALIZATION_ERROR", "RPC request body is not valid JSON.");
+        }
+        const frameId = readFrameId(frame);
+        let auth;
+        try {
+            auth = await options.auth?.(request);
+        }
+        catch (error) {
+            const mapped = mapRPCError(error);
+            if (mapped.internal) {
+                options.onInternalError?.(error, frameId);
+            }
+            return reply(createRPCErrorResponse(frameId, mapped.payload));
+        }
+        const response = await server.handle(frame, auth === undefined ? { signal: request.signal } : { auth, signal: request.signal });
+        return reply(response);
+    };
+}
+/**
+ * Reads a frame's id for error replies built before the server has
+ * validated the frame. Only a short, safe id is echoed, so the handler
+ * never reflects arbitrary caller input.
+ */
+function readFrameId(frame) {
+    const id = frame?.id;
+    return typeof id === "string" && id.length <= MAX_RPC_REQUEST_ID_LENGTH && /^[\w.:-]+$/.test(id) ? id : "";
+}
+//# sourceMappingURL=rpcFetchHandler.core.js.map

package/dist/rpc/transport/http/rpcHttpExchange.helper.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Request encoding, fetch error typing and response decoding for
+ * `createRPCHttpTransport`.
+ */
+import type { RPCRequest } from "../../types/rpcRequest.type.js";
+import type { RPCResponse } from "../../types/rpcResponse.type.js";
+import type { RPCTransportRequestOptions } from "../rpcTransport.type.js";
+import type { RPCFrameSerializer } from "../codec/rpcCodec.helper.js";
+/**
+ * Links the caller signal and the deadline into one abort signal.
+ *
+ * The deadline is clamped to the timer range, as the client's own timer
+ * is: `AbortSignal.timeout` fires after 1 ms for anything past 2^31-1 ms
+ * (about 24.8 days) and throws for a non-integer beyond 2^32-1, so a long
+ * or `Infinity` timeout used to fail every call at once.
+ */
+export declare function linkSignals(options: RPCTransportRequestOptions): {
+    readonly signal: AbortSignal;
+    dispose(): void;
+};
+/** Runs the fetch, typing a failure as transport, timeout or cancellation. */
+export declare function fetchOrThrow(run: () => Promise<Response>, signal: AbortSignal, options: RPCTransportRequestOptions, procedure: string): Promise<Response>;
+/** Serializes a request frame. */
+export declare function encode(serializer: RPCFrameSerializer, request: RPCRequest): string;
+/** Reads, parses and shape-checks the reply to `request`. */
+export declare function decode(serializer: RPCFrameSerializer, response: Response, maxBytes: number, request: RPCRequest): Promise<RPCResponse>;
+//# sourceMappingURL=rpcHttpExchange.helper.d.ts.map

package/dist/rpc/transport/http/rpcHttpExchange.helper.js

@@ -0,0 +1,78 @@
+/**
+ * Request encoding, fetch error typing and response decoding for
+ * `createRPCHttpTransport`.
+ */
+import { isRPCResponseFrame } from "../codec/rpcCodec.helper.js";
+import { readBoundedBody } from "../codec/rpcBody.helper.js";
+import { RPCSerializationError, RPCTimeoutError, RPCTransportError, } from "../../errors/rpc.errors.js";
+import { combineSignals } from "../../reliability/cancellation/rpcCancellation.helper.js";
+import { abortReasonToRPCError } from "../../reliability/cancellation/rpcAbort.helper.js";
+import { MAX_TIMER_DELAY } from "../../constants/rpcConstants.core.js";
+/**
+ * Links the caller signal and the deadline into one abort signal.
+ *
+ * The deadline is clamped to the timer range, as the client's own timer
+ * is: `AbortSignal.timeout` fires after 1 ms for anything past 2^31-1 ms
+ * (about 24.8 days) and throws for a non-integer beyond 2^32-1, so a long
+ * or `Infinity` timeout used to fail every call at once.
+ */
+export function linkSignals(options) {
+    const timeout = options.timeout;
+    const deadline = timeout !== undefined && timeout > 0
+        ? AbortSignal.timeout(Math.min(Math.ceil(timeout), MAX_TIMER_DELAY))
+        : undefined;
+    return combineSignals(options.signal, deadline);
+}
+/** Runs the fetch, typing a failure as transport, timeout or cancellation. */
+export async function fetchOrThrow(run, signal, options, procedure) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (!signal.aborted) {
+            throw withCause(new RPCTransportError("RPC HTTP request failed.", procedure), error);
+        }
+        if (options.signal?.aborted) {
+            throw abortReasonToRPCError(options.signal, procedure);
+        }
+        throw new RPCTimeoutError(options.timeout ?? 0, procedure);
+    }
+}
+/** Serializes a request frame. */
+export function encode(serializer, request) {
+    try {
+        return serializer.serialize(request);
+    }
+    catch (error) {
+        throw withCause(new RPCSerializationError("RPC request could not be serialized.", request.procedure), error);
+    }
+}
+/** Reads, parses and shape-checks the reply to `request`. */
+export async function decode(serializer, response, maxBytes, request) {
+    const read = await readBoundedBody(response, maxBytes);
+    const failure = (detail) => new RPCTransportError(`RPC server replied with HTTP ${response.status} and ${detail}.`, request.procedure);
+    if (!read.ok) {
+        throw failure(read.reason === "too-large" ? "an oversized body" : "an unreadable body");
+    }
+    let frame;
+    try {
+        frame = serializer.deserialize(read.text);
+    }
+    catch {
+        throw failure("a body that is not valid JSON");
+    }
+    if (!isRPCResponseFrame(frame) || (frame.id !== request.id && frame.id !== "")) {
+        throw failure("a body that is not a response to this request");
+    }
+    return frame;
+}
+function withCause(error, cause) {
+    Object.defineProperty(error, "cause", {
+        value: cause,
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+    return error;
+}
+//# sourceMappingURL=rpcHttpExchange.helper.js.map

package/dist/rpc/transport/http/rpcHttpStatus.helper.d.ts

@@ -0,0 +1,16 @@
+import type { RPCResponse } from "../../types/rpcResponse.type.js";
+/**
+ * HTTP status used by {@link createRPCFetchHandler} for each wire code.
+ *
+ * The status is advisory — for proxies, logs and dashboards. The frame's
+ * `error.code` is authoritative, and {@link createRPCHttpTransport} reads
+ * any well-formed frame whatever status it arrives with. Codes not listed
+ * here (custom `RPCError` codes) are sent as 500.
+ */
+export declare const RPC_HTTP_STATUS: Readonly<Record<string, number>>;
+/**
+ * Returns the HTTP status for a response frame: 200 for success, the
+ * mapped status for a known error code, and 500 otherwise.
+ */
+export declare function rpcHttpStatus(response: RPCResponse): number;
+//# sourceMappingURL=rpcHttpStatus.helper.d.ts.map

package/dist/rpc/transport/http/rpcHttpStatus.helper.js

@@ -0,0 +1,37 @@
+/**
+ * HTTP status used by {@link createRPCFetchHandler} for each wire code.
+ *
+ * The status is advisory — for proxies, logs and dashboards. The frame's
+ * `error.code` is authoritative, and {@link createRPCHttpTransport} reads
+ * any well-formed frame whatever status it arrives with. Codes not listed
+ * here (custom `RPCError` codes) are sent as 500.
+ */
+export const RPC_HTTP_STATUS = Object.freeze({
+    RPC_INVALID_REQUEST: 400,
+    RPC_DESERIALIZATION_ERROR: 400,
+    RPC_UNAUTHENTICATED: 401,
+    RPC_FORBIDDEN: 403,
+    RPC_PROCEDURE_NOT_FOUND: 404,
+    RPC_NOT_FOUND: 404,
+    RPC_CONFLICT: 409,
+    RPC_VALIDATION_ERROR: 422,
+    RPC_RATE_LIMITED: 429,
+    RPC_CANCELLED: 499,
+    RPC_INTERNAL_ERROR: 500,
+    RPC_SERIALIZATION_ERROR: 500,
+    RPC_UNAVAILABLE: 503,
+    RPC_TIMEOUT: 504,
+    RPC_DEADLINE_EXCEEDED: 504,
+});
+/**
+ * Returns the HTTP status for a response frame: 200 for success, the
+ * mapped status for a known error code, and 500 otherwise.
+ */
+export function rpcHttpStatus(response) {
+    if (response.success) {
+        return 200;
+    }
+    const code = response.error?.code;
+    return (code !== undefined ? RPC_HTTP_STATUS[code] : undefined) ?? 500;
+}
+//# sourceMappingURL=rpcHttpStatus.helper.js.map

package/dist/rpc/transport/http/rpcHttpTransport.core.d.ts

@@ -0,0 +1,36 @@
+import type { RPCRequest } from "../../types/rpcRequest.type.js";
+import type { RPCTransport } from "../rpcTransport.type.js";
+import type { RPCFrameSerializer } from "../codec/rpcCodec.helper.js";
+/** Headers accepted by the `Headers` constructor. */
+export type RPCHttpHeaders = ConstructorParameters<typeof Headers>[0];
+/**
+ * Options for {@link createRPCHttpTransport}.
+ */
+export interface RPCHttpTransportOptions {
+    /** Endpoint the server's fetch handler is mounted on. */
+    readonly url: string | URL;
+    /**
+     * Extra request headers — a fixed set, or a function called per request
+     * (for a short-lived bearer token). They cannot replace `content-type`.
+     */
+    readonly headers?: RPCHttpHeaders | ((request: RPCRequest) => RPCHttpHeaders | Promise<RPCHttpHeaders>);
+    /** Fetch implementation. Defaults to the global `fetch`. */
+    readonly fetch?: (input: string | URL, init: RequestInit) => Promise<Response>;
+    /** Frame serializer. Must match the server's. Defaults to plain JSON. */
+    readonly serializer?: RPCFrameSerializer;
+    /** Largest response body accepted, in bytes. */
+    readonly maxResponseBytes?: number;
+}
+/**
+ * Creates a transport that POSTs each frame to a remote
+ * {@link createRPCFetchHandler} with the global `fetch`.
+ *
+ * The client's signal and deadline (`options.timeout`) both abort the
+ * underlying request, so a timed-out call releases its connection.
+ * Failures are typed: a network error or a reply that is not an RPC frame
+ * is an `RPCTransportError`, an expired deadline an `RPCTimeoutError`, a
+ * caller abort an `RPCCancelledError`. An error frame from the server is
+ * returned as a response for the client to rebuild into a typed error.
+ */
+export declare function createRPCHttpTransport(options: RPCHttpTransportOptions): RPCTransport;
+//# sourceMappingURL=rpcHttpTransport.core.d.ts.map

package/dist/rpc/transport/http/rpcHttpTransport.core.js

@@ -0,0 +1,45 @@
+import { createRPCJsonSerializer } from "../codec/rpcCodec.helper.js";
+import { RPCUnavailableError } from "../../errors/rpc.errors.js";
+import { DEFAULT_RPC_HTTP_MAX_BODY_BYTES } from "../../constants/rpcConstants.core.js";
+import { decode, encode, fetchOrThrow, linkSignals } from "./rpcHttpExchange.helper.js";
+/**
+ * Creates a transport that POSTs each frame to a remote
+ * {@link createRPCFetchHandler} with the global `fetch`.
+ *
+ * The client's signal and deadline (`options.timeout`) both abort the
+ * underlying request, so a timed-out call releases its connection.
+ * Failures are typed: a network error or a reply that is not an RPC frame
+ * is an `RPCTransportError`, an expired deadline an `RPCTimeoutError`, a
+ * caller abort an `RPCCancelledError`. An error frame from the server is
+ * returned as a response for the client to rebuild into a typed error.
+ */
+export function createRPCHttpTransport(options) {
+    const serializer = options.serializer ?? createRPCJsonSerializer();
+    const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_RPC_HTTP_MAX_BODY_BYTES;
+    const url = new URL(options.url);
+    let closed = false;
+    return {
+        async send(request, sendOptions = {}) {
+            if (closed) {
+                throw new RPCUnavailableError("RPC HTTP transport has been closed.", request.procedure);
+            }
+            const body = encode(serializer, request);
+            const signals = linkSignals(sendOptions);
+            try {
+                const headers = new Headers(typeof options.headers === "function" ? await options.headers(request) : options.headers);
+                headers.set("content-type", "application/json");
+                headers.set("accept", "application/json");
+                const response = await fetchOrThrow(() => doFetch(url, { method: "POST", headers, body, signal: signals.signal }), signals.signal, sendOptions, request.procedure);
+                return await decode(serializer, response, maxResponseBytes, request);
+            }
+            finally {
+                signals.dispose();
+            }
+        },
+        async close() {
+            closed = true;
+        },
+    };
+}
+//# sourceMappingURL=rpcHttpTransport.core.js.map

package/dist/rpc/transport/index.d.ts

@@ -1,2 +1,14 @@
+/**
+ * RPC transports: the {@link RPCTransport} contract an `RPCClient` sends
+ * through, plus the built-in implementations — in-memory for tests and
+ * modular monoliths, and HTTP (client transport and server fetch handler)
+ * built on the web-standard Fetch API.
+ */
 export type { RPCTransport, RPCTransportRequestOptions, } from "./rpcTransport.type.js";
+export type { RPCFrameSerializer, RPCJsonSerializerOptions, RPCBodyReadResult, RPCBodySource, } from "./codec/index.js";
+export { createRPCJsonSerializer, isRPCResponseFrame, readBoundedBody, } from "./codec/index.js";
+export type { RPCFrameHandler, RPCMemoryTransportOptions, } from "./memory/index.js";
+export { createRPCMemoryTransport } from "./memory/index.js";
+export type { RPCHttpHeaders, RPCHttpTransportOptions, RPCFetchHandlerOptions, } from "./http/index.js";
+export { createRPCHttpTransport, createRPCFetchHandler, RPC_HTTP_STATUS, rpcHttpStatus, } from "./http/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/rpc/transport/index.js

@@ -1,2 +1,10 @@
-export {};
+/**
+ * RPC transports: the {@link RPCTransport} contract an `RPCClient` sends
+ * through, plus the built-in implementations — in-memory for tests and
+ * modular monoliths, and HTTP (client transport and server fetch handler)
+ * built on the web-standard Fetch API.
+ */
+export { createRPCJsonSerializer, isRPCResponseFrame, readBoundedBody, } from "./codec/index.js";
+export { createRPCMemoryTransport } from "./memory/index.js";
+export { createRPCHttpTransport, createRPCFetchHandler, RPC_HTTP_STATUS, rpcHttpStatus, } from "./http/index.js";
 //# sourceMappingURL=index.js.map

package/dist/rpc/transport/memory/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * In-process transport: connects an `RPCClient` to an `RPCServer` in the
+ * same process, serializing frames across the boundary by default.
+ */
+export type { RPCFrameHandler, RPCMemoryTransportOptions, } from "./rpcMemoryTransport.core.js";
+export { createRPCMemoryTransport } from "./rpcMemoryTransport.core.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rpc/transport/memory/index.js

@@ -0,0 +1,6 @@
+/**
+ * In-process transport: connects an `RPCClient` to an `RPCServer` in the
+ * same process, serializing frames across the boundary by default.
+ */
+export { createRPCMemoryTransport } from "./rpcMemoryTransport.core.js";
+//# sourceMappingURL=index.js.map

package/dist/rpc/transport/memory/rpcMemoryTransport.core.d.ts

@@ -0,0 +1,42 @@
+import type { RPCRequest } from "../../types/rpcRequest.type.js";
+import type { RPCResponse } from "../../types/rpcResponse.type.js";
+import type { RPCAuthContext, RPCContextOptions } from "../../context/rpcContext.type.js";
+import type { RPCTransport } from "../rpcTransport.type.js";
+import type { RPCFrameSerializer } from "../codec/rpcCodec.helper.js";
+/**
+ * The part of an `RPCServer` a transport delivers frames to.
+ */
+export interface RPCFrameHandler {
+    handle(request: RPCRequest, trusted?: RPCContextOptions): Promise<RPCResponse>;
+}
+/**
+ * Options for {@link createRPCMemoryTransport}.
+ */
+export interface RPCMemoryTransportOptions {
+    /**
+     * Trusted identity handed to the server as `context.auth` — a fixed
+     * value, or a function of the request. This is what an HTTP transport
+     * would derive from a verified credential; in memory the caller's own
+     * code supplies it.
+     */
+    readonly auth?: RPCAuthContext | ((request: RPCRequest) => RPCAuthContext | undefined | Promise<RPCAuthContext | undefined>);
+    /**
+     * How frames cross the boundary. By default each request and response is
+     * round-tripped through a JSON serializer, so the server can never see or
+     * mutate the caller's objects and a payload that could not travel over a
+     * network fails here too. Pass another serializer to match a remote
+     * transport, or `false` to pass frames by reference.
+     */
+    readonly serializer?: RPCFrameSerializer | false;
+}
+/**
+ * Creates a transport that delivers frames to a server in the same
+ * process — for tests, and for modular monoliths that may later split a
+ * module into its own service without touching callers.
+ *
+ * Honours `options.signal`: an aborted call stops waiting at once and the
+ * server's dispatch is cancelled with it. After `close()` every send fails
+ * with `RPCUnavailableError`.
+ */
+export declare function createRPCMemoryTransport(server: RPCFrameHandler, options?: RPCMemoryTransportOptions): RPCTransport;
+//# sourceMappingURL=rpcMemoryTransport.core.d.ts.map

package/dist/rpc/transport/memory/rpcMemoryTransport.core.js

@@ -0,0 +1,73 @@
+import { createRPCJsonSerializer } from "../codec/rpcCodec.helper.js";
+import { createRPCErrorResponse } from "../../types/rpcResponse.type.js";
+import { RPCSerializationError, RPCUnavailableError, } from "../../errors/rpc.errors.js";
+import { INTERNAL_ERROR_MESSAGE } from "../../constants/rpcConstants.core.js";
+import { raceAbort } from "../../reliability/cancellation/rpcAbort.helper.js";
+/**
+ * Creates a transport that delivers frames to a server in the same
+ * process — for tests, and for modular monoliths that may later split a
+ * module into its own service without touching callers.
+ *
+ * Honours `options.signal`: an aborted call stops waiting at once and the
+ * server's dispatch is cancelled with it. After `close()` every send fails
+ * with `RPCUnavailableError`.
+ */
+export function createRPCMemoryTransport(server, options = {}) {
+    const serializer = options.serializer === false
+        ? undefined
+        : (options.serializer ?? createRPCJsonSerializer());
+    let closed = false;
+    const resolveAuth = async (request) => typeof options.auth === "function" ? options.auth(request) : options.auth;
+    return {
+        async send(request, sendOptions = {}) {
+            if (closed) {
+                throw new RPCUnavailableError("RPC memory transport has been closed.", request.procedure);
+            }
+            const frame = copy(serializer, request, request.procedure);
+            const exchange = async () => {
+                const auth = await resolveAuth(request);
+                const signal = sendOptions.signal;
+                const response = await server.handle(frame, {
+                    ...(auth === undefined ? {} : { auth }),
+                    ...(signal === undefined ? {} : { signal }),
+                });
+                return copyResponse(serializer, response);
+            };
+            return raceAbort(exchange(), sendOptions.signal, request.procedure);
+        },
+        async close() {
+            closed = true;
+        },
+    };
+}
+function copy(serializer, value, procedure) {
+    if (serializer === undefined) {
+        return value;
+    }
+    try {
+        return serializer.deserialize(serializer.serialize(value));
+    }
+    catch {
+        throw new RPCSerializationError("RPC request could not be serialized.", procedure);
+    }
+}
+/**
+ * A response the server produced but that cannot cross the boundary (a
+ * `BigInt` result under plain JSON, a cycle) is answered the way a
+ * network transport would: a generic internal error frame.
+ */
+function copyResponse(serializer, response) {
+    if (serializer === undefined) {
+        return response;
+    }
+    try {
+        return serializer.deserialize(serializer.serialize(response));
+    }
+    catch {
+        return createRPCErrorResponse(response.id, {
+            code: "RPC_SERIALIZATION_ERROR",
+            message: INTERNAL_ERROR_MESSAGE,
+        });
+    }
+}
+//# sourceMappingURL=rpcMemoryTransport.core.js.map

package/dist/rpc/validation/rpcUnsafeKey.helper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Detection of prototype-polluting keys in decoded, untrusted data.
+ */
+/**
+ * Returns the first `__proto__`, `constructor` or `prototype` key found
+ * anywhere in `value`, or `undefined` when there is none.
+ *
+ * `JSON.parse` keeps such a key as an ordinary own property, so it reaches
+ * handlers intact; the moment one is copied with `Object.assign`, a
+ * `for…in` merge or a bracket assignment, it replaces the target's
+ * prototype. Transports refuse a frame that carries one rather than
+ * silently dropping it.
+ *
+ * Walks plain objects and arrays only, iteratively (no recursion limit)
+ * and cycle-safe, so it is safe on any decoded or in-process value.
+ */
+export declare function findUnsafeKey(value: unknown): string | undefined;
+//# sourceMappingURL=rpcUnsafeKey.helper.d.ts.map