@orpc/openapi 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/plugins/index.d.mts

@@ -2,10 +2,10 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions } from '@orpc/server/standard';
 import { Value, Promisable } from '@orpc/shared';
 import { ApiReferenceConfiguration } from '@scalar/api-reference';
-import { StandardUrl } from '@standardserver/core';
+import { StandardUrl } from '@standard-server/core';
 import { SwaggerUIOptions } from 'swagger-ui';
-import { a as OpenAPIDocument } from '../shared/openapi.CYgMBSUF.mjs';
-import '@hey-api/spec-types';
+import { OpenAPIDocument, OpenAPIVersion } from '../index.mjs';
+import '@openapi-spec/types';
 import '@orpc/client';
 
 type OpenAPIReferenceHandlerPluginProvider = 'scalar' | 'swagger';
@@ -13,15 +13,34 @@ interface OpenAPIReferenceHandlerPluginScalarConfig extends Partial<ApiReference
 }
 interface OpenAPIReferenceHandlerPluginSwaggerConfig extends Partial<Omit<SwaggerUIOptions, 'dom_id' | 'presets' | 'plugins'>> {
     dom_id?: undefined | never;
-    presets?: undefined | `SwaggerUIBundle.${string}`[];
-    plugins?: undefined | `SwaggerUIBundle.${string}`[];
+    /**
+     * Paths to global variables holding the presets, resolved in the browser,
+     * e.g. `'SwaggerUIBundle.presets.apis'`. Load custom presets through `docsHead`.
+     *
+     * @default ['SwaggerUIBundle.presets.apis']
+     */
+    presets?: undefined | string[];
+    /**
+     * Paths to global variables holding the plugins, resolved in the browser,
+     * e.g. `'SwaggerUIBundle.plugins.DownloadUrl'`. Load custom plugins through `docsHead`.
+     *
+     * @default ['SwaggerUIBundle.plugins.DownloadUrl']
+     */
+    plugins?: undefined | string[];
 }
 interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> {
     /**
      * A static or dynamic OpenAPI document to serve.
      * Receives routing interceptor options when provided as a function.
      */
-    spec: Value<Promisable<OpenAPIDocument>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    spec: Value<Promisable<OpenAPIDocument<OpenAPIVersion>>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Determines whether the docs UI and OpenAPI JSON are allowed to be served for a request.
+     * When it resolves to `false`, the request falls through as unmatched,
+     * as if the plugin were not installed. Useful for restricting access
+     * to authenticated users.
+     */
+    allow?: Value<Promisable<boolean>, [StandardHandlerRoutingInterceptorOptions<T>]>;
     /**
      * The URL path at which to serve the OpenAPI JSON.
      *
@@ -71,9 +90,19 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      */
     docsHead?: Value<Promisable<string>, [StandardHandlerRoutingInterceptorOptions<T>]>;
 }
+/**
+ * Serves API reference documentation powered by Scalar or Swagger UI,
+ * and exposes the OpenAPI specification as JSON.
+ *
+ * @remarks
+ * **Note**: By default, the API reference UI is served from `/` and the OpenAPI specification from `/spec.json`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/openapi-reference | OpenAPI Reference Plugin (Swagger/Scalar)}
+ */
 declare class OpenAPIReferenceHandlerPlugin<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> implements StandardHandlerPlugin<T> {
     name: string;
     private readonly spec;
+    private readonly allow;
     private readonly specPath;
     private readonly provider;
     private readonly providerConfig;

package/dist/plugins/index.d.ts

@@ -2,10 +2,10 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions } from '@orpc/server/standard';
 import { Value, Promisable } from '@orpc/shared';
 import { ApiReferenceConfiguration } from '@scalar/api-reference';
-import { StandardUrl } from '@standardserver/core';
+import { StandardUrl } from '@standard-server/core';
 import { SwaggerUIOptions } from 'swagger-ui';
-import { a as OpenAPIDocument } from '../shared/openapi.CYgMBSUF.js';
-import '@hey-api/spec-types';
+import { OpenAPIDocument, OpenAPIVersion } from '../index.js';
+import '@openapi-spec/types';
 import '@orpc/client';
 
 type OpenAPIReferenceHandlerPluginProvider = 'scalar' | 'swagger';
@@ -13,15 +13,34 @@ interface OpenAPIReferenceHandlerPluginScalarConfig extends Partial<ApiReference
 }
 interface OpenAPIReferenceHandlerPluginSwaggerConfig extends Partial<Omit<SwaggerUIOptions, 'dom_id' | 'presets' | 'plugins'>> {
     dom_id?: undefined | never;
-    presets?: undefined | `SwaggerUIBundle.${string}`[];
-    plugins?: undefined | `SwaggerUIBundle.${string}`[];
+    /**
+     * Paths to global variables holding the presets, resolved in the browser,
+     * e.g. `'SwaggerUIBundle.presets.apis'`. Load custom presets through `docsHead`.
+     *
+     * @default ['SwaggerUIBundle.presets.apis']
+     */
+    presets?: undefined | string[];
+    /**
+     * Paths to global variables holding the plugins, resolved in the browser,
+     * e.g. `'SwaggerUIBundle.plugins.DownloadUrl'`. Load custom plugins through `docsHead`.
+     *
+     * @default ['SwaggerUIBundle.plugins.DownloadUrl']
+     */
+    plugins?: undefined | string[];
 }
 interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> {
     /**
      * A static or dynamic OpenAPI document to serve.
      * Receives routing interceptor options when provided as a function.
      */
-    spec: Value<Promisable<OpenAPIDocument>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    spec: Value<Promisable<OpenAPIDocument<OpenAPIVersion>>, [StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Determines whether the docs UI and OpenAPI JSON are allowed to be served for a request.
+     * When it resolves to `false`, the request falls through as unmatched,
+     * as if the plugin were not installed. Useful for restricting access
+     * to authenticated users.
+     */
+    allow?: Value<Promisable<boolean>, [StandardHandlerRoutingInterceptorOptions<T>]>;
     /**
      * The URL path at which to serve the OpenAPI JSON.
      *
@@ -71,9 +90,19 @@ interface OpenAPIReferenceHandlerPluginOptions<T extends Context, TProvider exte
      */
     docsHead?: Value<Promisable<string>, [StandardHandlerRoutingInterceptorOptions<T>]>;
 }
+/**
+ * Serves API reference documentation powered by Scalar or Swagger UI,
+ * and exposes the OpenAPI specification as JSON.
+ *
+ * @remarks
+ * **Note**: By default, the API reference UI is served from `/` and the OpenAPI specification from `/spec.json`.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/openapi-reference | OpenAPI Reference Plugin (Swagger/Scalar)}
+ */
 declare class OpenAPIReferenceHandlerPlugin<T extends Context, TProvider extends OpenAPIReferenceHandlerPluginProvider> implements StandardHandlerPlugin<T> {
     name: string;
     private readonly spec;
+    private readonly allow;
     private readonly specPath;
     private readonly provider;
     private readonly providerConfig;

package/dist/plugins/index.mjs

@@ -1,8 +1,9 @@
-import { toArray, matchesHttpPath, mergeHttpPath, getOpenTelemetryConfig, value, stringifyJSON } from '@orpc/shared';
+import { toArray, matchesHttpPath, mergeHttpPath, value, getTracer, stringifyJSON } from '@orpc/shared';
 
 class OpenAPIReferenceHandlerPlugin {
   name = "~openapi-reference";
   spec;
+  allow;
   specPath;
   provider;
   providerConfig;
@@ -13,6 +14,7 @@ class OpenAPIReferenceHandlerPlugin {
   docsHead;
   constructor(options) {
     this.spec = options.spec;
+    this.allow = options.allow;
     this.specPath = options.specPath ?? "/spec.json";
     this.provider = options.provider ?? "scalar";
     this.providerConfig = options.providerConfig;
@@ -44,7 +46,10 @@ class OpenAPIReferenceHandlerPlugin {
           if (!isSpecPath && !isDocsPath) {
             return result;
           }
-          const span = getOpenTelemetryConfig()?.trace.getActiveSpan();
+          if (await value(this.allow, routingInterceptorOptions) === false) {
+            return result;
+          }
+          const span = getTracer()?.getActiveSpan();
           const spec = await value(this.spec, routingInterceptorOptions);
           if (isSpecPath) {
             span?.updateName(`${routingInterceptorOptions.request.method} ${routingInterceptorOptions.request.url} (openapi spec)`);
@@ -64,13 +69,8 @@ class OpenAPIReferenceHandlerPlugin {
               dom_id: "#app",
               spec,
               deepLinking: true,
-              presets: [
-                "SwaggerUIBundle.presets.apis",
-                "SwaggerUIBundle.presets.standalone"
-              ],
-              plugins: [
-                "SwaggerUIBundle.plugins.DownloadUrl"
-              ],
+              presets: ["SwaggerUIBundle.presets.apis"],
+              plugins: ["SwaggerUIBundle.plugins.DownloadUrl"],
               ...this.providerConfig
             };
             html = `
@@ -90,10 +90,15 @@ class OpenAPIReferenceHandlerPlugin {
 
                 <!-- IMPORTANT: assign to a variable first to prevent ), ( in values breaking the call expression. -->
                 <!-- IMPORTANT: escapeJsonForHtml ensures <, > cannot terminate the <\/script> tag prematurely. -->
+                <!-- IMPORTANT: resolve presets/plugins global paths at runtime, never unquote them in the JSON, which also holds the spec. -->
                 <script>
-                    const swaggerConfig = ${escapeJsonForHtml(config).replace(/"(SwaggerUIBundle\.[.a-zA-Z0-9]+)"/g, "$1")}
+                    const swaggerConfig = ${escapeJsonForHtml(config)}
 
                     window.onload = () => {
+                        for (const key of ['presets', 'plugins']) {
+                            swaggerConfig[key] &&= swaggerConfig[key].map(path => path.split('.').reduce((value, name) => value?.[name], window))
+                        }
+
                         window.ui = SwaggerUIBundle(swaggerConfig)
                     }
                 <\/script>

package/dist/shared/{openapi.B2SK0ZAr.mjs → openapi.8cM6P94D.mjs}

@@ -1,15 +1,15 @@
-import { isORPCErrorJson, createORPCErrorFromJson, ORPCError } from '@orpc/client';
+import { createORPCErrorFromMalformedResponse, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
 import { getRouterContract, ProcedureContract } from '@orpc/contract';
 import { unlazy } from '@orpc/server';
-import { value, pathToHttpPath, mergeHttpPath, isTypescriptObject, stringifyJSON } from '@orpc/shared';
-import { mergeStandardHeaders, parseStandardUrl, isStandardHeaders } from '@standardserver/core';
-import { toStandardHeaders } from '@standardserver/fetch';
-import { O as OpenAPISerializer, D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, g as getDynamicPathParams, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.DmAa7YPO.mjs';
+import { value, pathToHttpPath, mergeHttpPath, isTypescriptObject, stringifyJSON, safeEncodeURIComponent } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl } from '@standard-server/core';
+import { toStandardHeaders } from '@standard-server/fetch';
+import { O as OpenAPISerializer, D as DEFAULT_OPENAPI_METHOD, a as DEFAULT_OPENAPI_INPUT_STRUCTURE, g as getDynamicPathParams, i as isBodylessMethod, b as DEFAULT_OPENAPI_OUTPUT_STRUCTURE } from './openapi.Bu_PfTtX.mjs';
 import { g as getOpenAPIMeta } from './openapi.B9PQzqBn.mjs';
+import { s as serializeHeaders } from './openapi.Bi1qxGF9.mjs';
 
-class OpenAPILinkCodecError extends TypeError {
-}
 const END_SLASH_REGEX = /\/$/;
+const DOT_SEGMENT_REGEX = /(?:^|\/)\.{1,2}(?:\/|$)/;
 class OpenAPILinkCodec {
   constructor(router, options = {}) {
     this.router = router;
@@ -42,7 +42,7 @@ class OpenAPILinkCodec {
       let data = input;
       if (dynamicParams?.length) {
         if (!isTypescriptObject(input)) {
-          throw new OpenAPILinkCodecError(
+          throw new TypeError(
             `Input must be an object with "compact" input structure when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
           );
         }
@@ -56,7 +56,7 @@ class OpenAPILinkCodec {
         data = Object.keys(remaining).length > 0 ? remaining : void 0;
       }
       pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
-      if (method === "GET") {
+      if (isBodylessMethod(method)) {
         const queryString2 = this.serializeQueryString(data, meta?.queryStyles);
         const search2 = combineSearch(baseSearch, queryString2);
         const url3 = `${pathname}${search2 ?? ""}${baseHash ?? ""}`;
@@ -78,12 +78,12 @@ class OpenAPILinkCodec {
       };
     }
     if (!isValidDetailedInput(input)) {
-      throw new OpenAPILinkCodecError(`
+      throw new TypeError(`
         Invalid "detailed" input structure in call to procedure (${path.join(".")}):
         \u2022 Expected an object or undefined with optional properties:
           - params (object, required when the path has dynamic params)
           - query (object)
-          - headers (Record<string, string | string[] | undefined>)
+          - headers (object)
           - body (any)
 
         Actual value:
@@ -92,7 +92,7 @@ class OpenAPILinkCodec {
     }
     if (dynamicParams?.length) {
       if (!input?.params) {
-        throw new OpenAPILinkCodecError(
+        throw new TypeError(
           `The "params" property is required for "detailed" input when the path has dynamic params (${dynamicParams.map((p) => p.parameterName).join(", ")}) in call to procedure (${path.join(".")}).`
         );
       }
@@ -104,13 +104,13 @@ class OpenAPILinkCodec {
       }
     }
     if (input?.headers) {
-      headers = mergeStandardHeaders(headers, input.headers);
+      headers = mergeStandardHeaders(headers, serializeHeaders(input.headers, this.serializer));
     }
     pathname = `${basePathname.replace(END_SLASH_REGEX, "")}${pathname}`;
     const queryString = this.serializeQueryString(input?.query, meta?.queryStyles);
     const search = combineSearch(baseSearch, queryString);
     const url = `${pathname}${search ?? ""}${baseHash ?? ""}`;
-    if (method === "GET") {
+    if (isBodylessMethod(method)) {
       return {
         body: void 0,
         method,
@@ -130,21 +130,24 @@ class OpenAPILinkCodec {
   encodePathParam(val, param, style, path) {
     let encoded;
     if (style === "comma-delimited-array" && Array.isArray(val)) {
-      encoded = val.map((val2) => this.serializer.serialize(val2)).filter((val2) => val2 !== void 0 && val2 !== null).map((val2) => encodeURIComponent(String(val2))).join(",");
+      encoded = val.map((val2) => this.serializer.serialize(val2)).filter((val2) => val2 !== void 0 && val2 !== null).map((val2) => safeEncodeURIComponent(String(val2))).join(",");
     } else if (style === "comma-delimited-object" && isTypescriptObject(val)) {
-      encoded = Object.entries(val).map(([key, val2]) => [key, this.serializer.serialize(val2)]).filter(([, val2]) => val2 !== void 0 && val2 !== null).map(([key, val2]) => `${encodeURIComponent(String(key))},${encodeURIComponent(String(val2))}`).join(",");
+      encoded = Object.entries(val).map(([key, val2]) => [key, this.serializer.serialize(val2)]).filter(([, val2]) => val2 !== void 0 && val2 !== null).map(([key, val2]) => `${safeEncodeURIComponent(String(key))},${safeEncodeURIComponent(String(val2))}`).join(",");
     } else {
       const serialized = this.serializer.serialize(val);
       if (serialized !== void 0 && serialized !== null) {
         if (param.allowsSlash) {
-          encoded = String(serialized).split("/").map(encodeURIComponent).join("/");
+          encoded = String(serialized).split("/").map(safeEncodeURIComponent).join("/");
         } else {
-          encoded = encodeURIComponent(String(serialized));
+          encoded = safeEncodeURIComponent(String(serialized));
         }
       }
     }
     if (!encoded) {
-      throw new OpenAPILinkCodecError(`Path param "${param.parameterName}" cannot be empty in call to procedure (${path.join(".")}).`);
+      throw new TypeError(`Path param "${param.parameterName}" cannot be empty in call to procedure (${path.join(".")}).`);
+    }
+    if (DOT_SEGMENT_REGEX.test(encoded)) {
+      throw new TypeError(`Path param "${param.parameterName}" cannot contain "." or ".." segments in call to procedure (${path.join(".")}).`);
     }
     return encoded;
   }
@@ -243,22 +246,17 @@ class OpenAPILinkCodec {
     return query || void 0;
   }
   async decodeResponse(response, path, _options) {
-    const isOk = response.status >= 200 && response.status < 400;
+    const isOk = response.status < 400;
     const procedure = await this.resolveProcedure(path);
     const meta = getOpenAPIMeta(procedure);
+    const body = await response.resolveBody(meta?.responseBodyHint);
     const deserialized = await (async () => {
-      let isBodyOk = false;
       try {
-        const body = await response.resolveBody(meta?.responseBodyHint);
-        isBodyOk = true;
         return this.serializer.deserialize(body);
       } catch (error) {
-        if (!isBodyOk) {
-          throw new Error("Cannot parse response body, please check the response body and content-type.", {
-            cause: error
-          });
-        }
-        throw new Error("Invalid OpenAPI response format.", {
+        throw createORPCErrorFromMalformedResponse({
+          message: "Invalid OpenAPI response format.",
+          response: { status: response.status, headers: response.headers, body },
           cause: error
         });
       }
@@ -273,9 +271,7 @@ class OpenAPILinkCodec {
       }
       return {
         kind: "error",
-        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
-          data: { headers: response.headers, status: response.status, body: deserialized }
-        })
+        error: createORPCErrorFromMalformedResponse({ response: { headers: response.headers, status: response.status, body } })
       };
     }
     const outputStructure = meta?.outputStructure ?? DEFAULT_OPENAPI_OUTPUT_STRUCTURE;
@@ -291,7 +287,7 @@ class OpenAPILinkCodec {
   async resolveProcedure(path) {
     const { default: maybeProcedure } = await unlazy(getRouterContract(this.router, path));
     if (!(maybeProcedure instanceof ProcedureContract)) {
-      throw new OpenAPILinkCodecError(`Expected a procedure or contract at path (${path.join(".")})`);
+      throw new TypeError(`Expected a procedure or contract at path (${path.join(".")})`);
     }
     return maybeProcedure;
   }
@@ -324,7 +320,7 @@ function isValidDetailedInput(input) {
   if (input.query !== void 0 && !isTypescriptObject(input.query)) {
     return false;
   }
-  if (input.headers !== void 0 && !isStandardHeaders(input.headers)) {
+  if (input.headers !== void 0 && !isTypescriptObject(input.headers)) {
     return false;
   }
   return true;
@@ -347,7 +343,7 @@ function encodeDelimitedArray(serializedValues, encodedDelimiter) {
   return strings.map(encodeURLSearchParamComponent).join(encodedDelimiter);
 }
 function encodeDelimitedObject(entries, encodedDelimiter) {
-  const strings = entries.filter(([v]) => v !== null && v !== void 0).map(([k, v]) => [k, String(v)]);
+  const strings = entries.filter(([, v]) => v !== null && v !== void 0).map(([k, v]) => [k, String(v)]);
   if (!strings.length) {
     return void 0;
   }
@@ -356,4 +352,4 @@ function encodeDelimitedObject(entries, encodedDelimiter) {
   ).join(encodedDelimiter);
 }
 
-export { OpenAPILinkCodec as O, OpenAPILinkCodecError as a };
+export { OpenAPILinkCodec as O };

package/dist/shared/openapi.B2G-HeFn.mjs

@@ -0,0 +1,123 @@
+import { isPlainObject, NullProtoObj, getOwn, setOwn } from '@orpc/shared';
+
+class BracketNotationSerializer {
+  maxExplicitDeserializingArrayIndex;
+  constructor(options = {}) {
+    this.maxExplicitDeserializingArrayIndex = options.maxExplicitDeserializingArrayIndex ?? 999;
+  }
+  serialize(data) {
+    const result = [];
+    this.internalSerialize(data, "", true, result);
+    return result;
+  }
+  internalSerialize(data, path, isRoot, result) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.internalSerialize(item, isRoot ? i.toString() : `${path}[${i}]`, false, result);
+      });
+    } else if (isPlainObject(data)) {
+      for (const key of Object.keys(data)) {
+        this.internalSerialize(data[key], isRoot ? key : `${path}[${key}]`, false, result);
+      }
+    } else {
+      result.push([path, data]);
+    }
+  }
+  deserialize(serialized) {
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const root = new NullProtoObj();
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = root;
+      let nextSegment = segments[0];
+      for (let i = 1; i < segments.length; i++) {
+        const segment = segments[i];
+        const isLast = i === segments.length - 1;
+        const existing = getOwn(currentRef, nextSegment);
+        let child = existing;
+        if (!Array.isArray(child) && !isPlainObject(child)) {
+          child = [];
+        }
+        if (Array.isArray(child)) {
+          const isPushStyle = arrayPushStyles.has(child);
+          const canStayArray = segment === "" ? isLast && (isPushStyle || child.length === 0) : internalIsValidArrayIndex(segment, this.maxExplicitDeserializingArrayIndex) && !(isLast && isPushStyle);
+          if (!canStayArray) {
+            arrayPushStyles.delete(child);
+            child = isPushStyle ? internalPushStyleArrayToObject(child) : internalArrayToObject(child);
+          }
+        }
+        if (child !== existing) {
+          setOwn(currentRef, nextSegment, child);
+        }
+        currentRef = child;
+        nextSegment = segment;
+      }
+      if (Array.isArray(currentRef) && nextSegment === "") {
+        arrayPushStyles.add(currentRef);
+        currentRef.push(value);
+      } else if (Object.hasOwn(currentRef, nextSegment)) {
+        const current = currentRef[nextSegment];
+        if (Array.isArray(current)) {
+          current.push(value);
+        } else {
+          setOwn(currentRef, nextSegment, [current, value]);
+        }
+      } else {
+        setOwn(currentRef, nextSegment, value);
+      }
+    }
+    return root;
+  }
+  stringifyPath(segments) {
+    if (segments.length === 0) {
+      return "";
+    }
+    let result = segments[0].toString();
+    for (let i = 1; i < segments.length; i++) {
+      result += `[${segments[i]}]`;
+    }
+    return result;
+  }
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[")) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[") {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else {
+        currentSegment += char;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path] : segments;
+  }
+}
+const INTEGER_PATTERN = /^0$|^[1-9]\d*$/;
+function internalIsValidArrayIndex(value, maxIndex) {
+  return INTEGER_PATTERN.test(value) && Number(value) <= maxIndex;
+}
+function internalArrayToObject(array) {
+  const obj = new NullProtoObj();
+  array.forEach((item, i) => {
+    obj[i] = item;
+  });
+  return obj;
+}
+function internalPushStyleArrayToObject(array) {
+  const obj = new NullProtoObj();
+  obj[""] = array.length === 1 ? array[0] : array;
+  return obj;
+}
+
+export { BracketNotationSerializer as B };

package/dist/shared/{openapi.7vgmPxca.d.ts → openapi.BCNfESWr.d.ts}

@@ -1,10 +1,10 @@
 import { AnyORPCError } from '@orpc/client';
 import { AnyProcedure, AnyRouter, Context } from '@orpc/server';
-import { StandardHandlerCodec, StandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { StandardHandlerCodec, ResolvedStandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
+import { Value, Public, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { AnyProcedureContract } from '@orpc/contract';
-import { O as OpenAPISerializer } from './openapi.C7m7NAmH.js';
+import { O as OpenAPISerializer } from './openapi.C2LayTNZ.js';
 
 interface OpenAPIMatcherOptions {
     /**
@@ -18,7 +18,7 @@ declare class OpenAPIMatcher {
     private readonly filter;
     private readonly rootRouter;
     private readonly tree;
-    private pendingLazyRouters;
+    private readonly pendingLazyRouters;
     constructor(router: AnyRouter, options?: OpenAPIMatcherOptions);
     private index;
     match(method: string, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
@@ -26,8 +26,10 @@ declare class OpenAPIMatcher {
         procedure: AnyProcedure;
         params?: Record<string, string> | undefined;
     } | undefined>;
-    private matchPathname;
     private resolvePendingLazyRouters;
+    private loadPendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
     private resolveProcedure;
 }
 
@@ -35,11 +37,12 @@ interface OpenAPIHandlerCodecCoreOptions<_T extends Context> {
     /**
      * Override the default OpenAPI serializer.
      */
-    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    serializer?: Public<OpenAPISerializer>;
     /**
      * 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`).
      *
-     * @default COMMON_ERROR_STATUS_MAP, DEFAULT_ERROR_STATUS
+     * @default COMMON_ERROR_STATUS_MAP
      */
     errorStatusMap?: Record<string, number> | undefined;
     /**
@@ -75,7 +78,7 @@ interface OpenAPIHandlerCodecOptions<T extends Context> extends OpenAPIHandlerCo
 declare class OpenAPIHandlerCodec<T extends Context> extends OpenAPIHandlerCodecCore<T> implements StandardHandlerCodec<T> {
     private readonly matcher;
     constructor(router: AnyRouter, options?: OpenAPIHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
 }
 
 export { OpenAPIHandlerCodec as a, OpenAPIHandlerCodecCore as b, OpenAPIMatcher as d };

package/dist/shared/{openapi.CX6Ri5dP.d.mts → openapi.BgpM--nz.d.mts}

@@ -1,10 +1,10 @@
 import { AnyORPCError } from '@orpc/client';
 import { AnyProcedure, AnyRouter, Context } from '@orpc/server';
-import { StandardHandlerCodec, StandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { StandardHandlerCodec, ResolvedStandardHandlerHandleOptions, StandardHandlerCodecResolvedProcedure } from '@orpc/server/standard';
+import { Value, Public, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { AnyProcedureContract } from '@orpc/contract';
-import { O as OpenAPISerializer } from './openapi.C7m7NAmH.mjs';
+import { O as OpenAPISerializer } from './openapi.C2LayTNZ.mjs';
 
 interface OpenAPIMatcherOptions {
     /**
@@ -18,7 +18,7 @@ declare class OpenAPIMatcher {
     private readonly filter;
     private readonly rootRouter;
     private readonly tree;
-    private pendingLazyRouters;
+    private readonly pendingLazyRouters;
     constructor(router: AnyRouter, options?: OpenAPIMatcherOptions);
     private index;
     match(method: string, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
@@ -26,8 +26,10 @@ declare class OpenAPIMatcher {
         procedure: AnyProcedure;
         params?: Record<string, string> | undefined;
     } | undefined>;
-    private matchPathname;
     private resolvePendingLazyRouters;
+    private loadPendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
     private resolveProcedure;
 }
 
@@ -35,11 +37,12 @@ interface OpenAPIHandlerCodecCoreOptions<_T extends Context> {
     /**
      * Override the default OpenAPI serializer.
      */
-    serializer?: Pick<OpenAPISerializer, keyof OpenAPISerializer>;
+    serializer?: Public<OpenAPISerializer>;
     /**
      * 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`).
      *
-     * @default COMMON_ERROR_STATUS_MAP, DEFAULT_ERROR_STATUS
+     * @default COMMON_ERROR_STATUS_MAP
      */
     errorStatusMap?: Record<string, number> | undefined;
     /**
@@ -75,7 +78,7 @@ interface OpenAPIHandlerCodecOptions<T extends Context> extends OpenAPIHandlerCo
 declare class OpenAPIHandlerCodec<T extends Context> extends OpenAPIHandlerCodecCore<T> implements StandardHandlerCodec<T> {
     private readonly matcher;
     constructor(router: AnyRouter, options?: OpenAPIHandlerCodecOptions<T>);
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
 }
 
 export { OpenAPIHandlerCodec as a, OpenAPIHandlerCodecCore as b, OpenAPIMatcher as d };