@orpc/server 2.0.0-beta.48 → 2.0.0-beta.49

package/dist/adapters/standard/handler.d.mts

@@ -1,68 +0,0 @@
-import type { ErrorMap, Schema } from "@orpc/contract";
-import type { Interceptor, Promisable, Value } from "@orpc/shared";
-import type { StandardLazyRequest, StandardResponse } from "@standard-server/core";
-import type { Context } from "../../context.mjs";
-import type { ProcedureClientInterceptor } from "../../procedure-client.mjs";
-import type { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.mjs";
-import type { StandardHandlerPlugin } from "./plugin.mjs";
-export interface StandardHandlerHandleOptions<T extends Context> {
-	prefix?: `/${string}` | undefined;
-	/**
-	* The initial context, or a function (sync or async) that receives the request and returns it.
-	* The function only runs once the request passes the prefix check.
-	*/
-	context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-}
-/**
-* `StandardHandlerHandleOptions` after the context has been resolved,
-* this is what interceptors and codecs receive.
-*/
-export interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, "context"> {
-	context: T;
-}
-export type StandardHandlerHandleResult = {
-	matched: true;
-	response: StandardResponse;
-} | {
-	matched: false;
-	response?: undefined;
-};
-export interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
-	request: StandardLazyRequest;
-}
-export type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-export interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
-	request: StandardLazyRequest;
-}
-export type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
-export interface StandardHandlerOptions<TContext extends Context> {
-	/**
-	* Fired on every request before routing, useful when you want
-	* to intercept all requests regardless of whether they match a procedure or not.
-	*
-	* @examples
-	* - batch plugins - separate one request into multiple and call multiple next
-	* - openapi spec plugin - to intercept a request and early response
-	*/
-	routingInterceptors?: StandardHandlerRoutingInterceptor<TContext>[] | undefined;
-	/**
-	* interceptor run after routing and before error handler,
-	* useful for error handling, logging, metrics, etc.
-	*/
-	interceptors?: StandardHandlerInterceptor<TContext>[] | undefined;
-	/**
-	*
-	* ClientInterceptor equivalent with createRouterClient.interceptors / createProcedure.interceptors
-	* useful for error handling, logging, metrics, etc. (not counting encoding/decoding)
-	*/
-	clientInterceptors?: ProcedureClientInterceptor<TContext, Schema<unknown>, ErrorMap>[] | undefined;
-	plugins?: StandardHandlerPlugin<TContext>[] | undefined;
-}
-export declare class StandardHandler<T extends Context> {
-	private readonly codec;
-	private readonly routingInterceptors;
-	private readonly interceptors;
-	private readonly clientInterceptors;
-	constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-	handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
-}

package/dist/adapters/standard/handler.mjs

@@ -1,185 +0,0 @@
-import { ORPCError, toORPCError } from "@orpc/client";
-import { getTracer, intercept, isAsyncIteratorObject, matchesHttpPathPrefix, ORPC_NAME, override, recordSpanError, runWithSpan, toArray, toTracingException, traceAsyncIterator, traceReadableStream, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
-import { ErrorEvent, flattenStandardHeader, parseStandardUrl } from "@standard-server/core";
-import { createProcedureClient } from "../../procedure-client.mjs";
-import { CompositeStandardHandlerPlugin } from "./plugin.mjs";
-export class StandardHandler {
-	codec;
-	routingInterceptors;
-	interceptors;
-	clientInterceptors;
-	constructor(codec, options) {
-		this.codec = codec;
-		options = new CompositeStandardHandlerPlugin([...toArray(options.plugins), new TracingHandlerPlugin()]).init(options);
-		this.routingInterceptors = options.routingInterceptors;
-		this.interceptors = options.interceptors;
-		this.clientInterceptors = options.clientInterceptors;
-	}
-	async handle(request, options) {
-		const { prefix } = options;
-		if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
-			return {
-				matched: false,
-				response: undefined
-			};
-		}
-		const context = await value(options.context, request);
-		return intercept(this.routingInterceptors, {
-			context,
-			prefix,
-			request
-		}, async ({ context, prefix, request }) => {
-			const span = getTracer()?.getActiveSpan();
-			let step;
-			const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request, {
-				context,
-				prefix
-			}));
-			if (!matchedOrNot) {
-				
-				span?.updateName(`${ORPC_NAME}_no_match`);
-				span?.setAttribute("http.request.method", request.method);
-				span?.setAttribute("url.path", request.url);
-				return { matched: false };
-			}
-			const { path, procedure, decodeInput } = matchedOrNot;
-			
-			span?.updateName(`${ORPC_NAME}.${path.join("/")}`);
-			span?.setAttribute("rpc.system", ORPC_NAME);
-			span?.setAttribute("rpc.method", path.join("."));
-			try {
-				const response = await intercept(this.interceptors, {
-					context,
-					prefix,
-					request,
-					path,
-					procedure,
-					decodeInput
-				}, async ({ context, prefix, request, path, procedure, decodeInput }) => {
-					step = "decode_input";
-					let input = await runWithSpan("decode_input", decodeInput);
-					step = undefined;
-					if (getTracer() && isAsyncIteratorObject(input)) {
-						
-						input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
-					} else if (getTracer() && input instanceof ReadableStream) {
-						
-						input = override(input, traceReadableStream("consume_octet_stream_input", input));
-					}
-					const client = createProcedureClient(procedure, {
-						context,
-						path,
-						interceptors: this.clientInterceptors
-					});
-					
-					step = "call_procedure";
-					const output = await client(input, {
-						signal: request.signal,
-						lastEventId: flattenStandardHeader(request.headers["last-event-id"])
-					});
-					step = undefined;
-					const response = await this.codec.encodeOutput(output, procedure, path, {
-						context,
-						prefix
-					});
-					return response;
-				});
-				return {
-					matched: true,
-					response
-				};
-			} catch (e) {
-				
-				if (step !== "call_procedure") {
-					recordSpanError(span, e);
-				}
-				const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
-					message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-					cause: e
-				}) : toORPCError(e);
-				const response = await this.codec.encodeError(error, procedure, path, {
-					context,
-					prefix
-				});
-				return {
-					matched: true,
-					response
-				};
-			}
-		});
-	}
-}
-class TracingHandlerPlugin {
-	name = "~tracing";
-	init(options) {
-		return {
-			...options,
-			routingInterceptors: [async ({ next, request }) => {
-				const tracer = getTracer();
-				if (!tracer) {
-					return next();
-				}
-				const parent = tracer.extract?.(request.headers);
-				
-				const [pathname] = parseStandardUrl(request.url);
-				return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
-					try {
-						const result = await next();
-						if (!result.matched) {
-							span.end();
-							return result;
-						}
-						const body = result.response.body;
-						if (isAsyncIteratorObject(body)) {
-							return {
-								...result,
-								response: {
-									...result.response,
-									
-									body: override(body, wrapAsyncIterator(body, {
-										runWith: (fn) => tracer.withActiveSpan(span, fn),
-										onError(error) {
-											
-											if (!(error instanceof ErrorEvent)) {
-												span.recordException("error", toTracingException(error));
-											}
-										},
-										onFinish() {
-											span.end();
-										}
-									}))
-								}
-							};
-						}
-						if (body instanceof ReadableStream) {
-							return {
-								...result,
-								response: {
-									...result.response,
-									
-									body: override(body, wrapReadableStream(body, {
-										runWith: (fn) => tracer.withActiveSpan(span, fn),
-										onError(error) {
-											
-											span.recordException("error", toTracingException(error));
-										},
-										onFinish() {
-											span.end();
-										}
-									}))
-								}
-							};
-						}
-						span.end();
-						return result;
-					} catch (e) {
-						
-						span.recordException("error", toTracingException(e));
-						span.end();
-						throw e;
-					}
-				});
-			}, ...toArray(options.routingInterceptors)]
-		};
-	}
-}

package/dist/adapters/standard/index.d.mts

@@ -1,6 +0,0 @@
-export * from "./codec.mjs";
-export * from "./handler.mjs";
-export type { StandardHandlerPlugin } from "./plugin.mjs";
-export * from "./rpc-handler-codec.mjs";
-export * from "./rpc-matcher.mjs";
-export * from "./utils.mjs";

package/dist/adapters/standard/index.mjs

@@ -1,5 +0,0 @@
-export * from "./codec.mjs";
-export * from "./handler.mjs";
-export * from "./rpc-handler-codec.mjs";
-export * from "./rpc-matcher.mjs";
-export * from "./utils.mjs";

package/dist/adapters/standard/plugin.d.mts

@@ -1,32 +0,0 @@
-import type { OrderablePlugin } from "@orpc/shared";
-import type { Context } from "../../context.mjs";
-import type { StandardHandlerOptions } from "./handler.mjs";
-export interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
-	/**
-	* Initializes the plugin and returns new handler options.
-	* Called once per plugin instance during composition.
-	*
-	* This method allows plugins to wrap, extend, or transform handler options
-	* such as interceptors, or configuration.
-	*
-	* @param options - The current handler options from previous plugins or base configuration
-	* @returns Transformed handler options with plugin's modifications applied
-	*
-	* @example
-	* ```ts
-	* init(options) {
-	*   return {
-	*     ...options,
-	*     interceptors: [...(options.interceptors || []), myInterceptor]
-	*   }
-	* }
-	* ```
-	*/
-	init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}
-export declare class CompositeStandardHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-	readonly name = "~composite";
-	protected readonly plugins: StandardHandlerPlugin<T>[];
-	constructor(plugins?: StandardHandlerPlugin<T>[]);
-	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
-}

package/dist/adapters/standard/plugin.mjs

@@ -1,16 +0,0 @@
-import { sortPlugins } from "@orpc/shared";
-export class CompositeStandardHandlerPlugin {
-	name = "~composite";
-	plugins;
-	constructor(plugins = []) {
-		this.plugins = sortPlugins(plugins);
-	}
-	init(options) {
-		for (const plugin of this.plugins) {
-			if (plugin.init) {
-				options = plugin.init(options);
-			}
-		}
-		return options;
-	}
-}

package/dist/adapters/standard/rpc-handler-codec.d.mts

@@ -1,42 +0,0 @@
-import type { AnyORPCError } from "@orpc/client";
-import type { Promisable, Public, Value } from "@orpc/shared";
-import type { StandardLazyRequest, StandardResponse } from "@standard-server/core";
-import type { Context } from "../../context.mjs";
-import type { AnyProcedure } from "../../procedure.mjs";
-import type { AnyRouter } from "../../router.mjs";
-import type { ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./index.mjs";
-import type { RPCMatcherOptions } from "./rpc-matcher.mjs";
-import { RPCSerializer } from "@orpc/client";
-export interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
-	/**
-	* Override the default RPC serializer.
-	*/
-	serializer?: Public<RPCSerializer> | undefined;
-	/**
-	* Resolve HTTP status for encoded successful outputs.
-	*
-	* Value should be in the `2xx` range and must be less than `400`.
-	* Return `undefined` or `null` to fallback to default
-	*
-	* @default DEFAULT_SUCCESS_STATUS (200)
-	*/
-	outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>]> | undefined;
-	/**
-	* Mapping ORPCError Code -> HTTP Status Code
-	* The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
-	* Codes missing from the map fall back to `DEFAULT_ERROR_STATUS` (400).
-	*
-	* @default COMMON_ERROR_STATUS_MAP
-	*/
-	errorStatusMap?: Record<string, number> | undefined;
-}
-export declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
-	private readonly matcher;
-	private readonly serializer;
-	private readonly errorStatusMap;
-	private readonly outputStatus;
-	constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
-	resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
-	encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-	encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}

package/dist/adapters/standard/rpc-handler-codec.mjs

@@ -1,51 +0,0 @@
-import { COMMON_ERROR_STATUS_MAP, RPCSerializer } from "@orpc/client";
-import { getOwn, parseEmptyableJSON, value } from "@orpc/shared";
-import { parseStandardUrl } from "@standard-server/core";
-import { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS } from "../../constants.mjs";
-import { RPCMatcher } from "./rpc-matcher.mjs";
-export class RPCHandlerCodec {
-	matcher;
-	serializer;
-	errorStatusMap;
-	outputStatus;
-	constructor(router, options = {}) {
-		this.matcher = new RPCMatcher(router, options);
-		this.serializer = options.serializer ?? new RPCSerializer();
-		this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
-		this.outputStatus = options.outputStatus;
-	}
-	async resolveProcedure(request, options) {
-		const [pathname, query] = parseStandardUrl(request.url);
-		const matched = await this.matcher.match(request.method, pathname, options.prefix);
-		if (!matched) {
-			return undefined;
-		}
-		return {
-			procedure: matched.procedure,
-			path: matched.path,
-			decodeInput: async () => {
-				if (request.method === "GET") {
-					const dataString = new URLSearchParams(query).getAll("data").at(-1);
-					return this.serializer.deserialize(parseEmptyableJSON(dataString));
-				}
-				const body = await request.resolveBody();
-				return this.serializer.deserialize(body);
-			}
-		};
-	}
-	encodeOutput(output, procedure, path, options) {
-		return {
-			headers: {},
-			status: value(this.outputStatus, output, procedure, path, options) ?? DEFAULT_SUCCESS_STATUS,
-			body: this.serializer.serialize(output)
-		};
-	}
-	encodeError(error, _procedure, _path, _options) {
-		const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
-		return {
-			headers: {},
-			status,
-			body: this.serializer.serialize(error.toJSON())
-		};
-	}
-}

package/dist/adapters/standard/rpc-matcher.d.mts

@@ -1,53 +0,0 @@
-import type { AnyProcedureContract } from "@orpc/contract";
-import type { Value } from "@orpc/shared";
-import type { StandardMethod } from "@standard-server/core";
-import type { AnyProcedure } from "../../procedure.mjs";
-import type { AnyRouter } from "../../router.mjs";
-/**
-* Methods that can invoke procedures by default. Browsers cannot trigger them
-* cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
-* `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
-* methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
-* invoke a procedure that can modify data.
-*
-* @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
-*/
-export declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
-export interface RPCMatcherOptions {
-	/**
-	* Filter which procedures are exposed for matching. Return `false` to exclude.
-	*
-	* @default true
-	*/
-	filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
-	/**
-	* Restricts which HTTP methods can invoke procedures, either with a list of allowed
-	* methods or decided per request via a function. Requests using a disallowed method
-	* are treated as unmatched. `GET` is excluded by default because it is exposed to
-	* Cross-Site Request Forgery (CSRF) attacks.
-	*
-	* @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
-	* @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
-	*/
-	allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
-}
-export declare class RPCMatcher {
-	private readonly filter;
-	private readonly allowMethodsSet;
-	private readonly allowMethodsFn;
-	private readonly rootRouter;
-	private readonly tree;
-	private readonly pendingLazyRouters;
-	/** segment count of the deepest pending key, never lowered so it stays an upper bound */
-	private maxPendingLazyRouterDepth;
-	constructor(router: AnyRouter, options?: RPCMatcherOptions);
-	private index;
-	match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
-		path: string[];
-		procedure: AnyProcedure;
-	} | undefined>;
-	private resolvePendingLazyRouters;
-	private loadPendingLazyRouter;
-	private indexPendingLazyRouter;
-	private resolveProcedure;
-}

package/dist/adapters/standard/rpc-matcher.mjs

@@ -1,140 +0,0 @@
-import { normalizeHttpPath, pathToHttpPath, value } from "@orpc/shared";
-import { unlazy } from "../../lazy.mjs";
-import { Procedure } from "../../procedure.mjs";
-import { resolveContractProcedure, walkProcedureContractsSync } from "../../router-utils.mjs";
-
-export const RPC_DEFAULT_ALLOW_METHODS = [
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-];
-
-const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
-export class RPCMatcher {
-	filter;
-	allowMethodsSet;
-	allowMethodsFn;
-	rootRouter;
-	tree = new Map();
-	pendingLazyRouters = new Map();
-	
-	maxPendingLazyRouterDepth = 0;
-	constructor(router, options = {}) {
-		this.filter = options.filter ?? true;
-		const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
-		if (typeof allowMethods !== "function") {
-			this.allowMethodsSet = new Set(allowMethods);
-		} else {
-			this.allowMethodsFn = allowMethods;
-		}
-		this.rootRouter = router;
-		this.index(router);
-	}
-	index(router, path = []) {
-		const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
-			if (!value(this.filter, procedure, procedurePath)) {
-				return;
-			}
-			this.tree.set(pathToHttpPath(procedurePath), {
-				path: procedurePath,
-				contract: procedure,
-				
-				procedure: procedure instanceof Procedure ? procedure : undefined
-			});
-		}, path);
-		for (const result of lazyResults) {
-			this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
-			this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
-		}
-	}
-	async match(method, pathname, prefix) {
-		if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
-			return undefined;
-		}
-		if (prefix) {
-			if (!pathname.startsWith(prefix)) {
-				return undefined;
-			}
-			const charAfterPrefix = pathname[prefix.length];
-			if (charAfterPrefix === "/") {
-				pathname = pathname.slice(prefix.length);
-			} else if (charAfterPrefix === undefined) {
-				pathname = "/";
-			} else if (prefix[prefix.length - 1] === "/") {
-				pathname = pathname.slice(prefix.length - 1);
-			} else {
-				return undefined;
-			}
-		}
-		if (pathname.length > 1 && pathname.endsWith("/")) {
-			pathname = pathname.slice(0, -1);
-		}
-		
-		const loading = this.resolvePendingLazyRouters(pathname);
-		if (loading !== undefined) {
-			await loading;
-		}
-		let entry = this.tree.get(pathname);
-		if (entry === undefined && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
-			
-			
-			
-			const normalizedPathname = normalizeHttpPath(pathname);
-			
-			const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
-			if (normalizedLoading !== undefined) {
-				await normalizedLoading;
-			}
-			entry = this.tree.get(normalizedPathname);
-		}
-		if (entry === undefined) {
-			return undefined;
-		}
-		const procedure = entry.procedure ?? await this.resolveProcedure(entry);
-		if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
-			return undefined;
-		}
-		return {
-			path: entry.path,
-			procedure
-		};
-	}
-	resolvePendingLazyRouters(pathname) {
-		if (this.pendingLazyRouters.size === 0) {
-			return;
-		}
-		let slashIndex = 0;
-		
-		
-		for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
-			const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
-			const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
-			const pending = this.pendingLazyRouters.get(httpPathPrefix);
-			if (pending !== undefined) {
-				return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
-			}
-			slashIndex = nextSlashIndex;
-		}
-	}
-	loadPendingLazyRouter(httpPathPrefix, pending) {
-		if (pending.loading === undefined) {
-			pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
-				pending.loading = undefined;
-				throw error;
-			});
-		}
-		return pending.loading;
-	}
-	async indexPendingLazyRouter(httpPathPrefix, pending) {
-		const { default: router } = await unlazy(pending.router);
-		this.index(router, pending.path);
-		
-		
-		this.pendingLazyRouters.delete(httpPathPrefix);
-	}
-	async resolveProcedure(entry) {
-		entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
-		return entry.procedure;
-	}
-}

package/dist/adapters/standard/utils.d.mts

@@ -1,10 +0,0 @@
-import type { Promisable, Value } from "@orpc/shared";
-import type { StandardLazyRequest } from "@standard-server/core";
-import type { Context } from "../../context.mjs";
-import type { StandardHandlerHandleOptions } from "./handler.mjs";
-export type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, "context"> & (object extends T ? {
-	context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
-} : {
-	context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;

package/dist/adapters/standard/utils.mjs

@@ -1,6 +0,0 @@
-export function resolveFriendlyStandardHandlerHandleOptions(options) {
-	return {
-		...options,
-		context: options.context ?? {}
-	};
-}

package/dist/adapters/standard-peer/index.d.mts

@@ -1 +0,0 @@
-export * from "./utils.mjs";

package/dist/adapters/standard-peer/index.mjs

@@ -1 +0,0 @@
-export * from "./utils.mjs";

package/dist/adapters/standard-peer/utils.mjs

@@ -1,11 +0,0 @@
-import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/index.mjs";
-export function createStandardPeerRequestHandler(handler, options) {
-	return async (request) => {
-		const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
-		return response ?? {
-			status: 404,
-			headers: {},
-			body: "No procedure matched"
-		};
-	};
-}