@temporary-name/server 1.9.3-alpha.ec3bfb9dce56198911349c322c970208b21b50db → 1.9.3-alpha.edd373b82156a10608d43b19a44b75ae72e72de7

package/dist/shared/{server.Cza0RB3u.mjs → server.BCY45g2x.mjs}

@@ -1,7 +1,7 @@
 import { resolveMaybeOptionalOptions, toArray, value, runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, ORPCError } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
 import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
-import { u as unlazy, V as ValidationError } from './server.ChOv1yG3.mjs';
+import { u as unlazy, V as ValidationError } from './server.BETu17rq.mjs';
 
 function mergeCurrentContext(context, other) {
   return { ...context, ...other };

package/dist/shared/{server.ChOv1yG3.mjs → server.BETu17rq.mjs}

@@ -316,4 +316,4 @@ function parseEndpointDefinition(stringsOrEndpoint, values) {
   return { method, path, pathSchema };
 }
 
-export { Contract as C, LAZY_SYMBOL as L, Procedure as P, ValidationError as V, mergeTags as a, mergeRoute as b, prefixRoute as c, addMiddleware as d, enhanceRouter as e, getLazyMeta as f, getDynamicParams as g, isLazy as h, isProcedure as i, getRouter as j, lazy as k, lazyInternal as l, mergePrefix as m, isStartWithMiddlewares as n, mergeMiddlewares as o, parseEndpointDefinition as p, createAccessibleLazyRouter as q, resolveContractProcedures as r, standardizeHTTPPath as s, traverseContractProcedures as t, unlazy as u, unlazyRouter as v, endpointRegex as w };
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, ValidationError as V, mergeTags as a, mergeRoute as b, prefixRoute as c, addMiddleware as d, enhanceRouter as e, getLazyMeta as f, getDynamicParams as g, lazy as h, isProcedure as i, isLazy as j, isStartWithMiddlewares as k, lazyInternal as l, mergePrefix as m, mergeMiddlewares as n, getRouter as o, parseEndpointDefinition as p, createAccessibleLazyRouter as q, resolveContractProcedures as r, standardizeHTTPPath as s, traverseContractProcedures as t, unlazy as u, unlazyRouter as v, endpointRegex as w };

package/dist/shared/server.B_oW_rPl.mjs

@@ -0,0 +1,525 @@
+import { isAsyncIteratorObject, ORPCError, toArray } from '@temporary-name/shared';
+import { mapEventIterator } from '@temporary-name/standard-server';
+import { custom, safeParseAsync } from '@temporary-name/zod';
+import { V as ValidationError } from './server.BETu17rq.mjs';
+import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@temporary-name/server/openapi';
+import { registry, globalRegistry } from 'zod/v4/core';
+
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_DETAILS");
+function eventIterator(yields, returns) {
+  const schema = custom(
+    (iterator) => isAsyncIteratorObject(iterator)
+  ).transform((iterator) => {
+    const mapped = mapEventIterator(iterator, {
+      async value(value, done) {
+        const schema2 = done ? returns : yields;
+        if (!schema2) {
+          return value;
+        }
+        const result = await safeParseAsync(schema2, value);
+        if (result.success) {
+          return result.data;
+        } else {
+          throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
+            message: "Event iterator validation failed",
+            cause: new ValidationError({
+              issues: result.error.issues,
+              message: "Event iterator validation failed",
+              data: value
+            })
+          });
+        }
+      },
+      error: async (error) => error
+    });
+    return mapped;
+  });
+  schema[EVENT_ITERATOR_DETAILS_SYMBOL] = {
+    yields,
+    returns
+  };
+  return schema;
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema[EVENT_ITERATOR_DETAILS_SYMBOL];
+}
+
+var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
+  JsonSchemaXNativeType2["BigInt"] = "bigint";
+  JsonSchemaXNativeType2["RegExp"] = "regexp";
+  JsonSchemaXNativeType2["Date"] = "date";
+  JsonSchemaXNativeType2["Url"] = "url";
+  JsonSchemaXNativeType2["Set"] = "set";
+  JsonSchemaXNativeType2["Map"] = "map";
+  return JsonSchemaXNativeType2;
+})(JsonSchemaXNativeType || {});
+
+const JSON_SCHEMA_REGISTRY = registry();
+const JSON_SCHEMA_INPUT_REGISTRY = registry();
+const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
+
+class ZodToJsonSchemaConverter {
+  maxLazyDepth;
+  maxStructureDepth;
+  anyJsonSchema;
+  unsupportedJsonSchema;
+  undefinedJsonSchema;
+  constructor(options = {}) {
+    this.maxLazyDepth = options.maxLazyDepth ?? 2;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
+    this.anyJsonSchema = options.anyJsonSchema ?? {};
+    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
+    this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
+  }
+  convert = (schema, options) => {
+    return this.#convert(schema, options, 0, 0);
+  };
+  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
+    if (structureDepth > this.maxStructureDepth) {
+      return [false, this.anyJsonSchema];
+    }
+    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
+      const components = toArray(options.components);
+      for (const component of components) {
+        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
+          return [component.required, { $ref: component.ref }];
+        }
+      }
+    }
+    if (!isHandledCustomJSONSchema) {
+      const customJSONSchema = this.#getCustomJsonSchema(schema, options);
+      if (customJSONSchema) {
+        const [required, json] = this.#convert(schema, options, lazyDepth, structureDepth, true);
+        return [required, { ...json, ...customJSONSchema }];
+      }
+    }
+    switch (schema._zod.def.type) {
+      case "string": {
+        const string = schema;
+        const json = { type: "string" };
+        const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+        if (typeof minimum === "number") {
+          json.minLength = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxLength = maximum;
+        }
+        if (typeof contentEncoding === "string") {
+          json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+        }
+        if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
+          json.format = this.#handleStringFormat(format);
+        }
+        if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
+          for (const pattern of patterns) {
+            if (json.pattern === void 0) {
+              json.pattern = pattern.source;
+            } else {
+              json.allOf ??= [];
+              json.allOf.push({ pattern: pattern.source });
+            }
+          }
+        }
+        if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
+          json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
+        }
+        return [true, json];
+      }
+      case "number": {
+        const number = schema;
+        const json = { type: "number" };
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+        if (typeof format === "string" && format?.includes("int")) {
+          json.type = "integer";
+        }
+        if (typeof minimum === "number") {
+          json.minimum = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maximum = maximum;
+        }
+        if (typeof exclusiveMinimum === "number") {
+          json.exclusiveMinimum = exclusiveMinimum;
+        }
+        if (typeof exclusiveMaximum === "number") {
+          json.exclusiveMaximum = exclusiveMaximum;
+        }
+        if (typeof multipleOf === "number") {
+          json.multipleOf = multipleOf;
+        }
+        return [true, json];
+      }
+      case "boolean": {
+        return [true, { type: "boolean" }];
+      }
+      case "bigint": {
+        return [
+          true,
+          {
+            type: "string",
+            pattern: "^-?[0-9]+$",
+            "x-native-type": JsonSchemaXNativeType.BigInt
+          }
+        ];
+      }
+      case "date": {
+        return [
+          true,
+          {
+            type: "string",
+            format: JSONSchemaFormat.DateTime,
+            "x-native-type": JsonSchemaXNativeType.Date
+          }
+        ];
+      }
+      case "null": {
+        return [true, { type: "null" }];
+      }
+      case "undefined":
+      case "void": {
+        return [false, this.undefinedJsonSchema];
+      }
+      case "any": {
+        return [false, this.anyJsonSchema];
+      }
+      case "unknown": {
+        return [false, this.anyJsonSchema];
+      }
+      case "never": {
+        return [true, this.unsupportedJsonSchema];
+      }
+      case "array": {
+        const array = schema;
+        const json = { type: "array" };
+        const { minimum, maximum } = array._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        json.items = this.#handleArrayItemJsonSchema(
+          this.#convert(array._zod.def.element, options, lazyDepth, structureDepth + 1),
+          options
+        );
+        return [true, json];
+      }
+      case "object": {
+        const object = schema;
+        const json = { type: "object" };
+        for (const [key, value] of Object.entries(object._zod.def.shape)) {
+          const [itemRequired, itemJson] = this.#convert(value, options, lazyDepth, structureDepth + 1);
+          json.properties ??= {};
+          json.properties[key] = itemJson;
+          if (itemRequired) {
+            json.required ??= [];
+            json.required.push(key);
+          }
+        }
+        if (object._zod.def.catchall) {
+          if (object._zod.def.catchall._zod.def.type === "never") {
+            json.additionalProperties = false;
+          } else {
+            const [_, addJson] = this.#convert(
+              object._zod.def.catchall,
+              options,
+              lazyDepth,
+              structureDepth + 1
+            );
+            json.additionalProperties = addJson;
+          }
+        }
+        return [true, json];
+      }
+      case "union": {
+        const union = schema;
+        const anyOf = [];
+        let required = true;
+        for (const item of union._zod.def.options) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          if (!itemRequired) {
+            required = false;
+          }
+          if (options.strategy === "input") {
+            if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          } else {
+            if (itemJson !== this.undefinedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          }
+        }
+        return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
+      }
+      case "intersection": {
+        const intersection = schema;
+        const json = { allOf: [] };
+        let required = false;
+        for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          json.allOf.push(itemJson);
+          if (itemRequired) {
+            required = true;
+          }
+        }
+        return [required, json];
+      }
+      case "tuple": {
+        const tuple = schema;
+        const json = { type: "array", prefixItems: [] };
+        for (const item of tuple._zod.def.items) {
+          json.prefixItems.push(
+            this.#handleArrayItemJsonSchema(
+              this.#convert(item, options, lazyDepth, structureDepth + 1),
+              options
+            )
+          );
+        }
+        if (tuple._zod.def.rest) {
+          json.items = this.#handleArrayItemJsonSchema(
+            this.#convert(tuple._zod.def.rest, options, lazyDepth, structureDepth + 1),
+            options
+          );
+        }
+        const { minimum, maximum } = tuple._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        return [true, json];
+      }
+      case "record": {
+        const record = schema;
+        const json = { type: "object" };
+        json.propertyNames = this.#convert(
+          record._zod.def.keyType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        json.additionalProperties = this.#convert(
+          record._zod.def.valueType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        return [true, json];
+      }
+      case "map": {
+        const map = schema;
+        return [
+          true,
+          {
+            type: "array",
+            items: {
+              type: "array",
+              prefixItems: [
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.keyType, options, lazyDepth, structureDepth + 1),
+                  options
+                ),
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+                  options
+                )
+              ],
+              maxItems: 2,
+              minItems: 2
+            },
+            "x-native-type": JsonSchemaXNativeType.Map
+          }
+        ];
+      }
+      case "set": {
+        const set = schema;
+        return [
+          true,
+          {
+            type: "array",
+            uniqueItems: true,
+            items: this.#handleArrayItemJsonSchema(
+              this.#convert(set._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+              options
+            ),
+            "x-native-type": JsonSchemaXNativeType.Set
+          }
+        ];
+      }
+      case "enum": {
+        const enum_ = schema;
+        return [true, { enum: Object.values(enum_._zod.def.entries) }];
+      }
+      case "literal": {
+        const literal = schema;
+        let required = true;
+        const values = /* @__PURE__ */ new Set();
+        for (const value of literal._zod.def.values) {
+          if (value === void 0) {
+            required = false;
+          } else {
+            values.add(typeof value === "bigint" ? value.toString() : value);
+          }
+        }
+        const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
+        return [required, json];
+      }
+      case "file": {
+        const file = schema;
+        const oneOf = [];
+        const { mime } = file._zod.bag;
+        if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
+          for (const type of mime ?? ["*/*"]) {
+            oneOf.push({
+              type: "string",
+              contentMediaType: type
+            });
+          }
+        }
+        return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
+      }
+      case "transform": {
+        return [false, this.anyJsonSchema];
+      }
+      case "nullable": {
+        const nullable = schema;
+        const [required, json] = this.#convert(
+          nullable._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { anyOf: [json, { type: "null" }] }];
+      }
+      case "nonoptional": {
+        const nonoptional = schema;
+        const [, json] = this.#convert(nonoptional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [true, json];
+      }
+      case "success": {
+        return [true, { type: "boolean" }];
+      }
+      case "default":
+      case "prefault": {
+        const default_ = schema;
+        const [, json] = this.#convert(default_._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [
+          false,
+          {
+            ...json,
+            default: default_._zod.def.defaultValue
+          }
+        ];
+      }
+      case "catch": {
+        const catch_ = schema;
+        return this.#convert(catch_._zod.def.innerType, options, lazyDepth, structureDepth);
+      }
+      case "nan": {
+        return [true, options.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
+      }
+      case "pipe": {
+        const pipe = schema;
+        return this.#convert(
+          options.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+      }
+      case "readonly": {
+        const readonly_ = schema;
+        const [required, json] = this.#convert(
+          readonly_._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { ...json, readOnly: true }];
+      }
+      case "template_literal": {
+        const templateLiteral = schema;
+        return [
+          true,
+          {
+            type: "string",
+            pattern: templateLiteral._zod.pattern.source
+          }
+        ];
+      }
+      case "optional": {
+        const optional = schema;
+        const [, json] = this.#convert(optional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [false, json];
+      }
+      case "lazy": {
+        const lazy = schema;
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        return this.#convert(lazy._zod.def.getter(), options, currentLazyDepth, structureDepth);
+      }
+      default: {
+        schema._zod.def.type;
+        return [true, this.unsupportedJsonSchema];
+      }
+    }
+  }
+  #getCustomJsonSchema(schema, options) {
+    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+    }
+    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    }
+    if (JSON_SCHEMA_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_REGISTRY.get(schema);
+    }
+    const global = globalRegistry.get(schema);
+    if (global) {
+      return {
+        title: global.title,
+        description: global.description,
+        examples: Array.isArray(global.examples) ? global.examples : void 0
+      };
+    }
+  }
+  #handleArrayItemJsonSchema([required, schema], options) {
+    if (required || options.strategy === "input" || schema.default !== void 0) {
+      return schema;
+    }
+    if (schema === this.undefinedJsonSchema) {
+      return { type: "null" };
+    }
+    return {
+      anyOf: [
+        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf
+        schema,
+        { type: "null" }
+      ]
+    };
+  }
+  #handleStringFormat(format) {
+    if (format === "guid") {
+      return JSONSchemaFormat.UUID;
+    }
+    if (format === "url") {
+      return JSONSchemaFormat.URI;
+    }
+    if (format === "datetime") {
+      return JSONSchemaFormat.DateTime;
+    }
+    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;
+  }
+  #handleContentEncoding(contentEncoding) {
+    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
+  }
+}
+
+export { JsonSchemaXNativeType as J, ZodToJsonSchemaConverter as Z, JSON_SCHEMA_REGISTRY as a, JSON_SCHEMA_INPUT_REGISTRY as b, JSON_SCHEMA_OUTPUT_REGISTRY as c, eventIterator as e, getEventIteratorSchemaDetails as g };

package/dist/shared/server.CjPiuQYH.d.mts

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

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

@@ -0,0 +1,51 @@
+import { JSONSchema, SchemaConverter } from '@temporary-name/server/openapi';
+
+interface ZodToJsonSchemaConverterOptions {
+    /**
+     * Max depth of lazy type.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 2
+     */
+    maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
+    /**
+     * The schema to be used to represent the any | unknown type.
+     *
+     * @default { }
+     */
+    anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used to represent the undefined type.
+     *
+     * @default { not: {} }
+     */
+    undefinedJsonSchema?: Exclude<JSONSchema, boolean>;
+}
+declare class ZodToJsonSchemaConverter {
+    #private;
+    private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
+    private readonly anyJsonSchema;
+    private readonly unsupportedJsonSchema;
+    private readonly undefinedJsonSchema;
+    constructor(options?: ZodToJsonSchemaConverterOptions);
+    convert: SchemaConverter;
+}
+
+export { ZodToJsonSchemaConverter as a };
+export type { ZodToJsonSchemaConverterOptions as Z };

package/dist/shared/{server.CYa9puL2.mjs → server.Cq7SBLD5.mjs}

@@ -1,10 +1,10 @@
 import { isObject, NullProtoObj, isAsyncIteratorObject, isORPCErrorJson, createORPCErrorFromJson, toORPCError, fallbackContractConfig, stringifyJSON, isORPCErrorStatus, tryDecodeURIComponent, toHttpPath, runWithSpan, ORPC_NAME, asyncIteratorWithSpan, setSpanError, ORPCError } from '@temporary-name/shared';
-import { c as createProcedureClient } from './server.Cza0RB3u.mjs';
+import { c as createProcedureClient } from './server.BCY45g2x.mjs';
 import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
 import { j as jsonSerialize } from './server.CQIFwyhc.mjs';
 import { traverseContractProcedures, getLazyMeta, unlazy } from '@temporary-name/server';
 import { createRouter, addRoute, findRoute } from 'rou3';
-import { s as standardizeHTTPPath } from './server.ChOv1yG3.mjs';
+import { s as standardizeHTTPPath } from './server.BETu17rq.mjs';
 
 function bracketNotationSerialize(data, segments = [], result = []) {
   if (Array.isArray(data)) {

package/dist/shared/{server.CVhIyQ4x.d.mts → server.DGH2Bq4t.d.mts}

@@ -1,5 +1,5 @@
 import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
-import { C as Context, m as Router } from './server.Cj3_Lp61.mjs';
+import { C as Context, l as Router } from './server.zsKBRxsz.mjs';
 
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;

package/dist/shared/{server.D8RAzJ_p.d.ts → server.nQoUObAJ.d.ts}

@@ -1,5 +1,5 @@
 import { HTTPPath, StandardResponse, StandardLazyRequest } from '@temporary-name/shared';
-import { C as Context, m as Router } from './server.Cj3_Lp61.js';
+import { C as Context, l as Router } from './server.zsKBRxsz.js';
 
 interface StandardHandleOptions<T extends Context> {
     prefix?: HTTPPath;