@temporary-name/server 1.9.3-alpha.03e17aa3340f4b261a549bf9e3fe948b084e2309

package/dist/shared/server.BKh8I1Ny.mjs

@@ -0,0 +1,239 @@
+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 { 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 = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+function mergeCurrentContext(context, other) {
+  return { ...context, ...other };
+}
+
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...rest) => {
+        const options = resolveMaybeOptionalOptions(rest);
+        const config = errors[code];
+        return new ORPCError(code, {
+          defined: Boolean(config),
+          status: config?.status,
+          message: options.message ?? config?.message,
+          data: options.data,
+          cause: options.cause
+        });
+      };
+      return item;
+    }
+  });
+  return proxy;
+}
+
+function middlewareOutputFn(output) {
+  return { output, context: {} };
+}
+
+function createProcedureClient(lazyableProcedure, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  return async (...[input, callerOptions]) => {
+    const path = toArray(options.path);
+    const { default: procedure } = await unlazy(lazyableProcedure);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options.context ?? {}, clientContext);
+    const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+    const validateError = async (e) => {
+      if (e instanceof ORPCError) {
+        return await validateORPCError(procedure["~orpc"].errorMap, e);
+      }
+      return e;
+    };
+    try {
+      const output = await runWithSpan({ name: "call_procedure", signal: callerOptions?.signal }, (span) => {
+        span?.setAttribute("procedure.path", [...path]);
+        return intercept(
+          toArray(options.interceptors),
+          {
+            context,
+            input,
+            // input only optional when it undefinable so we can safely cast it
+            errors,
+            path,
+            procedure,
+            signal: callerOptions?.signal,
+            lastEventId: callerOptions?.lastEventId
+          },
+          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+        );
+      });
+      if (isAsyncIteratorObject(output)) {
+        if (output instanceof HibernationEventIterator) {
+          return output;
+        }
+        return overlayProxy(
+          output,
+          mapEventIterator(
+            asyncIteratorWithSpan(
+              { name: "consume_event_iterator_output", signal: callerOptions?.signal },
+              output
+            ),
+            {
+              value: (v) => v,
+              error: (e) => validateError(e)
+            }
+          )
+        );
+      }
+      return output;
+    } catch (e) {
+      throw await validateError(e);
+    }
+  };
+}
+async function validateInput(procedure, input) {
+  const schema = procedure["~orpc"].inputSchema;
+  if (!schema) {
+    return input;
+  }
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const result = await schema["~standard"].validate(input);
+    if (result.issues) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "Input validation failed",
+        data: {
+          issues: result.issues
+        },
+        cause: new ValidationError({
+          message: "Input validation failed",
+          issues: result.issues,
+          data: input
+        })
+      });
+    }
+    return result.value;
+  });
+}
+async function validateOutput(schema, output) {
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await schema["~standard"].validate(output);
+    if (result.issues) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Output validation failed",
+        cause: new ValidationError({
+          message: "Output validation failed",
+          issues: result.issues,
+          data: output
+        })
+      });
+    }
+    return result.value;
+  });
+}
+async function executeProcedureInternal(procedure, options) {
+  const middlewares = procedure["~orpc"].middlewares;
+  const inputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].inputValidationIndex),
+    middlewares.length
+  );
+  const outputValidationIndex = Math.min(
+    Math.max(0, procedure["~orpc"].outputValidationIndex),
+    middlewares.length
+  );
+  const next = async (index, context, input) => {
+    let currentInput = input;
+    if (index === inputValidationIndex) {
+      currentInput = await validateInput(procedure, currentInput);
+    }
+    const mid = middlewares[index];
+    const output = mid ? await runWithSpan({ name: `middleware.${mid.name}`, signal: options.signal }, async (span) => {
+      span?.setAttribute("middleware.index", index);
+      span?.setAttribute("middleware.name", mid.name);
+      const result = await mid(
+        {
+          ...options,
+          context,
+          next: async (...[nextOptions]) => {
+            const nextContext = nextOptions?.context ?? {};
+            return {
+              output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              context: nextContext
+            };
+          }
+        },
+        currentInput,
+        middlewareOutputFn
+      );
+      return result.output;
+    }) : await runWithSpan(
+      { name: "handler", signal: options.signal },
+      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+    );
+    if (index === outputValidationIndex) {
+      const schema = procedure["~orpc"].outputSchema;
+      if (!schema) {
+        return output;
+      }
+      const validated = await validateOutput(schema, output);
+      const isGateEnabled = gatingContext.getStore();
+      if (!validated || !isGateEnabled) {
+        return validated;
+      }
+      return withoutGatedFields(validated, schema, isGateEnabled);
+    }
+    return output;
+  };
+  return next(0, options.context, options.input);
+}
+
+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.C1fnTLq0.d.mts

@@ -0,0 +1,57 @@
+import { Meta } from '@temporary-name/contract';
+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;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    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 e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

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

@@ -0,0 +1,57 @@
+import { Meta } from '@temporary-name/contract';
+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;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+interface StandardHandleOptions<T extends Context> {
+    prefix?: HTTPPath;
+    context: T;
+}
+type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: StandardLazyRequest;
+}
+interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: StandardHandlerPlugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
+}
+declare class StandardHandler<T extends Context> {
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    private readonly rootInterceptors;
+    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 e };
+export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardHandleOptions as c, StandardHandleResult as d };

package/dist/shared/server.DLsti1Pv.mjs

@@ -0,0 +1,293 @@
+import { isObject, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, value, toHttpPath, 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 './server.BKh8I1Ny.mjs';
+import { fallbackContractConfig } from '@temporary-name/contract';
+import { d as deserialize, s as serialize, a as standardizeHTTPPath } from './server.BEHw7Eyx.mjs';
+import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@temporary-name/server';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+class StandardOpenAPICodec {
+  constructor() {
+  }
+  async decode(request, params, procedure) {
+    const inputStructure = fallbackContractConfig(
+      "defaultInputStructure",
+      procedure["~orpc"].route.inputStructure
+    );
+    if (inputStructure === "compact") {
+      const data = request.method === "GET" ? deserialize(request.url.searchParams) : deserialize(await request.body());
+      if (data === void 0) {
+        return params;
+      }
+      if (isObject(data)) {
+        return {
+          ...params,
+          ...data
+        };
+      }
+      return data;
+    }
+    const deserializeSearchParams = () => {
+      return deserialize(request.url.searchParams);
+    };
+    return {
+      params,
+      get query() {
+        const value = deserializeSearchParams();
+        Object.defineProperty(this, "query", { value, writable: true });
+        return value;
+      },
+      set query(value) {
+        Object.defineProperty(this, "query", { value, writable: true });
+      },
+      headers: request.headers,
+      body: deserialize(await request.body())
+    };
+  }
+  encode(output, procedure) {
+    const successStatus = fallbackContractConfig(
+      "defaultSuccessStatus",
+      procedure["~orpc"].route.successStatus
+    );
+    const outputStructure = fallbackContractConfig(
+      "defaultOutputStructure",
+      procedure["~orpc"].route.outputStructure
+    );
+    if (outputStructure === "compact") {
+      return {
+        status: successStatus,
+        headers: {},
+        body: serialize(output)
+      };
+    }
+    if (!this.#isDetailedOutput(output)) {
+      throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
+    }
+    return {
+      status: output.status ?? successStatus,
+      headers: output.headers ?? {},
+      body: serialize(output.body)
+    };
+  }
+  encodeError(error) {
+    return {
+      status: error.status,
+      headers: {},
+      body: serialize(error.toJSON(), { outputFormat: "plain" })
+    };
+  }
+  #isDetailedOutput(output) {
+    if (!isObject(output)) {
+      return false;
+    }
+    if (output.headers && !isObject(output.headers)) {
+      return false;
+    }
+    if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
+      return false;
+    }
+    return true;
+  }
+}
+
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)])
+  );
+}
+
+class StandardOpenAPIMatcher {
+  tree = createRouter();
+  pendingRouters = [];
+  init(router, path = []) {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(true, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
+      if (isProcedure(contract)) {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: contract,
+          // this mean dev not used contract-first so we can used contract as procedure directly
+          router
+        });
+      } else {
+        addRoute(this.tree, method, httpPath, {
+          path: path2,
+          contract,
+          procedure: void 0,
+          router
+        });
+      }
+    });
+    this.pendingRouters.push(
+      ...laziedOptions.map((option) => ({
+        ...option,
+        httpPathPrefix: toHttpPath(option.path),
+        laziedPrefix: getLazyMeta(option.router).prefix
+      }))
+    );
+  }
+  async match(method, pathname) {
+    if (this.pendingRouters.length) {
+      const newPendingRouters = [];
+      for (const pendingRouter of this.pendingRouters) {
+        if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
+          const { default: router } = await unlazy(pendingRouter.router);
+          this.init(router, pendingRouter.path);
+        } else {
+          newPendingRouters.push(pendingRouter);
+        }
+      }
+      this.pendingRouters = newPendingRouters;
+    }
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    if (!match.data.procedure) {
+      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
+      if (!isProcedure(maybeProcedure)) {
+        throw new Error(`
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
+          Ensure that the procedure is correctly defined and matches the expected contract.
+        `);
+      }
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
+    }
+    return {
+      path: match.data.path,
+      procedure: match.data.procedure,
+      params: match.params ? decodeParams(match.params) : void 0
+    };
+  }
+}
+
+class CompositeStandardHandlerPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options, router) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options, router);
+    }
+  }
+}
+
+class StandardHandler {
+  interceptors;
+  clientInterceptors;
+  rootInterceptors;
+  matcher;
+  codec;
+  constructor(router, options) {
+    this.matcher = new StandardOpenAPIMatcher();
+    this.codec = new StandardOpenAPICodec();
+    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);
+  }
+  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 as C, StandardHandler as S, StandardOpenAPICodec as a, StandardOpenAPIMatcher as b, decodeParams as d, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };

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 };