@orpc/contract 1.14.6 → 2.0.0-beta.2

package/dist/plugins/index.mjs

@@ -1,81 +1,90 @@
 import { ORPCError } from '@orpc/client';
-import { get } from '@orpc/shared';
-import { i as isContractProcedure, V as ValidationError, v as validateORPCError } from '../shared/contract.D_dZrO__.mjs';
+import { toArray } from '@orpc/shared';
+import { g as getProcedureContractOrThrow, V as ValidationError, e as reconcileORPCError } from '../shared/contract.CW-2wl1i.mjs';
 
-class RequestValidationPluginError extends Error {
-}
-class RequestValidationPlugin {
-  constructor(contract) {
+class RequestValidationLinkPlugin {
+  constructor(contract, options = {}) {
     this.contract = contract;
+    this.forwardValidatedInput = options.forwardValidatedInput ?? false;
   }
+  name = "~request-validation";
+  forwardValidatedInput;
   init(options) {
-    options.interceptors ??= [];
-    options.interceptors.push(async ({ next, path, input }) => {
-      const procedure = get(this.contract, path);
-      if (!isContractProcedure(procedure)) {
-        throw new RequestValidationPluginError(`No valid procedure found at path "${path.join(".")}", this may happen when the contract router is not properly configured.`);
-      }
-      const inputSchema = procedure["~orpc"].inputSchema;
-      if (inputSchema) {
-        const result = await inputSchema["~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 {
+      ...options,
+      interceptors: [...toArray(options.interceptors), async ({ next, ...interceptorOptions }) => {
+        const procedure = getProcedureContractOrThrow(this.contract, interceptorOptions.path);
+        let currentInput = interceptorOptions.input;
+        if (procedure["~orpc"].inputSchemas) {
+          for (const schema of procedure["~orpc"].inputSchemas) {
+            const result = await schema["~standard"].validate(currentInput);
+            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,
+                  invalidData: currentInput
+                })
+              });
+            }
+            currentInput = result.value;
+          }
         }
-      }
-      return await next();
-    });
+        return this.forwardValidatedInput ? next({ ...interceptorOptions, input: currentInput }) : next();
+      }]
+    };
   }
 }
 
-class ResponseValidationPlugin {
+class ResponseValidationLinkPlugin {
   constructor(contract) {
     this.contract = contract;
   }
-  /**
-   * run before (validate after) retry plugin, because validation failed can't be retried
-   * run before (validate after) durable iterator plugin, because we expect durable iterator to validation (if user use it)
-   */
-  order = 12e5;
+  name = "~response-validation";
   init(options) {
-    options.interceptors ??= [];
-    options.interceptors.push(async ({ next, path }) => {
-      const procedure = get(this.contract, path);
-      if (!isContractProcedure(procedure)) {
-        throw new Error(`[ResponseValidationPlugin] no valid procedure found at path "${path.join(".")}", this may happen when the contract router is not properly configured.`);
-      }
-      try {
-        const output = await next();
-        const outputSchema = procedure["~orpc"].outputSchema;
-        if (!outputSchema) {
+    return {
+      ...options,
+      interceptors: [
+        async ({ next, path }) => {
+          const procedure = getProcedureContractOrThrow(this.contract, path);
+          try {
+            return await next();
+          } catch (error) {
+            if (error instanceof ORPCError) {
+              throw await reconcileORPCError(procedure["~orpc"].errorMap, error);
+            }
+            throw error;
+          }
+        },
+        ...toArray(options.interceptors),
+        async ({ next, path }) => {
+          const procedure = getProcedureContractOrThrow(this.contract, path);
+          const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
+          let output = await next();
+          for (let i = outputSchemas.length - 1; i >= 0; i--) {
+            const schema = outputSchemas[i];
+            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,
+                  invalidData: output
+                })
+              });
+            }
+            output = result.value;
+          }
           return output;
         }
-        const result = await outputSchema["~standard"].validate(output);
-        if (result.issues) {
-          throw new ValidationError({
-            message: "Server response output does not match expected schema",
-            issues: result.issues,
-            data: output
-          });
-        }
-        return result.value;
-      } catch (e) {
-        if (e instanceof ORPCError) {
-          throw await validateORPCError(procedure["~orpc"].errorMap, e);
-        }
-        throw e;
-      }
-    });
+      ]
+    };
   }
 }
 
-export { RequestValidationPlugin, RequestValidationPluginError, ResponseValidationPlugin };
+export { RequestValidationLinkPlugin, ResponseValidationLinkPlugin };

package/dist/shared/contract.CW-2wl1i.mjs

@@ -0,0 +1,180 @@
+import { toArray, getConstructor, isTypescriptObject } from '@orpc/shared';
+import { cloneORPCError } from '@orpc/client';
+
+function mergeErrorMap(errorMap1, errorMap2) {
+  return { ...errorMap1, ...errorMap2 };
+}
+async function reconcileORPCError(map, error) {
+  const config = map[error.code];
+  if (!config) {
+    if (!error.defined) {
+      return error;
+    }
+    const cloned2 = cloneORPCError(error);
+    cloned2.defined = false;
+    cloned2.inferable = false;
+    return cloned2;
+  }
+  if (!config.data) {
+    if (error.defined && error.inferable) {
+      return error;
+    }
+    const cloned2 = cloneORPCError(error);
+    cloned2.defined = true;
+    cloned2.inferable = true;
+    return cloned2;
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    if (!error.defined) {
+      return error;
+    }
+    const cloned2 = cloneORPCError(error);
+    cloned2.defined = false;
+    cloned2.inferable = false;
+    return cloned2;
+  }
+  if (error.data === validated.value && error.defined && error.inferable) {
+    return error;
+  }
+  const cloned = cloneORPCError(error);
+  cloned.data = validated.value;
+  cloned.defined = true;
+  cloned.inferable = true;
+  return cloned;
+}
+
+function resolveMetaPlugins(baseMeta, existingPlugins, incomingPlugins) {
+  existingPlugins = toArray(existingPlugins);
+  incomingPlugins = toArray(incomingPlugins);
+  let meta = baseMeta;
+  for (const plugin of incomingPlugins) {
+    if (plugin.init) {
+      meta = plugin.init(meta);
+    }
+  }
+  const plugins = [...existingPlugins, ...incomingPlugins];
+  for (const plugin of plugins) {
+    if (plugin.apply) {
+      meta = plugin.apply(meta);
+    }
+  }
+  return [meta, plugins];
+}
+function defineMeta(name, merge) {
+  const metaPlugin = (value) => ({
+    name,
+    init: (meta) => {
+      const current = meta[name];
+      return {
+        ...meta,
+        [name]: merge(value, current)
+      };
+    }
+  });
+  const getMeta = (procedureOrLazy) => procedureOrLazy["~orpc"].meta[name];
+  return [metaPlugin, getMeta];
+}
+
+class ProcedureContract {
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+  /**
+   * Checks if the given instance satisfies the {@see ProcedureContract} class/interface.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (this !== ProcedureContract) {
+      return Function.prototype[Symbol.hasInstance].call(this, instance);
+    }
+    const constructor = getConstructor(instance);
+    if (constructor === ProcedureContract) {
+      return true;
+    }
+    return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].errorMap) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].inputSchemas === void 0 || Array.isArray(instance["~orpc"].inputSchemas)) && (instance["~orpc"].outputSchemas === void 0 || Array.isArray(instance["~orpc"].outputSchemas));
+  }
+}
+
+function augmentContractRouter(router, options) {
+  if (router instanceof ProcedureContract) {
+    const [meta, metaPlugins] = resolveMetaPlugins(
+      options.meta,
+      options.metaPlugins,
+      router["~orpc"].metaPlugins
+    );
+    const enhanced2 = new ProcedureContract({
+      ...router["~orpc"],
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      meta,
+      metaPlugins
+    });
+    return enhanced2;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = augmentContractRouter(router[key], options);
+  }
+  return enhanced;
+}
+function getRouterContract(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!isTypescriptObject(current)) {
+      return void 0;
+    }
+    if (current instanceof ProcedureContract) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  if (!isTypescriptObject(current)) {
+    return void 0;
+  }
+  return current;
+}
+function getProcedureContractOrThrow(router, path) {
+  const procedure = getRouterContract(router, path);
+  if (!(procedure instanceof ProcedureContract)) {
+    throw new TypeError(`No valid procedure found at path "${path.join(".")}", this may happen when the router contract is not properly configured.`);
+  }
+  return procedure;
+}
+function minifyRouterContract(router) {
+  if (router instanceof ProcedureContract) {
+    const procedure = {
+      "~orpc": {
+        errorMap: {},
+        meta: router["~orpc"].meta
+      }
+    };
+    return procedure;
+  }
+  if (!isTypescriptObject(router)) {
+    return router;
+  }
+  const json = {};
+  for (const key in router) {
+    json[key] = minifyRouterContract(router[key]);
+  }
+  return json;
+}
+
+class ValidationError extends Error {
+  /**
+   * This array is readonly because the upstream Standard Schema returns readonly issues.
+   */
+  issues;
+  invalidData;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+    this.invalidData = options.invalidData;
+  }
+}
+
+export { ProcedureContract as P, ValidationError as V, augmentContractRouter as a, getRouterContract as b, minifyRouterContract as c, defineMeta as d, reconcileORPCError as e, getProcedureContractOrThrow as g, mergeErrorMap as m, resolveMetaPlugins as r };

package/dist/shared/contract.Do92aRJ4.d.mts

@@ -0,0 +1,126 @@
+import { ThrowableError } from '@orpc/shared';
+import { ORPCErrorCode, ORPCError } from '@orpc/client';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/**
+ * TOutput default = TInput for better readability (shorter) in-case both TInput, TOutput is equal
+ */
+type Schema<TInput, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type MergedSchema<T extends AnySchema, U extends AnySchema> = T extends Schema<infer TInput, infer TOutput> ? U extends Schema<infer UInput, infer UOutput> ? Schema<TInput & UInput, TOutput & UOutput> : never : never;
+
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    message?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+    invalidData: unknown;
+}
+declare class ValidationError extends Error {
+    /**
+     * This array is readonly because the upstream Standard Schema returns readonly issues.
+     */
+    issues: readonly SchemaIssue[];
+    invalidData: unknown;
+    constructor(options: ValidationErrorOptions);
+}
+
+interface Meta {
+    [key: PropertyKey]: unknown;
+}
+interface MetaPluginDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    __TInputSchema?: {
+        type: TInputSchema;
+    };
+    __TOutputSchema?: {
+        type: TOutputSchema;
+    };
+    __TErrorMap?: {
+        type: TErrorMap;
+    };
+}
+interface MetaPlugin<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    /** This only for types, so it should be optional */
+    '~orpc'?: MetaPluginDefinition<TInputSchema, TOutputSchema, TErrorMap> | undefined;
+    /** Unique name of the plugin, used for identification. */
+    'name': string;
+    /**
+     * Runs once when this plugin is first added to the builder.
+     * Use this to set up initial metadata values.
+     */
+    'init'?: (meta: Meta) => Meta;
+    /**
+     * Runs every time metadata is updated.
+     * This is called for all plugins in the chain whenever a new plugin is added.
+     */
+    'apply'?: (meta: Meta) => Meta;
+}
+type AnyMetaPlugin = MetaPlugin<any, any, any>;
+declare const HIDDEN_META_PLUGINS_SYMBOL: unique symbol;
+declare function getHiddenMetaPlugins(container: unknown): AnyMetaPlugin[] | undefined;
+declare function setHiddenMetaPlugins<T extends object>(container: T, metaPlugins: AnyMetaPlugin[]): void;
+
+interface ProcedureContractDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    __TInputSchema?: {
+        type: TInputSchema;
+    };
+    __TOutputSchema?: {
+        type: TOutputSchema;
+    };
+    /**
+     * Non-serializable should be optional
+     */
+    inputSchemas?: AnySchema[] | undefined;
+    outputSchemas?: AnySchema[] | undefined;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    errorMap: TErrorMap;
+    meta: Meta;
+}
+declare class ProcedureContract<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>);
+    /**
+     * Checks if the given instance satisfies the {@see ProcedureContract} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AnyProcedureContract = ProcedureContract<any, any, any>;
+
+type RouterContract = AnyProcedureContract | {
+    [k: string]: RouterContract;
+};
+type InferRouterContractInputs<T extends RouterContract> = T extends ProcedureContract<infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractInputs<T[K]> : never;
+};
+type InferRouterContractOutputs<T extends RouterContract> = T extends ProcedureContract<any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractOutputs<T[K]> : never;
+};
+type InferRouterContractErrorMap<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? UErrorMap : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrorMap<T[K]> : never;
+}[keyof T];
+/**
+ * Infer the union of throwable errors for entire router-contract.
+ */
+type InferRouterContractError<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractError<T[K]> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure-contract, preserving the router-contract shape.
+ */
+type InferRouterContractErrors<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrors<T[K]> : never;
+};
+
+export { HIDDEN_META_PLUGINS_SYMBOL as H, ProcedureContract as P, ValidationError as V, getHiddenMetaPlugins as p, setHiddenMetaPlugins as s };
+export type { AnySchema as A, ErrorMap as E, InferSchemaInput as I, MetaPlugin as M, ORPCErrorFromErrorMap as O, RouterContract as R, Schema as S, MergedSchema as a, Meta as b, AnyMetaPlugin as c, AnyProcedureContract as d, InferSchemaOutput as e, SchemaIssue as f, ErrorMapItem as g, InferRouterContractError as h, InferRouterContractErrorMap as i, InferRouterContractErrors as j, InferRouterContractInputs as k, InferRouterContractOutputs as l, MetaPluginDefinition as m, ProcedureContractDefinition as n, ValidationErrorOptions as o };

package/dist/shared/contract.Do92aRJ4.d.ts

@@ -0,0 +1,126 @@
+import { ThrowableError } from '@orpc/shared';
+import { ORPCErrorCode, ORPCError } from '@orpc/client';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/**
+ * TOutput default = TInput for better readability (shorter) in-case both TInput, TOutput is equal
+ */
+type Schema<TInput, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type MergedSchema<T extends AnySchema, U extends AnySchema> = T extends Schema<infer TInput, infer TOutput> ? U extends Schema<infer UInput, infer UOutput> ? Schema<TInput & UInput, TOutput & UOutput> : never : never;
+
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    message?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+    invalidData: unknown;
+}
+declare class ValidationError extends Error {
+    /**
+     * This array is readonly because the upstream Standard Schema returns readonly issues.
+     */
+    issues: readonly SchemaIssue[];
+    invalidData: unknown;
+    constructor(options: ValidationErrorOptions);
+}
+
+interface Meta {
+    [key: PropertyKey]: unknown;
+}
+interface MetaPluginDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    __TInputSchema?: {
+        type: TInputSchema;
+    };
+    __TOutputSchema?: {
+        type: TOutputSchema;
+    };
+    __TErrorMap?: {
+        type: TErrorMap;
+    };
+}
+interface MetaPlugin<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    /** This only for types, so it should be optional */
+    '~orpc'?: MetaPluginDefinition<TInputSchema, TOutputSchema, TErrorMap> | undefined;
+    /** Unique name of the plugin, used for identification. */
+    'name': string;
+    /**
+     * Runs once when this plugin is first added to the builder.
+     * Use this to set up initial metadata values.
+     */
+    'init'?: (meta: Meta) => Meta;
+    /**
+     * Runs every time metadata is updated.
+     * This is called for all plugins in the chain whenever a new plugin is added.
+     */
+    'apply'?: (meta: Meta) => Meta;
+}
+type AnyMetaPlugin = MetaPlugin<any, any, any>;
+declare const HIDDEN_META_PLUGINS_SYMBOL: unique symbol;
+declare function getHiddenMetaPlugins(container: unknown): AnyMetaPlugin[] | undefined;
+declare function setHiddenMetaPlugins<T extends object>(container: T, metaPlugins: AnyMetaPlugin[]): void;
+
+interface ProcedureContractDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    __TInputSchema?: {
+        type: TInputSchema;
+    };
+    __TOutputSchema?: {
+        type: TOutputSchema;
+    };
+    /**
+     * Non-serializable should be optional
+     */
+    inputSchemas?: AnySchema[] | undefined;
+    outputSchemas?: AnySchema[] | undefined;
+    metaPlugins?: AnyMetaPlugin[] | undefined;
+    errorMap: TErrorMap;
+    meta: Meta;
+}
+declare class ProcedureContract<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+    constructor(def: ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>);
+    /**
+     * Checks if the given instance satisfies the {@see ProcedureContract} class/interface.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
+}
+type AnyProcedureContract = ProcedureContract<any, any, any>;
+
+type RouterContract = AnyProcedureContract | {
+    [k: string]: RouterContract;
+};
+type InferRouterContractInputs<T extends RouterContract> = T extends ProcedureContract<infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractInputs<T[K]> : never;
+};
+type InferRouterContractOutputs<T extends RouterContract> = T extends ProcedureContract<any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractOutputs<T[K]> : never;
+};
+type InferRouterContractErrorMap<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? UErrorMap : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrorMap<T[K]> : never;
+}[keyof T];
+/**
+ * Infer the union of throwable errors for entire router-contract.
+ */
+type InferRouterContractError<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractError<T[K]> : never;
+}[keyof T];
+/**
+ * Infer throwable errors for each procedure-contract, preserving the router-contract shape.
+ */
+type InferRouterContractErrors<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
+    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrors<T[K]> : never;
+};
+
+export { HIDDEN_META_PLUGINS_SYMBOL as H, ProcedureContract as P, ValidationError as V, getHiddenMetaPlugins as p, setHiddenMetaPlugins as s };
+export type { AnySchema as A, ErrorMap as E, InferSchemaInput as I, MetaPlugin as M, ORPCErrorFromErrorMap as O, RouterContract as R, Schema as S, MergedSchema as a, Meta as b, AnyMetaPlugin as c, AnyProcedureContract as d, InferSchemaOutput as e, SchemaIssue as f, ErrorMapItem as g, InferRouterContractError as h, InferRouterContractErrorMap as i, InferRouterContractErrors as j, InferRouterContractInputs as k, InferRouterContractOutputs as l, MetaPluginDefinition as m, ProcedureContractDefinition as n, ValidationErrorOptions as o };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "1.14.6",
+  "version": "2.0.0-beta.2",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -14,6 +14,7 @@
   ],
   "sideEffects": false,
   "exports": {
+    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
@@ -30,18 +31,16 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "openapi-types": "^12.1.3",
-    "@orpc/shared": "1.14.6",
-    "@orpc/client": "1.14.6"
+    "@orpc/client": "2.0.0-beta.2",
+    "@orpc/shared": "2.0.0-beta.2"
   },
   "devDependencies": {
-    "arktype": "2.2.0",
+    "arktype": "^2.1.29",
     "valibot": "^1.2.0",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "scripts": {
     "build": "unbuild",
-    "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/contract.D_dZrO__.mjs

@@ -1,53 +0,0 @@
-import { fallbackORPCErrorStatus, ORPCError, isORPCErrorStatus } from '@orpc/client';
-
-class ValidationError extends Error {
-  issues;
-  data;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
-    this.data = options.data;
-  }
-}
-function mergeErrorMap(errorMap1, errorMap2) {
-  return { ...errorMap1, ...errorMap2 };
-}
-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(code, { defined: false, status, message, data, cause }) : error;
-  }
-  if (!config.data) {
-    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(code, { defined: false, status, message, data, cause }) : error;
-  }
-  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
-}
-
-class ContractProcedure {
-  /**
-   * This property holds the defined options for the contract procedure.
-   */
-  "~orpc";
-  constructor(def) {
-    if (def.route?.successStatus && isORPCErrorStatus(def.route.successStatus)) {
-      throw new Error("[ContractProcedure] Invalid successStatus.");
-    }
-    if (Object.values(def.errorMap).some((val) => val && val.status && !isORPCErrorStatus(val.status))) {
-      throw new Error("[ContractProcedure] Invalid error status code.");
-    }
-    this["~orpc"] = def;
-  }
-}
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
-}
-
-export { ContractProcedure as C, ValidationError as V, isContractProcedure as i, mergeErrorMap as m, validateORPCError as v };