@temporary-name/server 1.9.3-alpha.5537ef74244620c125352bc9356d8c0ae804f10d → 1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e

package/dist/index.mjs

@@ -1,134 +1,13 @@
+import { mergePrefix, mergeTags, ContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, prefixRoute, initialSchemas, isContractProcedure, getContractRouter } from '@temporary-name/contract';
+export { ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
 import { onError, resolveMaybeOptionalOptions } from '@temporary-name/shared';
 export { AsyncIteratorClass, EventPublisher, ORPCError, asyncIteratorToStream as eventIteratorToStream, isDefinedError, onError, onFinish, onStart, onSuccess, safe, streamToAsyncIteratorClass as streamToEventIterator } from '@temporary-name/shared';
-import { isContractProcedure, mergeErrorMap, mergeMeta, mergeRoute, mergePrefix, enhanceRoute, mergeTags, ContractProcedure, prefixRoute, getContractRouter } from '@temporary-name/contract';
-export { ValidationError, eventIterator, validateORPCError } from '@temporary-name/contract';
 import { SchemaClass, gatingContext } from '@temporary-name/zod';
-import { c as createProcedureClient, i as isLazy, g as getLazyMeta, l as lazy, u as unlazy } from './shared/server.DcfsPloY.mjs';
-export { L as LAZY_SYMBOL, a as createORPCErrorConstructorMap, m as mergeCurrentContext, b as middlewareOutputFn } from './shared/server.DcfsPloY.mjs';
+import { P as Procedure, c as createProcedureClient, e as enhanceRouter, a as addMiddleware, s as setHiddenRouterContract, l as lazyInternal, g as getLazyMeta, u as unlazy, i as isProcedure, b as isLazy, d as getRouter } from './shared/server.BdGbIyq8.mjs';
+export { L as LAZY_SYMBOL, p as createAccessibleLazyRouter, f as createORPCErrorConstructorMap, o as getHiddenRouterContract, k as isStartWithMiddlewares, h as lazy, m as mergeCurrentContext, n as mergeMiddlewares, j as middlewareOutputFn, r as resolveContractProcedures, t as traverseContractProcedures, q as unlazyRouter } from './shared/server.BdGbIyq8.mjs';
 export { getEventMeta, withEventMeta } from '@temporary-name/standard-server';
 
-function isStartWithMiddlewares(middlewares, compare) {
-  if (compare.length > middlewares.length) {
-    return false;
-  }
-  for (let i = 0; i < middlewares.length; i++) {
-    if (compare[i] === void 0) {
-      return true;
-    }
-    if (middlewares[i] !== compare[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function mergeMiddlewares(first, second, options) {
-  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
-    return second;
-  }
-  return [...first, ...second];
-}
-function addMiddleware(middlewares, addition) {
-  return [...middlewares, addition];
-}
-
-function decorateMiddleware(middleware) {
-  const decorated = ((...args) => middleware(...args));
-  decorated.mapInput = (mapInput) => {
-    const mapped = decorateMiddleware(
-      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
-    );
-    return mapped;
-  };
-  decorated.concat = (concatMiddleware, mapInput) => {
-    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
-    const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const merged = middleware(
-        {
-          ...options,
-          next: (...[nextOptions1]) => mapped(
-            {
-              ...options,
-              context: { ...options.context, ...nextOptions1?.context },
-              next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
-            },
-            input,
-            output,
-            ...rest
-          )
-        },
-        input,
-        output,
-        ...rest
-      );
-      return merged;
-    });
-    return concatted;
-  };
-  return decorated;
-}
-
-class Procedure {
-  /**
-   * This property holds the defined options.
-   */
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-}
-function isProcedure(item) {
-  if (item instanceof Procedure) {
-    return true;
-  }
-  return isContractProcedure(item) && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
-}
-
 class DecoratedProcedure extends Procedure {
-  /**
-   * Adds type-safe custom errors.
-   * The provided errors are spared-merged with any existing errors.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
-   */
-  errors(errors) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
-  /**
-   * Sets or updates the metadata.
-   * The provided metadata is spared-merged with any existing metadata.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
-   */
-  meta(meta) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
-    });
-  }
-  /**
-   * Sets or updates the route definition.
-   * The provided route is spared-merged with any existing route.
-   * This option is typically relevant when integrating with OpenAPI.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
-   * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
-   */
-  route(route) {
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
-    });
-  }
-  use(middleware, mapInput) {
-    const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new DecoratedProcedure({
-      ...this["~orpc"],
-      middlewares: addMiddleware(this["~orpc"].middlewares, mapped)
-    });
-  }
   /**
    * Make this procedure callable (works like a function while still being a procedure).
    *
@@ -147,152 +26,6 @@ class DecoratedProcedure extends Procedure {
   }
 }
 
-const HIDDEN_ROUTER_CONTRACT_SYMBOL = Symbol("ORPC_HIDDEN_ROUTER_CONTRACT");
-function setHiddenRouterContract(router, contract) {
-  return new Proxy(router, {
-    get(target, key) {
-      if (key === HIDDEN_ROUTER_CONTRACT_SYMBOL) {
-        return contract;
-      }
-      return Reflect.get(target, key);
-    }
-  });
-}
-function getHiddenRouterContract(router) {
-  return router[HIDDEN_ROUTER_CONTRACT_SYMBOL];
-}
-
-function getRouter(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!current) {
-      return void 0;
-    }
-    if (isProcedure(current)) {
-      return void 0;
-    }
-    if (!isLazy(current)) {
-      current = current[segment];
-      continue;
-    }
-    const lazied = current;
-    const rest = path.slice(i);
-    return lazy(async () => {
-      const unwrapped = await unlazy(lazied);
-      const next = getRouter(unwrapped.default, rest);
-      return unlazy(next);
-    }, getLazyMeta(lazied));
-  }
-  return current;
-}
-function createAccessibleLazyRouter(lazied) {
-  const recursive = new Proxy(lazied, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      const next = getRouter(lazied, [key]);
-      return createAccessibleLazyRouter(next);
-    }
-  });
-  return recursive;
-}
-function enhanceRouter(router, options) {
-  if (isLazy(router)) {
-    const laziedMeta = getLazyMeta(router);
-    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
-    const enhanced2 = lazy(
-      async () => {
-        const { default: unlaziedRouter } = await unlazy(router);
-        const enhanced3 = enhanceRouter(unlaziedRouter, options);
-        return unlazy(enhanced3);
-      },
-      {
-        ...laziedMeta,
-        prefix: enhancedPrefix
-      }
-    );
-    const accessible = createAccessibleLazyRouter(enhanced2);
-    return accessible;
-  }
-  if (isProcedure(router)) {
-    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
-      dedupeLeading: options.dedupeLeadingMiddlewares
-    });
-    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
-    const enhanced2 = new Procedure({
-      ...router["~orpc"],
-      route: enhanceRoute(router["~orpc"].route, options),
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      middlewares: newMiddlewares,
-      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
-      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
-    });
-    return enhanced2;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = enhanceRouter(router[key], options);
-  }
-  return enhanced;
-}
-function traverseContractProcedures(options, callback, lazyOptions = []) {
-  let currentRouter = options.router;
-  const hiddenContract = getHiddenRouterContract(options.router);
-  if (hiddenContract !== void 0) {
-    currentRouter = hiddenContract;
-  }
-  if (isLazy(currentRouter)) {
-    lazyOptions.push({
-      router: currentRouter,
-      path: options.path
-    });
-  } else if (isContractProcedure(currentRouter)) {
-    callback({
-      contract: currentRouter,
-      path: options.path
-    });
-  } else {
-    for (const key in currentRouter) {
-      traverseContractProcedures(
-        {
-          router: currentRouter[key],
-          path: [...options.path, key]
-        },
-        callback,
-        lazyOptions
-      );
-    }
-  }
-  return lazyOptions;
-}
-async function resolveContractProcedures(options, callback) {
-  const pending = [options];
-  for (const options2 of pending) {
-    const lazyOptions = traverseContractProcedures(options2, callback);
-    for (const options3 of lazyOptions) {
-      const { default: router } = await unlazy(options3.router);
-      pending.push({
-        router,
-        path: options3.path
-      });
-    }
-  }
-}
-async function unlazyRouter(router) {
-  if (isProcedure(router)) {
-    return router;
-  }
-  const unlazied = {};
-  for (const key in router) {
-    const item = router[key];
-    const { default: unlaziedRouter } = await unlazy(item);
-    unlazied[key] = await unlazyRouter(unlaziedRouter);
-  }
-  return unlazied;
-}
-
 class ProcedureBuilder extends ContractProcedure {
   z;
   constructor(def) {
@@ -346,7 +79,10 @@ class ProcedureBuilder extends ContractProcedure {
   input(schema) {
     return new ProcedureBuilder({
       ...this["~orpc"],
-      inputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        inputSchema: schema
+      },
       inputValidationIndex: this["~orpc"].middlewares.length
     });
   }
@@ -358,7 +94,10 @@ class ProcedureBuilder extends ContractProcedure {
   output(schema) {
     return new ProcedureBuilder({
       ...this["~orpc"],
-      outputSchema: schema,
+      schemas: {
+        ...this["~orpc"].schemas,
+        outputSchema: schema
+      },
       outputValidationIndex: this["~orpc"].middlewares.length
     });
   }
@@ -430,15 +169,42 @@ class BuilderWithMiddlewares extends ProcedureBuilder {
   router(router) {
     return enhanceRouter(router, this["~orpc"]);
   }
-  /**
-   * Create a lazy router
-   * And applies all of the previously defined options to the specified router.
-   *
-   * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
-   */
-  lazyRoute(loader) {
-    return enhanceRouter(lazy(loader), this["~orpc"]);
-  }
+}
+
+function decorateMiddleware(middleware) {
+  const decorated = ((...args) => middleware(...args));
+  decorated.mapInput = (mapInput) => {
+    const mapped = decorateMiddleware(
+      (options, input, ...rest) => middleware(options, mapInput(input), ...rest)
+    );
+    return mapped;
+  };
+  decorated.concat = (concatMiddleware, mapInput) => {
+    const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
+    const concatted = decorateMiddleware((options, input, output, ...rest) => {
+      const merged = middleware(
+        {
+          ...options,
+          next: (...[nextOptions1]) => mapped(
+            {
+              ...options,
+              context: { ...options.context, ...nextOptions1?.context },
+              next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+            },
+            input,
+            output,
+            ...rest
+          )
+        },
+        input,
+        output,
+        ...rest
+      );
+      return merged;
+    });
+    return concatted;
+  };
+  return decorated;
 }
 
 class Builder extends BuilderWithMiddlewares {
@@ -471,6 +237,7 @@ function createApiBuilder(opts = {}) {
         console.dir(error, { depth: null });
       })
     ],
+    schemas: initialSchemas,
     // NB: this is a relic from orpc -- I'm not convinced there's a need for this (or if there is, that it's
     // the best solution). For now I've removed the interface to configure it externally.
     dedupeLeadingMiddlewares: true
@@ -512,17 +279,6 @@ function implementerInternal(contract, middlewares) {
           });
           return setHiddenRouterContract(adapted, contract);
         };
-      } else if (key === "lazyRoute") {
-        method = (loader) => {
-          const adapted = enhanceRouter(lazy(loader), {
-            middlewares,
-            errorMap: {},
-            prefix: void 0,
-            tags: void 0,
-            dedupeLeadingMiddlewares: true
-          });
-          return setHiddenRouterContract(adapted, contract);
-        };
       }
       const next = getContractRouter(target, [key]);
       if (!next) {
@@ -564,7 +320,7 @@ function implement(contract) {
 }
 
 function createAssertedLazyProcedure(lazied) {
-  const lazyProcedure = lazy(async () => {
+  const lazyProcedure = lazyInternal(async () => {
     const { default: maybeProcedure } = await unlazy(lazied);
     if (!isProcedure(maybeProcedure)) {
       throw new Error(`
@@ -615,4 +371,4 @@ function createRouterClient(router, ...rest) {
   return recursive;
 }
 
-export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createAccessibleLazyRouter, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getHiddenRouterContract, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, isStartWithMiddlewares, lazy, mergeMiddlewares, os, resolveContractProcedures, setHiddenRouterContract, traverseContractProcedures, unlazy, unlazyRouter };
+export { Builder, BuilderWithMiddlewares, DecoratedProcedure, Procedure, ProcedureBuilder, addMiddleware, call, createApiBuilder, createAssertedLazyProcedure, createContractedProcedure, createProcedureClient, createRouterClient, decorateMiddleware, enhanceRouter, getLazyMeta, getRouter, implement, implementerInternal, isLazy, isProcedure, lazyInternal, os, setHiddenRouterContract, unlazy };

package/dist/openapi/index.mjs

@@ -1,7 +1,7 @@
 import { isProcedure, resolveContractProcedures, ORPCError, createRouterClient } from '@temporary-name/server';
 import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@temporary-name/contract';
 import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value, toHttpPath, isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage, resolveMaybeOptionalOptions, createORPCErrorFromJson } from '@temporary-name/shared';
-import { a as standardizeHTTPPath, j as jsonSerialize, g as getDynamicParams, d as deserialize, s as serialize } from '../shared/server.BEHw7Eyx.mjs';
+import { a as standardizeHTTPPath, j as jsonSerialize, g as getDynamicParams, d as deserialize, s as serialize } from '../shared/server.Kxw442A9.mjs';
 import '@temporary-name/standard-server';
 import { TypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
 export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
@@ -530,7 +530,7 @@ ${errors.join("\n\n")}`
   }
   async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
+    const details = getEventIteratorSchemaDetails(def.schemas.inputSchema);
     if (details) {
       ref.requestBody = {
         required: true,
@@ -542,82 +542,48 @@ ${errors.join("\n\n")}`
       return;
     }
     const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
-    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = await this.converter.convert(def.inputSchema, {
+    let [required, schema] = await this.converter.convert(def.schemas.inputSchema, {
       ...baseSchemaConvertOptions,
       strategy: "input",
-      minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+      minStructureDepthForRef: dynamicParams?.length ? 1 : 0
     });
     if (isAnySchema(schema) && !dynamicParams?.length) {
       return;
     }
-    if (inputStructure === "compact") {
-      if (dynamicParams?.length) {
-        const error2 = new OpenAPIGeneratorError(
-          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
-        );
-        if (!isObjectSchema(schema)) {
-          throw error2;
-        }
-        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
-        schema = rest;
-        required = rest.required ? rest.required.length !== 0 : false;
-        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
-          throw error2;
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+    if (dynamicParams?.length) {
+      const error = new OpenAPIGeneratorError(
+        'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+      );
+      if (!isObjectSchema(schema)) {
+        throw error;
       }
-      if (method === "GET") {
-        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);
-        if (!isObjectSchema(resolvedSchema)) {
-          throw new OpenAPIGeneratorError(
-            'When method is "GET", input schema must satisfy: object | any | unknown'
-          );
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
-      } else {
-        ref.requestBody = {
-          required,
-          content: toOpenAPIContent(schema)
-        };
+      const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+      schema = rest;
+      required = rest.required ? rest.required.length !== 0 : false;
+      if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+        throw error;
       }
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(schema)) {
-      throw error;
-    }
-    const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;
-    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {
-      throw new OpenAPIGeneratorError(
-        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
-      );
-    }
-    for (const from of ["params", "query", "headers"]) {
-      const fromSchema = schema.properties?.[from];
-      if (fromSchema !== void 0) {
-        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);
-        if (!isObjectSchema(resolvedSchema)) {
-          throw error;
-        }
-        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+    }
+    if (method === "GET") {
+      const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, schema);
+      if (!isObjectSchema(resolvedSchema)) {
+        throw new OpenAPIGeneratorError(
+          'When method is "GET", input schema must satisfy: object | any | unknown'
+        );
       }
-    }
-    if (schema.properties?.body !== void 0) {
+      ref.parameters ??= [];
+      ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
+    } else {
       ref.requestBody = {
-        required: schema.required?.includes("body"),
-        content: toOpenAPIContent(schema.properties.body)
+        required,
+        content: toOpenAPIContent(schema)
       };
     }
   }
   async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
-    const outputSchema = def.outputSchema;
+    const outputSchema = def.schemas.outputSchema;
     const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
     const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
     const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.C-j2WKJz.mjs';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.Bzrdopnd.mjs';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.TgmlNh8r.mjs';
+import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.B5czSQQh.mjs';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable, ORPCError } from '@temporary-name/shared';
 import { StandardRequest, StandardHeaders } from '@temporary-name/standard-server';
 import { BatchResponseBodyItem } from '@temporary-name/standard-server/batch';
-import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.B9i6p26R.js';
-import { C as Context, E as ProcedureClientInterceptorOptions } from '../shared/server.Bzrdopnd.js';
+import { S as StandardHandlerInterceptorOptions, a as StandardHandlerPlugin, b as StandardHandlerOptions } from '../shared/server.C4l2ZA3m.js';
+import { C as Context, H as ProcedureClientInterceptorOptions } from '../shared/server.B5czSQQh.js';
 import { Meta } from '@temporary-name/contract';
 
 interface BatchHandlerOptions<T extends Context> {