@temporary-name/server 1.9.3-alpha.9f176ca3f9388d51e8dffa98a15fcf9f14f6a75e → 1.9.3-alpha.afd18ec2afa743b08cf1b5c2eb6252ded18a1f43

package/dist/adapters/aws-lambda/index.d.mts

@@ -1,22 +1,28 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
-import { S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.mjs';
+import { b as StandardHandlerOptions } from '../../shared/server.C1fnTLq0.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BeuTpcmO.mjs';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
 
-interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+interface AwsLambdaHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, SendStandardResponseOptions {
 }
 type AwsLambdaHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
+/**
+ * OpenAPI Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: AwsLambdaHandlerOptions<T>);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,22 +1,28 @@
 import { MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@temporary-name/standard-server-aws-lambda';
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
-import { S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.js';
+import { b as StandardHandlerOptions } from '../../shared/server.CQyYNJ1H.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.SLLuK6_v.js';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
 
-interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+interface AwsLambdaHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, SendStandardResponseOptions {
 }
 type AwsLambdaHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
+/**
+ * OpenAPI Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class AwsLambdaHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: AwsLambdaHandlerOptions<T>);
     handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
 }
 

package/dist/adapters/aws-lambda/index.mjs

@@ -1,13 +1,23 @@
 import { resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-aws-lambda';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server._YqJjI50.mjs';
+import '@temporary-name/contract';
+import '@temporary-name/server';
+import 'rou3';
+import '@temporary-name/standard-server';
+import '../../shared/server.BKh8I1Ny.mjs';
+import 'node:async_hooks';
+import 'zod';
+import 'zod/v4/core';
+import '../../shared/server.DhdDYN-Z.mjs';
 
 class AwsLambdaHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  sendStandardResponseOptions;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router, options);
     this.sendStandardResponseOptions = options;
   }
-  sendStandardResponseOptions;
   async handle(event, responseStream, ...rest) {
     const standardRequest = toStandardLazyRequest(event, responseStream);
     const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));

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

@@ -1,8 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandlerOptions, c as StandardHandleOptions } from '../../shared/server.C1fnTLq0.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BeuTpcmO.mjs';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
 
@@ -24,15 +24,21 @@ interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHand
     request: Request;
     toFetchResponseOptions: ToFetchResponseOptions;
 }
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions, Omit<StandardHandlerOptions<T>, 'plugins'> {
     adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
     plugins?: FetchHandlerPlugin<T>[];
 }
+/**
+ * OpenAPI Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly toFetchResponseOptions;
     private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 

package/dist/adapters/fetch/index.d.ts

@@ -1,8 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.js';
 import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
 import { ToFetchResponseOptions } from '@temporary-name/standard-server-fetch';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandlerOptions, c as StandardHandleOptions } from '../../shared/server.CQyYNJ1H.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.SLLuK6_v.js';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
 
@@ -24,15 +24,21 @@ interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHand
     request: Request;
     toFetchResponseOptions: ToFetchResponseOptions;
 }
-interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions, Omit<StandardHandlerOptions<T>, 'plugins'> {
     adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
     plugins?: FetchHandlerPlugin<T>[];
 }
+/**
+ * OpenAPI Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
     private readonly toFetchResponseOptions;
     private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 

package/dist/adapters/fetch/index.mjs

@@ -1,10 +1,12 @@
 import { ORPCError, toArray, intercept, resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@temporary-name/standard-server-fetch';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import '@temporary-name/standard-server';
+import { C as CompositeStandardHandlerPlugin, S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server._YqJjI50.mjs';
 import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
+import '@temporary-name/server';
+import 'rou3';
+import '@temporary-name/standard-server';
+import '../../shared/server.BKh8I1Ny.mjs';
+import '../../shared/server.DhdDYN-Z.mjs';
 import 'node:async_hooks';
 import 'zod';
 import 'zod/v4/core';
@@ -136,15 +138,16 @@ class CompositeFetchHandlerPlugin extends CompositeStandardHandlerPlugin {
 }
 
 class FetchHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  toFetchResponseOptions;
+  adapterInterceptors;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router, options);
     const plugin = new CompositeFetchHandlerPlugin(options.plugins);
     plugin.initRuntimeAdapter(options);
     this.adapterInterceptors = toArray(options.adapterInterceptors);
     this.toFetchResponseOptions = options;
   }
-  toFetchResponseOptions;
-  adapterInterceptors;
   async handle(request, ...rest) {
     return intercept(
       this.adapterInterceptors,

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

@@ -1,8 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Bo94xDTv.mjs';
-import { FriendlyStandardHandleOptions } from '../standard/index.mjs';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandlerOptions, c as StandardHandleOptions } from '../../shared/server.C1fnTLq0.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BeuTpcmO.mjs';
 import compression from '@temporary-name/interop/compression';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
@@ -24,15 +24,21 @@ interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardH
     response: NodeHttpResponse;
     sendStandardResponseOptions: SendStandardResponseOptions;
 }
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, Omit<StandardHandlerOptions<T>, 'plugins'> {
     adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
     plugins?: NodeHttpHandlerPlugin<T>[];
 }
+/**
+ * OpenAPI Handler for Node Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
     private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 

package/dist/adapters/node/index.d.ts

@@ -1,8 +1,8 @@
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
+import { C as Context, R as Router } from '../../shared/server.BKSOrA6h.js';
 import { Interceptor, MaybeOptionalOptions } from '@temporary-name/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@temporary-name/standard-server-node';
-import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, S as StandardHandler } from '../../shared/server.Btxrgkj5.js';
-import { FriendlyStandardHandleOptions } from '../standard/index.js';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandlerOptions, c as StandardHandleOptions } from '../../shared/server.CQyYNJ1H.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.SLLuK6_v.js';
 import compression from '@temporary-name/interop/compression';
 import '@temporary-name/contract';
 import '@temporary-name/standard-server';
@@ -24,15 +24,21 @@ interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardH
     response: NodeHttpResponse;
     sendStandardResponseOptions: SendStandardResponseOptions;
 }
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions, Omit<StandardHandlerOptions<T>, 'plugins'> {
     adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
     plugins?: NodeHttpHandlerPlugin<T>[];
 }
+/**
+ * OpenAPI Handler for Node Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-handler OpenAPI Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
     private readonly sendStandardResponseOptions;
     private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    private readonly standardHandler;
+    constructor(router: Router<any, T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 

package/dist/adapters/node/index.mjs

@@ -1,11 +1,13 @@
 import { once, ORPCError, toArray, intercept, resolveMaybeOptionalOptions } from '@temporary-name/shared';
 import compression from '@temporary-name/interop/compression';
 import { toStandardLazyRequest, sendStandardResponse } from '@temporary-name/standard-server-node';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import '@temporary-name/standard-server';
+import { C as CompositeStandardHandlerPlugin, S as StandardHandler, r as resolveFriendlyStandardHandleOptions } from '../../shared/server._YqJjI50.mjs';
 import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
+import '@temporary-name/server';
+import 'rou3';
+import '@temporary-name/standard-server';
+import '../../shared/server.BKh8I1Ny.mjs';
+import '../../shared/server.DhdDYN-Z.mjs';
 import 'node:async_hooks';
 import 'zod';
 import 'zod/v4/core';
@@ -102,15 +104,16 @@ class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
 }
 
 class NodeHttpHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  standardHandler;
+  constructor(router, options = {}) {
+    this.standardHandler = new StandardHandler(router, options);
     const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
     plugin.initRuntimeAdapter(options);
     this.adapterInterceptors = toArray(options.adapterInterceptors);
     this.sendStandardResponseOptions = options;
   }
-  sendStandardResponseOptions;
-  adapterInterceptors;
   async handle(request, response, ...rest) {
     return intercept(
       this.adapterInterceptors,

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

@@ -1,16 +1,88 @@
-import { b as StandardHandleOptions } from '../../shared/server.Bo94xDTv.mjs';
-export { C as CompositeStandardHandlerPlugin, i as StandardCodec, e as StandardHandleResult, S as StandardHandler, c as StandardHandlerInterceptorOptions, d as StandardHandlerOptions, a as StandardHandlerPlugin, g as StandardMatchResult, h as StandardMatcher, f as StandardParams } from '../../shared/server.Bo94xDTv.mjs';
-import { C as Context } from '../../shared/server.C1YnHvvf.mjs';
+export { C as CompositeStandardHandlerPlugin, c as StandardHandleOptions, d as StandardHandleResult, e as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.C1fnTLq0.mjs';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardCodec as StandardCodec$1, StandardParams as StandardParams$1, StandardMatcher as StandardMatcher$1, StandardMatchResult as StandardMatchResult$1 } from '@temporary-name/server/standard';
+import { Segment, ORPCError, HTTPPath } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { h as AnyProcedure$1, f as AnyRouter$1 } from '../../shared/server.BKSOrA6h.mjs';
+export { F as FriendlyStandardHandleOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.BeuTpcmO.mjs';
 import '@temporary-name/contract';
-import '@temporary-name/shared';
-import '@temporary-name/standard-server';
 
-type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+type StandardBracketNotationSerialized = [string, unknown][];
+interface StandardBracketNotationSerializerOptions {
+    /**
+     * Maximum allowed array index for bracket notation deserialization.
+     *
+     * This helps protect against memory exhaustion attacks where malicious input
+     * uses extremely large array indices (e.g., `?arr[4294967296]=value`).
+     *
+     * While bracket notation creates sparse arrays that handle large indices efficiently,
+     * downstream code might inadvertently convert these sparse arrays to dense arrays,
+     * potentially creating millions of undefined elements and causing memory issues.
+     *
+     * @note Only applies to deserialization.
+     * @default 9_999 (array with 10,000 elements)
+     */
+    maxBracketNotationArrayIndex?: number;
+}
+declare class StandardBracketNotationSerializer {
+    private readonly maxArrayIndex;
+    constructor(options?: StandardBracketNotationSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
 
-export { StandardHandleOptions, resolveFriendlyStandardHandleOptions };
-export type { FriendlyStandardHandleOptions };
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+declare class StandardOpenAPIJsonSerializer {
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+declare class StandardOpenAPICodec implements StandardCodec$1 {
+    #private;
+    private readonly serializer;
+    constructor(serializer: StandardOpenAPISerializer);
+    decode(request: StandardLazyRequest, params: StandardParams$1 | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardOpenAPIMatcher implements StandardMatcher$1 {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult$1>;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure$1;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter$1): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure$1): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure$1): Promise<unknown>;
+}
+
+export { StandardOpenAPICodec, StandardOpenAPIMatcher };
+export type { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams };

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

@@ -1,16 +1,88 @@
-import { b as StandardHandleOptions } from '../../shared/server.Btxrgkj5.js';
-export { C as CompositeStandardHandlerPlugin, i as StandardCodec, e as StandardHandleResult, S as StandardHandler, c as StandardHandlerInterceptorOptions, d as StandardHandlerOptions, a as StandardHandlerPlugin, g as StandardMatchResult, h as StandardMatcher, f as StandardParams } from '../../shared/server.Btxrgkj5.js';
-import { C as Context } from '../../shared/server.C1YnHvvf.js';
+export { C as CompositeStandardHandlerPlugin, c as StandardHandleOptions, d as StandardHandleResult, e as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.CQyYNJ1H.js';
+import { AnyProcedure, AnyRouter } from '@temporary-name/server';
+import { StandardCodec as StandardCodec$1, StandardParams as StandardParams$1, StandardMatcher as StandardMatcher$1, StandardMatchResult as StandardMatchResult$1 } from '@temporary-name/server/standard';
+import { Segment, ORPCError, HTTPPath } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { h as AnyProcedure$1, f as AnyRouter$1 } from '../../shared/server.BKSOrA6h.js';
+export { F as FriendlyStandardHandleOptions, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server.SLLuK6_v.js';
 import '@temporary-name/contract';
-import '@temporary-name/shared';
-import '@temporary-name/standard-server';
 
-type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+type StandardBracketNotationSerialized = [string, unknown][];
+interface StandardBracketNotationSerializerOptions {
+    /**
+     * Maximum allowed array index for bracket notation deserialization.
+     *
+     * This helps protect against memory exhaustion attacks where malicious input
+     * uses extremely large array indices (e.g., `?arr[4294967296]=value`).
+     *
+     * While bracket notation creates sparse arrays that handle large indices efficiently,
+     * downstream code might inadvertently convert these sparse arrays to dense arrays,
+     * potentially creating millions of undefined elements and causing memory issues.
+     *
+     * @note Only applies to deserialization.
+     * @default 9_999 (array with 10,000 elements)
+     */
+    maxBracketNotationArrayIndex?: number;
+}
+declare class StandardBracketNotationSerializer {
+    private readonly maxArrayIndex;
+    constructor(options?: StandardBracketNotationSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
 
-export { StandardHandleOptions, resolveFriendlyStandardHandleOptions };
-export type { FriendlyStandardHandleOptions };
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+declare class StandardOpenAPIJsonSerializer {
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+declare class StandardOpenAPICodec implements StandardCodec$1 {
+    #private;
+    private readonly serializer;
+    constructor(serializer: StandardOpenAPISerializer);
+    decode(request: StandardLazyRequest, params: StandardParams$1 | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+declare class StandardOpenAPIMatcher implements StandardMatcher$1 {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult$1>;
+}
+
+type StandardParams = Record<string, string>;
+type StandardMatchResult = {
+    path: readonly string[];
+    procedure: AnyProcedure$1;
+    params?: StandardParams;
+} | undefined;
+interface StandardMatcher {
+    init(router: AnyRouter$1): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure$1): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure$1): Promise<unknown>;
+}
+
+export { StandardOpenAPICodec, StandardOpenAPIMatcher };
+export type { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams };

package/dist/adapters/standard/index.mjs

@@ -1,101 +1,11 @@
-import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, ORPCError, toORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { c as createProcedureClient } from '../../shared/server.BEQrAa3A.mjs';
-import { C as CompositeStandardHandlerPlugin } from '../../shared/server.X0YaZxSJ.mjs';
-export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardOpenAPICodec, b as StandardOpenAPIMatcher, d as decodeParams, r as resolveFriendlyStandardHandleOptions, t as toRou3Pattern } from '../../shared/server._YqJjI50.mjs';
+import '@temporary-name/shared';
+import '@temporary-name/standard-server';
+import '../../shared/server.BKh8I1Ny.mjs';
 import '@temporary-name/contract';
-import '../../shared/server.D6K9uoPI.mjs';
 import 'node:async_hooks';
 import 'zod';
 import 'zod/v4/core';
-
-class StandardHandler {
-  constructor(router, matcher, codec, options) {
-    this.matcher = matcher;
-    this.codec = codec;
-    const plugins = new CompositeStandardHandlerPlugin(options.plugins);
-    plugins.init(options, router);
-    this.interceptors = toArray(options.interceptors);
-    this.clientInterceptors = toArray(options.clientInterceptors);
-    this.rootInterceptors = toArray(options.rootInterceptors);
-    this.matcher.init(router);
-  }
-  interceptors;
-  clientInterceptors;
-  rootInterceptors;
-  async handle(request, options) {
-    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
-    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
-      return { matched: false, response: void 0 };
-    }
-    return intercept(this.rootInterceptors, { ...options, request, prefix }, async (interceptorOptions) => {
-      return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
-        let step;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await runWithSpan(
-                { name: "find_procedure" },
-                () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
-              );
-              if (!match) {
-                return { matched: false, response: void 0 };
-              }
-              span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
-              span?.setAttribute("rpc.system", ORPC_NAME);
-              span?.setAttribute("rpc.method", match.path.join("."));
-              step = "decode_input";
-              let input = await runWithSpan(
-                { name: "decode_input" },
-                () => this.codec.decode(request2, match.params, match.procedure)
-              );
-              step = void 0;
-              if (isAsyncIteratorObject(input)) {
-                input = asyncIteratorWithSpan(
-                  { name: "consume_event_iterator_input", signal: request2.signal },
-                  input
-                );
-              }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request2.signal,
-                lastEventId: flattenHeader(request2.headers["last-event-id"])
-              });
-              step = void 0;
-              const response = this.codec.encode(output, match.procedure);
-              return {
-                matched: true,
-                response
-              };
-            }
-          );
-        } catch (e) {
-          if (step !== "call_procedure") {
-            setSpanError(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 = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
-      });
-    });
-  }
-}
-
-export { CompositeStandardHandlerPlugin, StandardHandler };
+import '../../shared/server.DhdDYN-Z.mjs';
+import '@temporary-name/server';
+import 'rou3';