@elysiajs/openapi 1.4.15 → 2.0.0-exp.0

package/dist/openapi.d.ts

@@ -1,6 +1,12 @@
-import { type AnyElysia, type TSchema, type InputSchema } from 'elysia';
+import type { AnyElysia } from 'elysia/base';
+import type { InputSchema } from 'elysia/types';
 import type { OpenAPIV3 } from 'openapi-types';
-import { TAnySchema, type TProperties } from '@sinclair/typebox';
+type TSchema = OpenAPIV3.SchemaObject & {
+    $ref?: string;
+    $schema?: string;
+    const?: unknown;
+    [key: string]: any;
+};
 import type { AdditionalReferences, ElysiaOpenAPIConfig, MapJsonSchema } from './types';
 export declare const capitalize: (word: string) => string;
 /**
@@ -16,7 +22,7 @@ export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?:
  *
  * Otherwise, return the schema as is
  */
-export declare const enumToOpenApi: <T extends TAnySchema | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined>(_schema: T) => T;
+export declare const enumToOpenApi: <T extends TSchema | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined>(_schema: T) => T;
 /**
  * Converts Elysia routes to OpenAPI 3.0.3 paths schema
  * @param routes Array of Elysia route objects
@@ -28,6 +34,7 @@ export declare function toOpenAPISchema(app: AnyElysia, exclude?: ElysiaOpenAPIC
     };
     paths: OpenAPIV3.PathsObject<{}, {}>;
 };
-export declare const withHeaders: (schema: TSchema, headers: TProperties) => TSchema & {
-    headers: TProperties;
+export declare const withHeaders: <const T, const H>(schema: T, headers: H) => T & {
+    headers: H;
 };
+export {};

package/dist/openapi.mjs

@@ -1,14 +1,7 @@
 // src/openapi.ts
 import { t } from "elysia";
-
-// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
-
-// src/openapi.ts
 var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
-var toRef = (name) => t.Ref(
-  name.startsWith("#/") ? name : `#/components/schemas/${name}`
-);
+var toRef = (name) => t.Ref(name.startsWith("#/") ? name : `#/components/schemas/${name}`);
 var toOperationId = (method, paths) => {
   let operationId = method.toLowerCase();
   if (!paths || paths === "/") return operationId + "Index";
@@ -29,12 +22,8 @@ var getPossiblePath = (path) => {
   }
   return paths;
 };
-var isValidSchema = (schema) => schema && typeof schema === "object" && (Kind in schema && schema[Kind] !== "Unknown" || schema.type || schema.properties || schema.items);
-var getLoosePath = (path) => {
-  if (path.charCodeAt(path.length - 1) === 47)
-    return path.slice(0, path.length - 1);
-  return path + "/";
-};
+var isValidSchema = (schema) => schema && typeof schema === "object" && (schema.type || schema.properties || schema.items || schema.anyOf || schema.allOf || schema.oneOf || schema.$ref || schema.enum || schema.const !== void 0);
+var getLoosePath = (path) => path.charCodeAt(path.length - 1) === 47 ? path.slice(0, path.length - 1) : path + "/";
 var warnings = {
   zod4: `import openapi from '@elysiajs/openapi'
 import * as z from 'zod'
@@ -130,12 +119,10 @@ var mergeObjectSchemas = (schemas) => {
 };
 var isTSchema = (value) => {
   if (!value || typeof value !== "object") return false;
-  if (Kind in value) return true;
+  if (value["~standard"]) return false;
   const keys = Object.keys(value);
-  if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) {
-    return false;
-  }
-  return false;
+  if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) return false;
+  return isValidSchema(value);
 };
 var normalizeSchemaReference = (schema) => {
   if (!schema) return void 0;
@@ -213,8 +200,8 @@ var mergeResponseSchema = (_existing, _incoming, vendors) => {
 };
 var mergeStandaloneValidators = (hooks, vendors) => {
   const merged = { ...hooks };
-  if (!hooks.standaloneValidator?.length) return merged;
-  for (const validator of hooks.standaloneValidator) {
+  if (!hooks.schemas?.length) return merged;
+  for (const validator of hooks.schemas) {
     if (validator.body)
       merged.body = mergeSchemaProperty(
         merged.body,
@@ -267,16 +254,15 @@ var mergeStandaloneValidators = (hooks, vendors) => {
     if ("type" in response || "$ref" in response) {
       if (typeof response === "string")
         merged.response = normalizeSchemaReference(response);
-    } else {
+    } else
       for (const [status, schema] of Object.entries(response))
         if (typeof schema === "string")
           response[status] = normalizeSchemaReference(schema);
-    }
   }
   return merged;
 };
 var flattenRoutes = (routes, vendors) => routes.map((route) => {
-  if (!route.hooks?.standaloneValidator?.length) return route;
+  if (!route.hooks?.schemas?.length) return route;
   return {
     ...route,
     hooks: mergeStandaloneValidators(route.hooks, vendors)
@@ -292,19 +278,19 @@ var unwrapReference = (schema, definitions) => {
 var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
   if (!schema) return;
   if (typeof schema === "string") schema = toRef(schema);
-  if (Kind in schema) return enumToOpenApi(schema);
-  if (!schema?.["~standard"] && // @ts-ignore
-  (schema.$schema || schema.type || schema.properties || schema.items))
-    return schema;
+  if (!schema?.["~standard"] && isValidSchema(schema))
+    return enumToOpenApi(schema);
   if (!schema?.["~standard"]) return;
   const vendor = schema["~standard"].vendor;
   try {
     if (mapJsonSchema?.[vendor] && typeof mapJsonSchema[vendor] === "function")
       return enumToOpenApi(mapJsonSchema[vendor](schema));
     if (schema["~standard"]?.jsonSchema?.[io])
-      return enumToOpenApi(schema["~standard"].jsonSchema[io]({
-        target: "draft-2020-12"
-      }));
+      return enumToOpenApi(
+        schema["~standard"].jsonSchema[io]({
+          target: "draft-2020-12"
+        })
+      );
     switch (vendor) {
       case "zod":
         if (warned.zod4 || warned.zod3) break;
@@ -360,9 +346,9 @@ var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
 };
 var enumToOpenApi = (_schema) => {
   if (!_schema || typeof _schema !== "object") return _schema;
-  if (Kind in _schema) {
+  {
     const schema2 = _schema;
-    if (schema2[Kind] === "Union" && schema2.anyOf && Array.isArray(schema2.anyOf) && schema2.anyOf.length > 0 && schema2.anyOf.every(
+    if (schema2.anyOf && Array.isArray(schema2.anyOf) && schema2.anyOf.length > 0 && schema2.anyOf.every(
       (item) => item && typeof item === "object" && item.const !== void 0
     ))
       return {
@@ -396,7 +382,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
   excludeMethods = excludeMethods.map((method) => method.toLowerCase());
   const excludePaths = Array.isArray(exclude?.paths) ? exclude.paths : typeof exclude?.paths !== "undefined" ? [exclude.paths] : [];
   const paths = /* @__PURE__ */ Object.create(null);
-  const definitions = app.getGlobalDefinitions?.().type;
+  const definitions = app.models;
   if (references) {
     if (!Array.isArray(references)) references = [references];
     for (let i = 0; i < references.length; i++) {
@@ -404,7 +390,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       if (typeof reference === "function") references[i] = reference();
     }
   }
-  const routes = flattenRoutes(app.getGlobalRoutes(), vendors);
+  const routes = flattenRoutes(app.routes, vendors);
   for (const route of routes) {
     if (route.hooks?.detail?.hide) continue;
     const method = route.method.toLowerCase();
@@ -446,7 +432,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
             }
         }
       }
-    if (excludeTags && hooks.detail.tags?.some((tag) => excludeTags?.includes(tag)))
+    if (excludeTags && hooks.detail?.tags?.some((tag) => excludeTags?.includes(tag)))
       continue;
     const operation = {
       ...hooks.detail
@@ -643,7 +629,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       path = path.replace(/:([^/]+)/g, "{$1}");
       if (!paths[path]) paths[path] = {};
       const current = paths[path];
-      if (method !== "all") {
+      if (method !== "all" && method !== "*") {
         current[method] = {
           ...operation,
           operationId
@@ -670,7 +656,11 @@ function toOpenAPISchema(app, exclude, references, vendors) {
   if (definitions)
     for (const [name, schema] of Object.entries(definitions)) {
       const jsonSchema = unwrapSchema(schema, vendors);
-      if (jsonSchema) schemas[name] = jsonSchema;
+      if (jsonSchema)
+        schemas[name] = {
+          ...jsonSchema,
+          $id: `#/components/schemas/${name}`
+        };
     }
   return {
     components: {

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { TSchema } from 'elysia';
+import type { TSchema } from 'typebox';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { ApiReferenceConfiguration } from '@scalar/types';
 import type { SwaggerUIOptions } from './swagger/types';
@@ -102,7 +102,7 @@ export interface ElysiaOpenAPIConfig<Enabled extends boolean = true, Path extend
      *'
      * @see https://github.com/scalar/scalar/blob/main/documentation/configuration.md
      */
-    scalar?: ApiReferenceConfiguration & {
+    scalar?: Partial<ApiReferenceConfiguration> & {
         /**
          * Version to use for Scalar cdn bundle
          *

package/memory/MIGRATION.md

@@ -0,0 +1,241 @@
+## 1. Hook and handler argument are swapped
+
+The verb methods take the **schema/hook object before the handler**.
+
+Applies to `get`/`post`/`put`/`patch`/`delete`/`options`/`head`/`all`/`method`
+
+**Migration:** swap position of hook and handler
+
+```ts
+// 1.x
+app.get('/user/:id', ({ params, query }) => params.id, {
+  params: t.Object({ id: t.Number() }),
+  query: t.Object({ name: t.String() })
+})
+
+// 2.0
+app.get('/user/:id', {
+  params: t.Object({ id: t.Number() }),
+  query: t.Object({ name: t.String() })
+}, ({ params, query }) => params.id)
+
+// no hook, unchanged
+app.get('/', () => 'hi')
+```
+
+---
+
+## 2. WebSocket
+
+- `.ws()` now accept 2-3 arguments
+	- 2-arg forms (`.ws('/ws', handler)`, `.ws('/ws', options)`) are unchanged
+	- 3-arg form is now `.ws('/ws', options, handler)`
+- `ws.data` is now inline to `ws` directly
+- generator function and `yield` is now preferred way of sending data instead of `ws.send` for type safety
+
+```ts
+// 1.x
+new Elysia()
+	.ws('/', {
+		message({ send, data: { params: { id } } }) {
+			send(id)
+		}
+	})
+
+// 2.x
+new Elysia()
+	.ws('/', ({ params: { id } }) => id)
+```
+
+## 3. Drop `on` prefix for event
+
+Use the bare-named methods.
+
+| Removed | Use |
+|---|---|
+| `onRequest` | `request` |
+| `onParse` | `parse` |
+| `onTransform` | `transform` |
+| `onBeforeHandle` | `beforeHandle` |
+| `onAfterHandle` | `afterHandle` |
+| `onAfterResponse` | `afterResponse` |
+| `onError` | `error` |
+
+The lifecycle hooks are also **renamed** (not just de-prefixed): `onStart` → **`setup`**, `onStop`
+→ **`cleanup`**.
+
+```ts
+// 1.x
+app.
+	onRequest(fn)
+	.onBeforeHandle(fn)
+	.onAfterResponse(fn)
+
+// 2.0
+app
+	.request(fn)
+	.beforeHandle(fn)
+	.afterResponse(fn)
+```
+
+---
+
+## 4. Code is drop from error
+
+- `error(ErrorClass, fn)` registers a per-class handler
+- `error(fn)` registers the general handler
+- **`error.code` is removed**: dispatch with `instanceof` or `error(SomeError, fn)`
+
+```ts
+// 1.x
+app
+	.onError(({ code, error }) => {
+	  	if (code === 'NOT_FOUND') return 'nope'
+	})
+
+// 2.0
+app.error(NotFound, () => 'nope')
+app.error(({ error }) => { /* ... */ })
+```
+
+---
+
+## 5. `resolve` removed entirely
+
+- `derive` now run on `beforeHandle` (previous `resolve` behavior)
+- `resolve` are now removed
+
+```ts
+// 1.x
+app.resolve(({ headers }) => ({ user: auth(headers) }))
+// 2.0
+app.derive(({ headers }) => ({ user: auth(headers) }))
+```
+
+## 6. Scope changes
+
+- The `'scoped'` scope is **renamed to `'plugin'`**
+- The `{ as: 'scope' }` **object form is removed**
+- `.decorate()` / `.state()` `{ as: 'append' | 'override' }`
+
+```ts
+// 1.x
+app.beforeHandle({ as: 'scoped' }, fn)
+app.as('scoped')
+app.guard({ as: 'scoped' }, fn)
+app.decorate({ as: 'override' }, 'db', db)
+
+// 2.0
+app.beforeHandle('plugin', fn)
+app.as('plugin')
+app.guard('plugin', fn)
+app.decorate('override', 'db', db)
+```
+
+---
+
+## 7. Guard/group default to OVERRIDE channel
+
+**Every** `.guard()` and `.group()` is default to **override**
+
+- the closer to the route, the more power, the nearer schema **replaces** an inherited one
+- `schema: 'standalone'` is explicitly required across all APIs
+
+**Migration:** if you use `guard`, add `schema: 'standalone'`:
+
+```ts
+// 1.x string-scope & run forms were implicitly additive (standalone)
+app.guard({ body: t.Object({ a: t.String() }) })
+
+// 2.0 now overrides by default; prefer closer schema first
+app.guard({ schema: 'standalone', body: t.Object({ a: t.String() }) })
+```
+
+---
+
+## 8. TypeBox 1.0 alignment
+
+See [TypeBox 1.0 migration](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
+
+But to summarize:
+- `t.Transform` → **`t.Codec`**.
+- Removed `t.Recursive`, `t.Not`, `t.RegExp`
+- **`t.NoValidate` semantics changed:** now skips `Check` only `Default`/`Convert`/`Decode`/`Encode` still run.
+	- `NoValidate` will throw `ValidationError` if Encode runs.
+- `Error.summary` now uses TypeBox's default message (and supports Standard Schema).
+
+---
+
+## 9. Macros
+
+- **Functional macro must use the object form:** `.macro({ name: fn })`.
+- **`.macro(name, definition)` removed**, use `.macro({ [name]: definition })`.
+	- The object form is now fully inferred (own schema, derive results, function-form arg, typo rejection)
+- **Requires TypeScript ≥ 5.7** for macro definition inference.
+
+```ts
+// 1.x named form
+app.macro('auth', {
+  resolve: ({ headers }) => ({ user: auth(headers) })
+})
+
+// 2.0 object form only (fully inferred)
+app.macro({
+  auth: {
+    resolve: ({ headers }) => ({ user: auth(headers) })
+  }
+})
+```
+
+## 10. Removed / renamed APIs & exports
+
+- `NotFoundError` → **`NotFound`** (a thrown 404 is `instanceof NotFound`)
+- `getSchemaValidator` → **`Validator.create`**
+- `set.redirect`: use the `redirect()` context helper
+- `context.contentType` is removed from `Context` in `parse`, use `context.contentType` instead
+- Deprecated `response` field on `mapResponse`/`afterResponse` is removed
+- Removed instance methods `.route()`, `.connect()`, `.env()`,
+  `.affix()`/`.prefix()`/`.suffix()` and the `.store`/`.decorator`/`.config`
+  **instance getters**, use the verb methods, `new Elysia({ name, prefix })` for
+  plugin naming, and in-handler `context.store`/`context.decorator`
+- Passing an Elysia instance to `.mount` is deprecated, use `.use` instead
+- `config.encodeSchema` dropped (always enabled now)
+
+```ts
+import { NotFound } from 'elysia'          // was NotFoundError
+import { Validator } from 'elysia'         // getSchemaValidator → Validator.create
+
+// redirect
+;({ set }) => { set.redirect = '/' }       // 1.x
+;({ redirect }) => redirect('/')           // 2.0
+
+// afterResponse / mapResponse field
+app.afterResponse(({ responseValue }) => {})   // was `response`
+
+// parse contentType
+app.parse((ctx, contentType) => {})        // 1.x (2nd param)
+app.parse((ctx) => ctx.contentType)        // 2.0
+
+// removed instance getters / methods → use context or constructor
+new Elysia({ name: 'x', prefix: '/v1' })   // was .prefix()/.affix()/.suffix()/name
+;({ store, decorator }) => {}              // was app.store / app.decorator getters
+
+// mount an instance
+app.use(plugin)                            // was app.mount(plugin)
+```
+
+---
+
+## 11. Behavior changes worth knowing (no API change, but observable)
+
+- **`afterHandle` skips the rest on short-circuit.**
+- **Bodyless `GET`/`HEAD` no longer run `parse` hooks**, a `parse` hook that must run on every request belongs in `request`/`transform`
+- **422 response no longer echoes large bodies**, `found` is scoped; a request body whose JSON exceeds 4KB isn't reflected back in full. `error.value` still exposes the full value to custom handlers.
+- **Returned `Response` passed by reference when `set` is untouched** (preserves
+  `content-length`).
+	- **Trap:** returning the *same* `Response` object across requests while writing per-request `set.headers` now mutates the shared object and leaks headers (previously errored loudly). Return a fresh `Response` per
+  request.
+- **`streamResponse` yields raw bytes**, re-streamed bodies are now byte-identical; a headerless binary-first chunked stream defaults to `application/octet-stream` (was `application/json`)
+- **WS query parsing** now matches HTTP (duplicate keys → arrays, not last-wins; null-prototype records)
+- **Validator runs `Convert → Check → DecodeUnsafe`** for codec schemas (fixes `t.Numeric({ minimum, maximum })` and `t.Codec(...).Decode(...)` against wire input)
+- When file use `t.File` has `type` **`t.File({ type: 'image/jpg' })`**, project must initialize `setFileTypeDetector` with a function that returns the MIME type. (By default Elysia use `file-type` package to detect file type)

package/package.json

@@ -1,92 +1,94 @@
 {
-    "name": "@elysiajs/openapi",
-    "version": "1.4.15",
-    "description": "Elysia plugin to add OpenAPI documentation",
-    "author": {
-        "name": "saltyAom",
-        "url": "https://github.com/SaltyAom",
-        "email": "saltyaom@gmail.com"
-    },
-    "main": "./dist/cjs/index.js",
-    "module": "./dist/index.mjs",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        "./package.json": "./package.json",
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.mjs",
-            "require": "./dist/cjs/index.js"
-        },
-        "./gen": {
-            "types": "./dist/gen/index.d.ts",
-            "import": "./dist/gen/index.mjs",
-            "require": "./dist/cjs/gen/index.js"
-        },
-        "./openapi": {
-            "types": "./dist/openapi.d.ts",
-            "import": "./dist/openapi.mjs",
-            "require": "./dist/cjs/openapi.js"
-        },
-        "./scalar": {
-            "types": "./dist/scalar/index.d.ts",
-            "import": "./dist/scalar/index.mjs",
-            "require": "./dist/cjs/scalar/index.js"
-        },
-        "./scalar/theme": {
-            "types": "./dist/scalar/theme.d.ts",
-            "import": "./dist/scalar/theme.mjs",
-            "require": "./dist/cjs/scalar/theme.js"
-        },
-        "./swagger": {
-            "types": "./dist/swagger/index.d.ts",
-            "import": "./dist/swagger/index.mjs",
-            "require": "./dist/cjs/swagger/index.js"
-        },
-        "./swagger/types": {
-            "types": "./dist/swagger/types.d.ts",
-            "import": "./dist/swagger/types.mjs",
-            "require": "./dist/cjs/swagger/types.js"
-        },
-        "./types": {
-            "types": "./dist/types.d.ts",
-            "import": "./dist/types.mjs",
-            "require": "./dist/cjs/types.js"
-        }
-    },
-    "keywords": [
-        "elysia",
-        "openapi",
-        "swagger",
-        "scalar"
-    ],
-    "homepage": "https://github.com/elysiajs/elysia-openapi",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/elysiajs/elysia-openapi"
-    },
-    "bugs": "https://github.com/elysiajs/elysia-openapi/issues",
-    "license": "MIT",
-    "scripts": {
-        "dev": "bun run --watch example/index.ts",
-        "test": "bun test && npm run test:node",
-        "test:node": "npm install --prefix ./test/node/cjs/ && npm install --prefix ./test/node/esm/ && node ./test/node/cjs/index.js && node ./test/node/esm/index.js",
-        "build": "bun build.ts",
-        "release": "npm run build && npm run test && npm publish --access public"
-    },
-    "devDependencies": {
-        "@apidevtools/swagger-parser": "^12.1.0",
-        "@scalar/types": "^0.2.16",
-        "@sinclair/typemap": "^0.10.1",
-        "@types/bun": "1.2.20",
-        "effect": "^3.21.2",
-        "elysia": "1.4.19",
-        "eslint": "9.6.0",
-        "openapi-types": "^12.1.3",
-        "tsup": "^8.5.1",
-        "typescript": "^5.9.3",
-        "zod": "^4.3.6"
-    },
-    "peerDependencies": {
-        "elysia": ">= 1.4.0"
-    }
+	"name": "@elysiajs/openapi",
+	"version": "2.0.0-exp.0",
+	"description": "Plugin for Elysia to auto-generate API documentation",
+	"author": {
+		"name": "saltyAom",
+		"url": "https://github.com/SaltyAom",
+		"email": "saltyaom@gmail.com"
+	},
+	"main": "./dist/cjs/index.js",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs",
+			"require": "./dist/cjs/index.js"
+		},
+		"./gen": {
+			"types": "./dist/gen/index.d.ts",
+			"import": "./dist/gen/index.mjs",
+			"require": "./dist/cjs/gen/index.js"
+		},
+		"./openapi": {
+			"types": "./dist/openapi.d.ts",
+			"import": "./dist/openapi.mjs",
+			"require": "./dist/cjs/openapi.js"
+		},
+		"./scalar": {
+			"types": "./dist/scalar/index.d.ts",
+			"import": "./dist/scalar/index.mjs",
+			"require": "./dist/cjs/scalar/index.js"
+		},
+		"./scalar/theme": {
+			"types": "./dist/scalar/theme.d.ts",
+			"import": "./dist/scalar/theme.mjs",
+			"require": "./dist/cjs/scalar/theme.js"
+		},
+		"./swagger": {
+			"types": "./dist/swagger/index.d.ts",
+			"import": "./dist/swagger/index.mjs",
+			"require": "./dist/cjs/swagger/index.js"
+		},
+		"./swagger/types": {
+			"types": "./dist/swagger/types.d.ts",
+			"import": "./dist/swagger/types.mjs",
+			"require": "./dist/cjs/swagger/types.js"
+		},
+		"./types": {
+			"types": "./dist/types.d.ts",
+			"import": "./dist/types.mjs",
+			"require": "./dist/cjs/types.js"
+		}
+	},
+	"keywords": [
+		"elysia",
+		"openapi",
+		"swagger",
+		"scalar"
+	],
+	"homepage": "https://github.com/elysiajs/elysia-openapi",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/elysiajs/elysia-openapi"
+	},
+	"bugs": "https://github.com/elysiajs/elysia-openapi/issues",
+	"license": "MIT",
+	"scripts": {
+		"dev": "bun run --watch example/index.ts",
+		"test": "bun test && npm run test:node",
+		"test:node": "npm install --prefix ./test/node/cjs/ && npm install --prefix ./test/node/esm/ && node ./test/node/cjs/index.js && node ./test/node/esm/index.js",
+		"build": "bun build.ts",
+		"release": "npm run build && npm run test && npm publish --access public"
+	},
+	"devDependencies": {
+		"@apidevtools/swagger-parser": "^12.0.0",
+		"@scalar/types": "^0.2.13",
+		"@types/bun": "1.2.20",
+		"effect": "^3.17.13",
+		"elysia": "2.0.0-exp.12",
+		"eslint": "9.6.0",
+		"file-type": "^22.0.0",
+		"openapi-types": "^12.1.3",
+		"tsup": "^8.5.0",
+		"typebox": "1.2.16",
+		"typescript": "^5.9.2",
+		"zod": "^4.2.1"
+	},
+	"peerDependencies": {
+		"elysia": "2.0.0-exp.12",
+		"typebox": "1.2.16"
+	}
 }

package/bunfig.toml

@@ -1,2 +0,0 @@
-[install]
-registry = "https://registry.npmjs.org/"