@orpc/contract 0.32.0 → 0.33.0

package/dist/index.js

@@ -1,12 +1,21 @@
+// src/error-map.ts
+function mergeErrorMap(errorMap1, errorMap2) {
+  return { ...errorMap1, ...errorMap2 };
+}
+
+// src/meta.ts
+function mergeMeta(meta1, meta2) {
+  return { ...meta1, ...meta2 };
+}
+
 // src/procedure.ts
 var ContractProcedure = class {
-  "~type" = "ContractProcedure";
   "~orpc";
   constructor(def) {
     if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
       throw new Error("[ContractProcedure] The successStatus must be between 200 and 299");
     }
-    if (Object.values(def.errorMap ?? {}).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
+    if (Object.values(def.errorMap).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
       throw new Error("[ContractProcedure] The error status code must be in the 400-599 range.");
     }
     this["~orpc"] = def;
@@ -16,266 +25,140 @@ function isContractProcedure(item) {
   if (item instanceof ContractProcedure) {
     return true;
   }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"] && "errorMap" in item["~orpc"];
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "inputSchema" in item["~orpc"] && "outputSchema" in item["~orpc"] && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
 }
 
-// src/procedure-decorated.ts
-var DecoratedContractProcedure = class _DecoratedContractProcedure extends ContractProcedure {
-  static decorate(procedure) {
-    if (procedure instanceof _DecoratedContractProcedure) {
-      return procedure;
-    }
-    return new _DecoratedContractProcedure(procedure["~orpc"]);
-  }
-  errors(errors) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  route(route) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        ...route
-      }
-    });
-  }
-  prefix(prefix) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      ...this["~orpc"].route?.path ? {
-        route: {
-          ...this["~orpc"].route,
-          path: `${prefix}${this["~orpc"].route.path}`
-        }
-      } : void 0
-    });
-  }
-  unshiftTag(...tags) {
-    return new _DecoratedContractProcedure({
-      ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        tags: [
-          ...tags,
-          ...this["~orpc"].route?.tags?.filter((tag) => !tags.includes(tag)) ?? []
-        ]
-      }
-    });
-  }
-};
-
-// src/procedure-builder-with-input.ts
-var ContractProcedureBuilderWithInput = class _ContractProcedureBuilderWithInput extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
-  }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+// src/route.ts
+function mergeRoute(a, b) {
+  return { ...a, ...b };
+}
+function prefixRoute(route, prefix) {
+  if (!route.path) {
+    return route;
   }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  return {
+    ...route,
+    path: `${prefix}${route.path}`
+  };
+}
+function unshiftTagRoute(route, tags) {
+  return {
+    ...route,
+    tags: [...tags, ...route.tags ?? []]
+  };
+}
+function mergePrefix(a, b) {
+  return a ? `${a}${b}` : b;
+}
+function mergeTags(a, b) {
+  return a ? [...a, ...b] : b;
+}
+function adaptRoute(route, options) {
+  let router = route;
+  if (options.prefix) {
+    router = prefixRoute(router, options.prefix);
   }
-  output(schema, example) {
-    return new DecoratedContractProcedure({
-      ...this["~orpc"],
-      OutputSchema: schema,
-      outputExample: example
-    });
+  if (options.tags) {
+    router = unshiftTagRoute(router, options.tags);
   }
-};
+  return router;
+}
 
-// src/procedure-builder-with-output.ts
-var ContractProcedureBuilderWithOutput = class _ContractProcedureBuilderWithOutput extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
-  }
-  input(schema, example) {
-    return new DecoratedContractProcedure({
-      ...this["~orpc"],
-      InputSchema: schema,
-      inputExample: example
+// src/router.ts
+function adaptContractRouter(contract, options) {
+  if (isContractProcedure(contract)) {
+    const adapted2 = new ContractProcedure({
+      ...contract["~orpc"],
+      errorMap: mergeErrorMap(options.errorMap, contract["~orpc"].errorMap),
+      route: adaptRoute(contract["~orpc"].route, options)
     });
+    return adapted2;
   }
-};
-
-// src/procedure-builder.ts
-var ContractProcedureBuilder = class _ContractProcedureBuilder extends ContractProcedure {
-  errors(errors) {
-    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  route(route) {
-    const decorated = DecoratedContractProcedure.decorate(this).route(route);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  const adapted = {};
+  for (const key in contract) {
+    adapted[key] = adaptContractRouter(contract[key], options);
   }
-  prefix(prefix) {
-    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  unshiftTag(...tags) {
-    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
-    return new _ContractProcedureBuilder(decorated["~orpc"]);
-  }
-  input(schema, example) {
-    return new ContractProcedureBuilderWithInput({
-      ...this["~orpc"],
-      InputSchema: schema,
-      inputExample: example
-    });
-  }
-  output(schema, example) {
-    return new ContractProcedureBuilderWithOutput({
-      ...this["~orpc"],
-      OutputSchema: schema,
-      outputExample: example
-    });
-  }
-};
+  return adapted;
+}
 
-// src/router-builder.ts
-var ContractRouterBuilder = class _ContractRouterBuilder {
-  "~type" = "ContractProcedure";
-  "~orpc";
+// src/builder.ts
+var ContractBuilder = class _ContractBuilder extends ContractProcedure {
   constructor(def) {
-    this["~orpc"] = def;
+    super(def);
+    this["~orpc"].prefix = def.prefix;
+    this["~orpc"].tags = def.tags;
   }
-  prefix(prefix) {
-    return new _ContractRouterBuilder({
+  /**
+   * Reset initial meta
+   */
+  $meta(initialMeta) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
+      meta: initialMeta
     });
   }
-  tag(...tags) {
-    return new _ContractRouterBuilder({
+  /**
+   * Reset initial route
+   */
+  $route(initialRoute) {
+    return new _ContractBuilder({
       ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
+      route: initialRoute
     });
   }
   errors(errors) {
-    return new _ContractRouterBuilder({
-      ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
-    });
-  }
-  router(router) {
-    if (isContractProcedure(router)) {
-      let decorated = DecoratedContractProcedure.decorate(router);
-      if (this["~orpc"].tags) {
-        decorated = decorated.unshiftTag(...this["~orpc"].tags);
-      }
-      if (this["~orpc"].prefix) {
-        decorated = decorated.prefix(this["~orpc"].prefix);
-      }
-      decorated = decorated.errors(this["~orpc"].errorMap);
-      return decorated;
-    }
-    const adapted = {};
-    for (const key in router) {
-      adapted[key] = this.router(router[key]);
-    }
-    return adapted;
-  }
-};
-
-// src/builder.ts
-var ContractBuilder = class _ContractBuilder extends ContractProcedure {
-  constructor(def) {
-    super(def);
-  }
-  config(config) {
     return new _ContractBuilder({
       ...this["~orpc"],
-      config: {
-        ...this["~orpc"].config,
-        ...config
-      }
+      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
-  errors(errors) {
+  meta(meta) {
     return new _ContractBuilder({
       ...this["~orpc"],
-      errorMap: {
-        ...this["~orpc"].errorMap,
-        ...errors
-      }
+      meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
   route(route) {
-    return new ContractProcedureBuilder({
-      route: {
-        ...this["~orpc"].config.initialRoute,
-        ...route
-      },
-      InputSchema: void 0,
-      OutputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
-  input(schema, example) {
-    return new ContractProcedureBuilderWithInput({
-      route: this["~orpc"].config.initialRoute,
-      InputSchema: schema,
-      inputExample: example,
-      OutputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
+  input(schema) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      inputSchema: schema
     });
   }
-  output(schema, example) {
-    return new ContractProcedureBuilderWithOutput({
-      route: this["~orpc"].config.initialRoute,
-      OutputSchema: schema,
-      outputExample: example,
-      InputSchema: void 0,
-      errorMap: this["~orpc"].errorMap
+  output(schema) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      outputSchema: schema
     });
   }
   prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix,
-      errorMap: this["~orpc"].errorMap
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
-    return new ContractRouterBuilder({
-      tags,
-      errorMap: this["~orpc"].errorMap
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
   router(router) {
-    return new ContractRouterBuilder({
-      errorMap: this["~orpc"].errorMap
-    }).router(router);
+    return adaptContractRouter(router, this["~orpc"]);
   }
 };
+var oc = new ContractBuilder({
+  errorMap: {},
+  inputSchema: void 0,
+  outputSchema: void 0,
+  route: {},
+  meta: {}
+});
 
 // src/error-orpc.ts
 import { isPlainObject } from "@orpc/shared";
@@ -363,21 +246,21 @@ function fallbackORPCErrorStatus(code, status) {
 function fallbackORPCErrorMessage(code, message) {
   return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
 }
-var ORPCError = class extends Error {
+var ORPCError = class _ORPCError extends Error {
   defined;
   code;
   status;
   data;
-  constructor(options) {
-    if (options.status && (options.status < 400 || options.status >= 600)) {
+  constructor(code, ...[options]) {
+    if (options?.status && (options.status < 400 || options.status >= 600)) {
       throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
     }
-    const message = fallbackORPCErrorMessage(options.code, options.message);
+    const message = fallbackORPCErrorMessage(code, options?.message);
     super(message, options);
-    this.code = options.code;
-    this.status = fallbackORPCErrorStatus(options.code, options.status);
-    this.defined = options.defined ?? false;
-    this.data = options.data;
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options?.status);
+    this.defined = options?.defined ?? false;
+    this.data = options?.data;
   }
   toJSON() {
     return {
@@ -388,34 +271,53 @@ var ORPCError = class extends Error {
       data: this.data
     };
   }
+  static fromJSON(json) {
+    return new _ORPCError(json.code, json);
+  }
   static isValidJSON(json) {
     return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
 };
+
+// src/error-utils.ts
 function isDefinedError(error) {
   return error instanceof ORPCError && error.defined;
 }
+function createORPCErrorConstructorMap(errors) {
+  const proxy = new Proxy(errors, {
+    get(target, code) {
+      if (typeof code !== "string") {
+        return Reflect.get(target, code);
+      }
+      const item = (...[options]) => {
+        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;
+}
 async function validateORPCError(map, error) {
   const { code, status, message, data, cause, defined } = error;
   const config = map?.[error.code];
   if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
-    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
   }
   if (!config.data) {
-    return defined ? error : new ORPCError({ defined: true, code, status, message, data, cause });
+    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
   }
   const validated = await config.data["~standard"].validate(error.data);
   if (validated.issues) {
-    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
   }
-  return new ORPCError({
-    defined: true,
-    code,
-    status,
-    message,
-    data: validated.value,
-    cause
-  });
+  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
 }
 
 // src/client-utils.ts
@@ -456,7 +358,7 @@ var ValidationError = class extends Error {
   }
 };
 
-// src/schema-utils.ts
+// src/schema.ts
 function type(...[map]) {
   return {
     "~standard": {
@@ -471,33 +373,30 @@ function type(...[map]) {
     }
   };
 }
-
-// src/index.ts
-var oc = new ContractBuilder({
-  errorMap: {},
-  InputSchema: void 0,
-  OutputSchema: void 0,
-  config: {}
-});
 export {
   COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
-  ContractProcedureBuilder,
-  ContractProcedureBuilderWithInput,
-  ContractProcedureBuilderWithOutput,
-  ContractRouterBuilder,
-  DecoratedContractProcedure,
   ORPCError,
   ValidationError,
+  adaptContractRouter,
+  adaptRoute,
+  createORPCErrorConstructorMap,
   fallbackContractConfig,
   fallbackORPCErrorMessage,
   fallbackORPCErrorStatus,
   isContractProcedure,
   isDefinedError,
+  mergeErrorMap,
+  mergeMeta,
+  mergePrefix,
+  mergeRoute,
+  mergeTags,
   oc,
+  prefixRoute,
   safe,
   type,
+  unshiftTagRoute,
   validateORPCError
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder-variants.d.ts

@@ -0,0 +1,38 @@
+import type { ErrorMap, MergedErrorMap } from './error-map';
+import type { Meta } from './meta';
+import type { ContractProcedure } from './procedure';
+import type { HTTPPath, Route } from './route';
+import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
+import type { Schema } from './schema';
+export interface ContractProcedureBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithInput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
+}
+export interface ContractProcedureBuilderWithInputOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+}
+export interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': AdaptContractRouterOptions<TErrorMap>;
+    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
+    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    'router'<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
+}
+//# sourceMappingURL=builder-variants.d.ts.map

package/dist/src/builder.d.ts

@@ -1,29 +1,32 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
-import type { ContractProcedureDef, RouteOptions } from './procedure';
-import type { ContractRouter } from './router';
-import type { AdaptedContractRouter } from './router-builder';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
+import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants';
+import type { ContractProcedureDef } from './procedure';
+import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
+import type { Schema } from './schema';
+import { type ErrorMap, type MergedErrorMap } from './error-map';
+import { type Meta } from './meta';
 import { ContractProcedure } from './procedure';
-import { ContractProcedureBuilder } from './procedure-builder';
-import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
-import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
-import { ContractRouterBuilder } from './router-builder';
-export interface ContractBuilderConfig {
-    initialRoute?: RouteOptions;
+import { type HTTPPath, type Route } from './route';
+export interface ContractBuilderDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, AdaptContractRouterOptions<TErrorMap> {
 }
-export interface ContractBuilderDef<TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap> {
-    config: ContractBuilderConfig;
-}
-export declare class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
-    '~orpc': ContractBuilderDef<TErrorMap>;
-    constructor(def: ContractBuilderDef<TErrorMap>);
-    config(config: ContractBuilderConfig): ContractBuilder<TErrorMap>;
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap>;
-    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
-    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
-    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
-    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
+export declare class ContractBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
+    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+    /**
+     * Reset initial meta
+     */
+    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
+    /**
+     * Reset initial route
+     */
+    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
+    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
+    router<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
 }
+export declare const oc: ContractBuilder<undefined, undefined, {}, {}>;
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/client-utils.d.ts

@@ -1,5 +1,5 @@
 import type { ClientPromiseResult } from './client';
-import { type ORPCError } from './error-orpc';
+import type { ORPCError } from './error-orpc';
 export type SafeResult<TOutput, TError extends Error> = [output: TOutput, error: undefined, isDefinedError: false] | [output: undefined, error: TError, isDefinedError: false] | [output: undefined, error: Extract<TError, ORPCError<any, any>>, isDefinedError: true];
 export declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 //# sourceMappingURL=client-utils.d.ts.map

package/dist/src/client.d.ts

@@ -8,7 +8,9 @@ export type ClientOptions<TClientContext> = {
 });
 export type ClientRest<TClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never);
 export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __typeError?: TError;
+    __error?: {
+        type: TError;
+    };
 };
 export interface Client<TClientContext, TInput, TOutput, TError extends Error> {
     (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;

package/dist/src/config.d.ts

@@ -1,4 +1,4 @@
-import type { HTTPMethod, InputStructure } from './types';
+import type { HTTPMethod, InputStructure } from './route';
 export interface ContractConfig {
     defaultMethod: HTTPMethod;
     defaultSuccessStatus: number;

package/dist/src/error-map.d.ts

@@ -1,58 +1,14 @@
-import type { CommonORPCErrorCode } from './error-orpc';
-import type { Schema } from './types';
+import type { ORPCErrorCode } from './error-orpc';
+import type { Schema } from './schema';
 export type ErrorMapItem<TDataSchema extends Schema> = {
-    /**
-     *
-     * @default 500
-     */
     status?: number;
     message?: string;
     description?: string;
     data?: TDataSchema;
 };
-export interface ErrorMap {
-    [k: string]: ErrorMapItem<Schema>;
-}
-/**
- * const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions
- *
- * Purpose:
- * - Helps `U` suggest `CommonORPCErrorCode` to the user when typing.
- *
- * Why not replace `ErrorMap` with `ErrorMapSuggestions`?
- * - `ErrorMapSuggestions` has a drawback: it allows `undefined` values for items.
- * - `ErrorMapGuard<TErrorMap>` uses `Partial`, which can introduce `undefined` values.
- *
- * This could lead to unintended behavior where `undefined` values override `TErrorMap`,
- * potentially resulting in a `never` type after merging.
- *
- * Recommendation:
- * - Use `ErrorMapSuggestions` to assist users in typing correctly but do not replace `ErrorMap`.
- * - Ensure `ErrorMapGuard<TErrorMap>` is adjusted to prevent `undefined` values.
- */
-export type ErrorMapSuggestions = {
-    [key in CommonORPCErrorCode | (string & {})]?: ErrorMapItem<Schema>;
-};
-/**
- * `U` extends `ErrorMap` & `ErrorMapGuard<TErrorMap>`
- *
- * `ErrorMapGuard` is a utility type that ensures `U` cannot redefine the structure of `TErrorMap`.
- * It achieves this by setting each key in `TErrorMap` to `never`, effectively preventing any redefinition.
- *
- * Why not just use `Partial<TErrorMap>`?
- * - Allowing users to redefine existing error map items would require using `StrictErrorMap`.
- * - However, I prefer not to use `StrictErrorMap` frequently, due to perceived performance concerns,
- *   though this has not been benchmarked and is based on personal preference.
- *
- */
-export type ErrorMapGuard<TErrorMap extends ErrorMap> = {
-    [K in keyof TErrorMap]?: never;
-};
-/**
- * Since `undefined` has a specific meaning (it use default value),
- * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
- */
-export type StrictErrorMap<T extends ErrorMap> = {
-    [K in keyof T]: T[K] & Partial<Record<Exclude<keyof ErrorMapItem<any>, keyof T[K]>, undefined>>;
+export type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
 };
+export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
 //# sourceMappingURL=error-map.d.ts.map

package/dist/src/error-orpc.d.ts

@@ -1,5 +1,5 @@
 import type { ErrorMap, ErrorMapItem } from './error-map';
-import type { SchemaOutput } from './types';
+import type { SchemaOutput } from './schema';
 export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
     [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
 }[keyof TErrorMap];
@@ -82,9 +82,11 @@ export declare const COMMON_ORPC_ERROR_DEFS: {
     };
 };
 export type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
-export type ORPCErrorOptions<TCode extends string, TData> = ErrorOptions & {
+export type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+export declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+export declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+export type ORPCErrorOptions<TData> = ErrorOptions & {
     defined?: boolean;
-    code: TCode;
     status?: number;
     message?: string;
 } & (undefined extends TData ? {
@@ -92,18 +94,16 @@ export type ORPCErrorOptions<TCode extends string, TData> = ErrorOptions & {
 } : {
     data: TData;
 });
-export declare function fallbackORPCErrorStatus(code: CommonORPCErrorCode | (string & {}), status: number | undefined): number;
-export declare function fallbackORPCErrorMessage(code: CommonORPCErrorCode | (string & {}), message: string | undefined): string;
-export declare class ORPCError<TCode extends CommonORPCErrorCode | (string & {}), TData> extends Error {
+export type ORPCErrorOptionsRest<TData> = [options: ORPCErrorOptions<TData>] | (undefined extends TData ? [] : never);
+export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly defined: boolean;
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(options: ORPCErrorOptions<TCode, TData>);
+    constructor(code: TCode, ...[options]: ORPCErrorOptionsRest<TData>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
-    static isValidJSON(json: unknown): json is ORPCErrorJSON<string, unknown>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 }
 export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
-export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
-export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
 //# sourceMappingURL=error-orpc.d.ts.map

package/dist/src/error-utils.d.ts

@@ -0,0 +1,14 @@
+import type { ErrorMap, ErrorMapItem } from './error-map';
+import type { ORPCErrorCode, ORPCErrorOptions } from './error-orpc';
+import type { SchemaInput } from './schema';
+import { ORPCError } from './error-orpc';
+export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+export type ORPCErrorConstructorMapItemRest<TData> = [options: ORPCErrorConstructorMapItemOptions<TData>] | (undefined extends TData ? [] : never);
+export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: ORPCErrorConstructorMapItemRest<TInData>) => ORPCError<TCode, TInData>;
+export type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+//# sourceMappingURL=error-utils.d.ts.map

package/dist/src/index.d.ts

@@ -1,22 +1,19 @@
 /** unnoq */
-import { ContractBuilder } from './builder';
 export * from './builder';
+export * from './builder-variants';
 export * from './client';
 export * from './client-utils';
 export * from './config';
 export * from './error';
 export * from './error-map';
 export * from './error-orpc';
+export * from './error-utils';
+export * from './meta';
 export * from './procedure';
-export * from './procedure-builder';
-export * from './procedure-builder-with-input';
-export * from './procedure-builder-with-output';
 export * from './procedure-client';
-export * from './procedure-decorated';
+export * from './route';
 export * from './router';
-export * from './router-builder';
 export * from './router-client';
-export * from './schema-utils';
+export * from './schema';
 export * from './types';
-export declare const oc: ContractBuilder<Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/meta.d.ts

@@ -0,0 +1,3 @@
+export type Meta = Record<string, any>;
+export declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+//# sourceMappingURL=meta.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -1,6 +1,6 @@
 import type { Client } from './client';
 import type { ErrorFromErrorMap } from './error';
 import type { ErrorMap } from './error-map';
-import type { Schema, SchemaInput, SchemaOutput } from './types';
+import type { Schema, SchemaInput, SchemaOutput } from './schema';
 export type ContractProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,83 +1,18 @@
 import type { ErrorMap } from './error-map';
-import type { HTTPMethod, HTTPPath, InputStructure, OutputStructure, Schema, SchemaOutput } from './types';
-export interface RouteOptions {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    /**
-     * The status code of the response when the procedure is successful.
-     *
-     * @default 200
-     */
-    successStatus?: number;
-    /**
-     * The description of the response when the procedure is successful.
-     *
-     * @default 'OK'
-     */
-    successDescription?: string;
-    /**
-     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
-     *
-     * @option 'compact'
-     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
-     *
-     * @option 'detailed'
-     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
-     *
-     * Example:
-     * ```ts
-     * const input = {
-     *   params: { id: 1 },
-     *   query: { search: 'hello' },
-     *   headers: { 'Content-Type': 'application/json' },
-     *   body: { name: 'John' },
-     * }
-     * ```
-     *
-     * @default 'compact'
-     */
-    inputStructure?: InputStructure;
-    /**
-     * Determines how the response should be structured based on the output.
-     *
-     * @option 'compact'
-     * Includes only the body data, encoded directly in the response.
-     *
-     * @option 'detailed'
-     * Separates the output into `headers` and `body` fields.
-     * - `headers`: Custom headers to merge with the response headers.
-     * - `body`: The response data.
-     *
-     * Example:
-     * ```ts
-     * const output = {
-     *   headers: { 'x-custom-header': 'value' },
-     *   body: { message: 'Hello, world!' },
-     * };
-     * ```
-     *
-     * @default 'compact'
-     */
-    outputStructure?: OutputStructure;
-}
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
-    route?: RouteOptions;
-    InputSchema: TInputSchema;
-    inputExample?: SchemaOutput<TInputSchema>;
-    OutputSchema: TOutputSchema;
-    outputExample?: SchemaOutput<TOutputSchema>;
+import type { Meta } from './meta';
+import type { Route } from './route';
+import type { Schema } from './schema';
+export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema: TInputSchema;
+    outputSchema: TOutputSchema;
     errorMap: TErrorMap;
 }
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> {
-    '~type': "ContractProcedure";
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap>);
+export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
 }
-export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any, any>;
-export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema, ErrorMap>;
-export declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
+export type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+export declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
 //# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -0,0 +1,79 @@
+export type HTTPPath = `/${string}`;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type InputStructure = 'compact' | 'detailed';
+export type OutputStructure = 'compact' | 'detailed';
+export interface Route {
+    method?: HTTPMethod;
+    path?: HTTPPath;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * Includes only the body data, encoded directly in the response.
+     *
+     * @option 'detailed'
+     * Separates the output into `headers` and `body` fields.
+     * - `headers`: Custom headers to merge with the response headers.
+     * - `body`: The response data.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+}
+export declare function mergeRoute(a: Route, b: Route): Route;
+export declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+export declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+export declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+export declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+export interface AdaptRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+export declare function adaptRoute(route: Route, options: AdaptRouteOptions): Route;
+//# sourceMappingURL=route.d.ts.map

package/dist/src/router-client.d.ts

@@ -1,7 +1,7 @@
 import type { ContractProcedure } from './procedure';
 import type { ContractProcedureClient } from './procedure-client';
-import type { ContractRouter } from './router';
-export type ContractRouterClient<TRouter extends ContractRouter<any>, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
-    [K in keyof TRouter]: TRouter[K] extends ContractRouter<any> ? ContractRouterClient<TRouter[K], TClientContext> : never;
+import type { AnyContractRouter } from './router';
+export type ContractRouterClient<TRouter extends AnyContractRouter, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends AnyContractRouter ? ContractRouterClient<TRouter[K], TClientContext> : never;
 };
 //# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,13 +1,29 @@
-import type { ErrorMap } from './error-map';
-import type { ContractProcedure } from './procedure';
-import type { SchemaInput, SchemaOutput } from './types';
-export type ContractRouter<T extends ErrorMap> = ContractProcedure<any, any, T> | {
-    [k: string]: ContractRouter<T>;
+import type { Meta } from './meta';
+import type { SchemaInput, SchemaOutput } from './schema';
+import { type ErrorMap, type MergedErrorMap } from './error-map';
+import { ContractProcedure } from './procedure';
+import { type HTTPPath } from './route';
+export type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
 };
-export type InferContractRouterInputs<T extends ContractRouter<any>> = T extends ContractProcedure<infer UInputSchema, any, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterInputs<T[K]> : never;
+export type AnyContractRouter = ContractRouter<any>;
+export type AdaptedContractRouter<TContract extends AnyContractRouter, TErrorMap extends ErrorMap> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer UMeta> ? ContractProcedure<UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrors>, UMeta> : TContract[K] extends AnyContractRouter ? AdaptedContractRouter<TContract[K], TErrorMap> : never;
 };
-export type InferContractRouterOutputs<T extends ContractRouter<any>> = T extends ContractProcedure<any, infer UOutputSchema, any> ? SchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterOutputs<T[K]> : never;
+export interface AdaptContractRouterOptions<TErrorMap extends ErrorMap> {
+    errorMap: TErrorMap;
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+export declare function adaptContractRouter<TRouter extends ContractRouter<any>, TErrorMap extends ErrorMap>(contract: TRouter, options: AdaptContractRouterOptions<TErrorMap>): AdaptedContractRouter<TRouter, TErrorMap>;
+export type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
 };
+export type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
+};
+export type ContractRouterToErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? ContractRouterToErrorMap<T[K]> : never;
+}[keyof T];
+export type ContractRouterToMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
 //# sourceMappingURL=router.d.ts.map

package/dist/src/schema.d.ts

@@ -0,0 +1,8 @@
+import type { IsEqual, Promisable } from '@orpc/shared';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type Schema = StandardSchemaV1 | undefined;
+export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
+export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/types.d.ts

@@ -1,11 +1,3 @@
 import type { FindGlobalInstanceType } from '@orpc/shared';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type InputStructure = 'compact' | 'detailed';
-export type OutputStructure = 'compact' | 'detailed';
-export type Schema = StandardSchemaV1 | undefined;
-export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
-export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
 export type AbortSignal = FindGlobalInstanceType<'AbortSignal'>;
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,8 +29,8 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-beta.4",
-    "@orpc/shared": "0.32.0"
+    "@standard-schema/spec": "1.0.0-rc.0",
+    "@orpc/shared": "0.33.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",

package/dist/src/procedure-builder-with-input.d.ts

@@ -1,19 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaOutput } from './types';
-import { ContractProcedure } from './procedure';
-import { DecoratedContractProcedure } from './procedure-decorated';
-/**
- * `ContractProcedureBuilderWithInput` is a branch of `ContractProcedureBuilder` which it has input schema.
- *
- * Why?
- * - prevents override input schema after .input
- */
-export declare class ContractProcedureBuilderWithInput<TInputSchema extends Schema, TErrorMap extends ErrorMap> extends ContractProcedure<TInputSchema, undefined, TErrorMap> {
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap & U>;
-    route(route: RouteOptions): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
-    prefix(prefix: HTTPPath): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
-    unshiftTag(...tags: string[]): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap>;
-}
-//# sourceMappingURL=procedure-builder-with-input.d.ts.map

package/dist/src/procedure-builder-with-output.d.ts

@@ -1,19 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaInput } from './types';
-import { ContractProcedure } from './procedure';
-import { DecoratedContractProcedure } from './procedure-decorated';
-/**
- * `ContractProcedureBuilderWithOutput` is a branch of `ContractProcedureBuilder` which it has output schema.
- *
- * Why?
- * - prevents override output schema after .output
- */
-export declare class ContractProcedureBuilderWithOutput<TOutputSchema extends Schema, TErrorMap extends ErrorMap> extends ContractProcedure<undefined, TOutputSchema, TErrorMap> {
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap & U>;
-    route(route: RouteOptions): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
-    prefix(prefix: HTTPPath): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
-    unshiftTag(...tags: string[]): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap>;
-}
-//# sourceMappingURL=procedure-builder-with-output.d.ts.map

package/dist/src/procedure-builder.d.ts

@@ -1,15 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { ContractProcedure } from './procedure';
-import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
-import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
-export declare class ContractProcedureBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilder<TErrorMap & U>;
-    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
-    prefix(prefix: HTTPPath): ContractProcedureBuilder<TErrorMap>;
-    unshiftTag(...tags: string[]): ContractProcedureBuilder<TErrorMap>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
-}
-//# sourceMappingURL=procedure-builder.d.ts.map

package/dist/src/procedure-decorated.d.ts

@@ -1,12 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema } from './types';
-import { ContractProcedure } from './procedure';
-export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap> {
-    static decorate<UInputSchema extends Schema, UOutputSchema extends Schema, TErrorMap extends ErrorMap>(procedure: ContractProcedure<UInputSchema, UOutputSchema, TErrorMap>): DecoratedContractProcedure<UInputSchema, UOutputSchema, TErrorMap>;
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap & U>;
-    route(route: RouteOptions): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    prefix(prefix: HTTPPath): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    unshiftTag(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-}
-//# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/router-builder.d.ts

@@ -1,23 +0,0 @@
-import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
-import type { ContractProcedure } from './procedure';
-import type { ContractRouter } from './router';
-import type { HTTPPath } from './types';
-import { DecoratedContractProcedure } from './procedure-decorated';
-export type AdaptedContractRouter<TContract extends ContractRouter<any>, TErrorMapExtra extends ErrorMap> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors & TErrorMapExtra> : TContract[K] extends ContractRouter<any> ? AdaptedContractRouter<TContract[K], TErrorMapExtra> : never;
-};
-export interface ContractRouterBuilderDef<TErrorMap extends ErrorMap> {
-    prefix?: HTTPPath;
-    tags?: string[];
-    errorMap: TErrorMap;
-}
-export declare class ContractRouterBuilder<TErrorMap extends ErrorMap> {
-    '~type': "ContractProcedure";
-    '~orpc': ContractRouterBuilderDef<TErrorMap>;
-    constructor(def: ContractRouterBuilderDef<TErrorMap>);
-    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
-    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
-    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractRouterBuilder<U & TErrorMap>;
-    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-//# sourceMappingURL=router-builder.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -1,5 +0,0 @@
-import type { IsEqual, Promisable } from '@orpc/shared';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
-export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
-//# sourceMappingURL=schema-utils.d.ts.map