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

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { c as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, d as StandardHandlerOptions } from '../shared/server.Bo94xDTv.mjs';
-import { C as Context, P as ProcedureClientInterceptorOptions } from '../shared/server.C1YnHvvf.mjs';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.C1fnTLq0.mjs';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.mjs';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { c as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, d as StandardHandlerOptions } from '../shared/server.Btxrgkj5.js';
-import { C as Context, P as ProcedureClientInterceptorOptions } from '../shared/server.C1YnHvvf.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.CQyYNJ1H.js';
+import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.BKSOrA6h.js';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/shared/{server.C1YnHvvf.d.ts → server.BKSOrA6h.d.mts}

@@ -188,5 +188,5 @@ type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as F, Procedure as b, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
-export type { AnyRouter as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, ProcedureClientInterceptorOptions as P, Router as R, AnyProcedure as a, MergedInitialContext as c, MergedCurrentContext as d, MapInputMiddleware as e, CreateProcedureClientOptions as f, ProcedureClient as g, AnyMiddleware as h, Lazy as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
+export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };

package/dist/shared/{server.C1YnHvvf.d.mts → server.BKSOrA6h.d.ts}

@@ -188,5 +188,5 @@ type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as F, Procedure as b, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
-export type { AnyRouter as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, ProcedureClientInterceptorOptions as P, Router as R, AnyProcedure as a, MergedInitialContext as c, MergedCurrentContext as d, MapInputMiddleware as e, CreateProcedureClientOptions as f, ProcedureClient as g, AnyMiddleware as h, Lazy as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+export { isProcedure as D, createProcedureClient as F, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, middlewareOutputFn as y };
+export type { AnyMiddleware as A, ProcedureDef as B, Context as C, ProcedureClientInterceptorOptions as E, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, Middleware as M, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as v, MiddlewareOutputFn as w, MiddlewareOptions as x, ProcedureHandlerOptions as z };

package/dist/shared/{server.BEQrAa3A.mjs → server.BKh8I1Ny.mjs}

@@ -1,7 +1,39 @@
 import { validateORPCError, ValidationError } from '@temporary-name/contract';
 import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { g as gatingContext, w as withoutGatedFields } from './server.D6K9uoPI.mjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import 'zod';
+import * as z4 from 'zod/v4/core';
+
+const gatingContext = new AsyncLocalStorage();
+function withoutGatedFields(data, schema, isGateEnabled) {
+  const filtered = { ...data };
+  const gatedFields = getGatedFields(schema);
+  for (const [fieldName, gate] of gatedFields) {
+    if (!isGateEnabled(gate)) {
+      delete filtered[fieldName];
+    }
+  }
+  return filtered;
+}
+function getGatedFields(schema) {
+  if (!schema || schema["~standard"].vendor !== "zod") {
+    return [];
+  }
+  const gatedFields = [];
+  const zodDef = schema._zod.def;
+  if (zodDef.type === "object") {
+    const shape = zodDef.shape;
+    for (const fieldName in shape) {
+      const fieldSchema = shape[fieldName];
+      const gate = z4.globalRegistry.get(fieldSchema)?.gate;
+      if (gate) {
+        gatedFields.push([fieldName, gate]);
+      }
+    }
+  }
+  return gatedFields;
+}
 
 const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
 function lazy(loader, meta = {}) {
@@ -204,4 +236,4 @@ async function executeProcedureInternal(procedure, options) {
   return next(0, options.context, options.input);
 }
 
-export { LAZY_SYMBOL as L, createORPCErrorConstructorMap as a, middlewareOutputFn as b, createProcedureClient as c, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };
+export { LAZY_SYMBOL as L, gatingContext as a, createORPCErrorConstructorMap as b, createProcedureClient as c, middlewareOutputFn as d, getLazyMeta as g, isLazy as i, lazy as l, mergeCurrentContext as m, unlazy as u };

package/dist/shared/server.BeuTpcmO.d.mts

@@ -0,0 +1,23 @@
+import { HTTPPath } from '@temporary-name/shared';
+import { C as Context } from './server.BKSOrA6h.mjs';
+import { c as StandardHandleOptions } from './server.C1fnTLq0.mjs';
+
+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>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/{server.Btxrgkj5.d.ts → server.C1fnTLq0.d.mts}

@@ -1,7 +1,7 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.js';
+import { HTTPPath, Interceptor } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.BKSOrA6h.mjs';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -13,22 +13,6 @@ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends
     init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
 }
 
-type StandardParams = Record<string, string>;
-type StandardMatchResult = {
-    path: readonly string[];
-    procedure: AnyProcedure;
-    params?: StandardParams;
-} | undefined;
-interface StandardMatcher {
-    init(router: AnyRouter): void;
-    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
-}
-interface StandardCodec {
-    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
-}
-
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;
     context: T;
@@ -60,14 +44,14 @@ interface StandardHandlerOptions<TContext extends Context> {
     clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
-    private readonly matcher;
-    private readonly codec;
     private readonly interceptors;
     private readonly clientInterceptors;
     private readonly rootInterceptors;
-    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    private readonly matcher;
+    private readonly codec;
+    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

package/dist/shared/{server.Bo94xDTv.d.mts → server.CQyYNJ1H.d.ts}

@@ -1,7 +1,7 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, ORPCError, Interceptor } from '@temporary-name/shared';
-import { StandardResponse, StandardLazyRequest } from '@temporary-name/standard-server';
-import { C as Context, R as Router, A as AnyRouter, a as AnyProcedure, P as ProcedureClientInterceptorOptions } from './server.C1YnHvvf.mjs';
+import { HTTPPath, Interceptor } from '@temporary-name/shared';
+import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
+import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.BKSOrA6h.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
@@ -13,22 +13,6 @@ declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends
     init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
 }
 
-type StandardParams = Record<string, string>;
-type StandardMatchResult = {
-    path: readonly string[];
-    procedure: AnyProcedure;
-    params?: StandardParams;
-} | undefined;
-interface StandardMatcher {
-    init(router: AnyRouter): void;
-    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
-}
-interface StandardCodec {
-    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
-}
-
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;
     context: T;
@@ -60,14 +44,14 @@ interface StandardHandlerOptions<TContext extends Context> {
     clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
-    private readonly matcher;
-    private readonly codec;
     private readonly interceptors;
     private readonly clientInterceptors;
     private readonly rootInterceptors;
-    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
+    private readonly matcher;
+    private readonly codec;
+    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as S };
-export type { StandardHandlerPlugin as a, StandardHandleOptions as b, StandardHandlerInterceptorOptions as c, StandardHandlerOptions as d, StandardHandleResult as e, StandardParams as f, StandardMatchResult as g, StandardMatcher as h, StandardCodec as i };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

package/dist/shared/server.DhdDYN-Z.mjs

@@ -0,0 +1,261 @@
+import { isObject, NullProtoObj, isAsyncIteratorObject, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@temporary-name/shared';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+
+class StandardBracketNotationSerializer {
+  maxArrayIndex;
+  constructor(options = {}) {
+    this.maxArrayIndex = options.maxBracketNotationArrayIndex ?? 9999;
+  }
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.serialize(item, [...segments, i], result);
+      });
+    } else if (isObject(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
+      }
+    } else {
+      result.push([this.stringifyPath(segments), data]);
+    }
+    return result;
+  }
+  deserialize(serialized) {
+    if (serialized.length === 0) {
+      return {};
+    }
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
+        }
+        if (i !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment, this.maxArrayIndex)) {
+            if (arrayPushStyles.has(currentRef[nextSegment])) {
+              arrayPushStyles.delete(currentRef[nextSegment]);
+              currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+            } else {
+              currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+            }
+          }
+        } else {
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+              }
+            } else {
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                arrayPushStyles.delete(currentRef[nextSegment]);
+                currentRef[nextSegment] = pushStyleArrayToObject(currentRef[nextSegment]);
+              } else if (!isValidArrayIndex(segment, this.maxArrayIndex)) {
+                currentRef[nextSegment] = arrayToObject(currentRef[nextSegment]);
+              }
+            }
+          }
+        }
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef) && nextSegment === "") {
+        arrayPushStyles.add(currentRef);
+        currentRef.push(value);
+      } else if (nextSegment in currentRef) {
+        if (Array.isArray(currentRef[nextSegment])) {
+          currentRef[nextSegment].push(value);
+        } else {
+          currentRef[nextSegment] = [currentRef[nextSegment], value];
+        }
+      } else {
+        currentRef[nextSegment] = value;
+      }
+    }
+    return ref.value;
+  }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i) => {
+      if (i === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
+  }
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path] : segments;
+  }
+}
+function isValidArrayIndex(value, maxIndex) {
+  return /^0$|^[1-9]\d*$/.test(value) && Number(value) <= maxIndex;
+}
+function arrayToObject(array) {
+  const obj = new NullProtoObj();
+  array.forEach((item, i) => {
+    obj[i] = item;
+  });
+  return obj;
+}
+function pushStyleArrayToObject(array) {
+  const obj = new NullProtoObj();
+  obj[""] = array.length === 1 ? array[0] : array;
+  return obj;
+}
+
+class StandardOpenAPIJsonSerializer {
+  serialize(data, hasBlobRef = { value: false }) {
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json, hasBlobRef.value];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
+    }
+    return [data, hasBlobRef.value];
+  }
+}
+
+class StandardOpenAPISerializer {
+  constructor(jsonSerializer, bracketNotation) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
+  }
+  serialize(data, options = {}) {
+    if (isAsyncIteratorObject(data) && !options.outputFormat) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, { outputFormat: "plain" }),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, options);
+  }
+  #serialize(data, options) {
+    const [json, hasBlob] = this.jsonSerializer.serialize(data);
+    if (options.outputFormat === "plain") {
+      return json;
+    }
+    if (options.outputFormat === "URLSearchParams") {
+      const params = new URLSearchParams();
+      for (const [path, value] of this.bracketNotation.serialize(json)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          params.append(path, value.toString());
+        }
+      }
+      return params;
+    }
+    if (json instanceof Blob || json === void 0 || !hasBlob) {
+      return json;
+    }
+    const form = new FormData();
+    for (const [path, value] of this.bracketNotation.serialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => value,
+        error: async (e) => {
+          if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+            return createORPCErrorFromJson(e.data, { cause: e });
+          }
+          return e;
+        }
+      });
+    }
+    return data;
+  }
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+
+export { StandardBracketNotationSerializer as S, StandardOpenAPISerializer as a, StandardOpenAPIJsonSerializer as b, getDynamicParams as g, standardizeHTTPPath as s };

package/dist/shared/server.SLLuK6_v.d.ts

@@ -0,0 +1,23 @@
+import { HTTPPath } from '@temporary-name/shared';
+import { C as Context } from './server.BKSOrA6h.js';
+import { c as StandardHandleOptions } from './server.CQyYNJ1H.js';
+
+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>;
+/**
+ * {@link https://github.com/unjs/rou3}
+ *
+ * @internal
+ */
+declare function toRou3Pattern(path: HTTPPath): string;
+/**
+ * @internal
+ */
+declare function decodeParams(params: Record<string, string>): Record<string, string>;
+
+export { decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };
+export type { FriendlyStandardHandleOptions as F };