rajt 0.0.97 → 0.0.99

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "type": "module",
   "main": "./src/index.ts",
+  "files": ["bin", "src"],
   "bin": {
     "rajt": "./bin/rajt.js"
   },
@@ -22,10 +23,6 @@
     "./env": "./src/utils/environment.ts",
     "./length": "./src/utils/length.ts"
   },
-  "files": [
-    "bin",
-    "src"
-  ],
   "scripts": {
     "aws:local": "bun run --silent aws:build && bun run --silent sam:local",
     "aws:package": "bun run --silent aws:build && bun run --silent sam:package",
@@ -38,51 +35,44 @@
     "zip": "zip -j ../../lambda.zip ../../.rajt/dist/index.js"
   },
   "dependencies": {
-    "cripta": "^0.1",
-    "forj": "0.1.7",
-    "t0n": "^0.1",
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
+    "@hono/zod-validator": "^0.7.6",
     "@scalar/hono-api-reference": "^0.9.40",
     "chokidar": "^3.5.2",
     "citty": "^0.1.6",
     "consola": "^3.4.2",
+    "cripta": "^0.1.10",
     "dotenv": "^16.5.0",
     "esbuild": "^0.25.2",
+    "forj": "^0.1.8",
     "hono": "^4.11.7",
-    "hono-openapi": "^1.2.0",
+    "hono-openapi": "^1.3.0",
     "localflare-api": "^0.4.2",
     "localflare-core": "^0.4.2",
-    "miniflare": "^4.20251217.0",
+    "miniflare": "^4.20260301.1",
     "pathe": "^2.0",
     "quansync": "^0.2.11",
+    "t0n": "^0.1.12",
     "tiny-glob": "^0.2",
-    "tsx": "^4.19.3",
-    "ua-parser-js": "^2.0.8",
+    "tsx": "^4.19.4",
     "wrangler": "^4.61.0",
     "zod": "^4.3.6",
-    "zod-openapi": "4"
+    "zod-openapi": "^5.4.6"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20251230.0",
-    "@miniflare/core": "^2.14.4",
-    "@miniflare/d1": "^2.14.4",
-    "@miniflare/durable-objects": "^2.14.4",
-    "@miniflare/kv": "^2.14.4",
-    "@miniflare/r2": "^2.14.4",
-    "@miniflare/scheduler": "^2.14.4",
-    "@miniflare/sites": "^2.14.4",
-    "@miniflare/storage-file": "^2.14.4",
-    "@miniflare/web-sockets": "^2.14.4",
+    "@cloudflare/workers-types": "^4.20260113.0",
     "@types/node": "^25.1.0",
     "bun-types": "^1.3.8",
     "typescript": "^5.9.3"
   },
+  "packageManager": "bun@1.3.10",
   "engines": {
     "node": ">=18.0.0"
   },
   "resolutions": {
-    "@smithy/types": "^4.3.0"
+    "@smithy/types": "^4.3.0",
+    "zod": "^4.3.6"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -111,4 +101,4 @@
     "bun",
     "nodejs"
   ]
-}
+}

package/src/auth/token.ts

@@ -1,8 +1,37 @@
-import { Envir } from 't0n'
-import { Token as Factory } from 'cripta'
-import { UAParser } from 'ua-parser-js'
+import { Envir, parseUA } from 't0n'
+import { Token as Factory, sha256 } from 'cripta'
 import type { IRequest } from '@/types'
 
+const STABLE_HEADERS = [
+  'host',
+  'connection',
+  'sec-ch-ua',
+  'sec-ch-ua-mobile',
+  'sec-ch-ua-platform',
+  'upgrade-insecure-requests',
+  'user-agent',
+  'accept',
+  'sec-fetch-site',
+  'sec-fetch-mode',
+  'sec-fetch-user',
+  'sec-fetch-dest',
+  'accept-encoding',
+  'accept-language',
+]
+
+function headerOrdering(headers: Record<string, string>) {
+  const order: string[] = []
+
+  for (const name in headers) {
+    const key = name.toLowerCase()
+
+    if (STABLE_HEADERS.includes(key))
+      order.push(key)
+  }
+
+  return order
+}
+
 export class Token {
   static #cookieName: string = '__auth_'
   static #name: string = 'Authorization'
@@ -48,8 +77,7 @@ export class Token {
     return Factory.parse(token)
       .issuedBy(serveHost)
       .permittedFor(host)
-      .withClaim('u', this.userAgent(req))
-      .withClaim('i', this.ip(req))
+      .withClaim('_', this.fingerprint(req))
   }
 
   static create(req: IRequest, user: any, exp: number = 7200) {
@@ -61,8 +89,7 @@ export class Token {
       .permittedFor(host)
       .issuedAt(time)
       .expiresAt(time + exp)
-      .withClaim('u', this.userAgent(req))
-      .withClaim('i', this.ip(req))
+      .withClaim('_', this.fingerprint(req))
       .body(user)
   }
 
@@ -90,11 +117,18 @@ export class Token {
     }
   }
 
-  static userAgent(req: IRequest) {
-    const ua = req?.userAgent
-    if (!ua) return 0
-    const { browser, device, os } = UAParser(ua)
-    return (browser?.name || '') + (browser?.major || '') + (device?.model || '') + (os?.name || '')
+  static fingerprint(req: IRequest) {
+    const ua = parseUA(req.header('user-agent'))
+
+    const id = sha256(
+      // (req.header('accept-language') || '')
+      this.ip(req)
+      + ua.browser.name + ua.browser.version.split('.')[0]
+      + ua.os.type + ua.os.name
+      + headerOrdering(req.header()).join('')
+    )
+
+    return id.substring(0, 8) + id.substring(56, 64)
   }
 
   static ip(req: IRequest) {

package/src/cli/commands/build.ts

@@ -1,5 +1,5 @@
 import { defineCommand } from 'citty'
-import { gray } from '../../utils/colors'
+import { gray } from 't0n/color'
 import { build, normalizePlatform, platformError } from '../utils'
 import { wait, error, rn } from '../../utils/log'
 

package/src/cli/commands/make.ts

@@ -4,7 +4,7 @@ import { Migrator } from 'forj'
 import { makeFile, hasExt, camelCase, kebabCase } from '../utils'
 import { _root } from '../../utils/paths'
 import { event, error } from '../../utils/log'
-import { dim } from '../../utils/colors'
+import { dim } from 't0n/color'
 import * as stub from '../stubs'
 
 export default defineCommand({

package/src/cli/commands/migrate.ts

@@ -2,7 +2,7 @@ import { defineCommand } from 'citty'
 import { spawn } from 'node:child_process'
 import { join } from 'pathe'
 import { Migrator } from 'forj'
-import { gray } from '../../utils/colors'
+import { gray } from 't0n/color'
 import { getRuntime, cleanDB, cleanDir } from '../utils'
 import { _root } from '../../utils/paths'
 import { wait, info, event, rn, error, log } from '../../utils/log'

package/src/cli/index.ts

@@ -2,7 +2,7 @@ import { defineCommand, runMain, renderUsage } from 'citty'
 import type { ArgsDef, CommandDef } from 'citty'
 import { createConsola } from 'consola'
 import { logo } from '../utils/log'
-import { isColorSupported, gray } from '../utils/colors'
+import { isColorSupported, gray } from 't0n/color'
 import { version as rajtVersion } from '../../package.json'
 
 import dev from './commands/dev'

package/src/cli/utils.ts

@@ -1,6 +1,6 @@
 import esbuild from 'esbuild'
 import { Miniflare } from 'miniflare'
-import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyFileSync, writeFileSync, readFileSync } from 'node:fs'
+import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyFileSync, writeFileSync } from 'node:fs'
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative } from 'pathe'
 import { createHash, createHmac } from 'node:crypto'
@@ -9,7 +9,7 @@ import { findWranglerConfig, parseWranglerConfig, WRANGLER_CONFIG_FILES } from '
 import type { WranglerConfig, LocalflareManifest } from 'localflare-core'
 
 import chokidar from 'chokidar'
-import { gray, bold, italic, purple, yellow, red } from '../utils/colors'
+import { gray, bold, italic, purple, yellow, red } from 't0n/color'
 import type { ChokidarEventName, Platform } from './types'
 
 import { cacheRoutes } from '../routes'

package/src/config.ts

@@ -39,6 +39,7 @@ export default class Config {
     this.#c.clear()
   }
 
+  // @ts-ignore
   static get length(): number {
     return this.#c.length
   }

package/src/create-app.ts

@@ -1,19 +1,19 @@
 import { Hono } from 'hono'
 import { logger } from 'hono/logger'
 import { matchedRoutes } from 'hono/route'
-import { describeRoute } from 'hono-openapi'
 import { Envir, Datte } from 't0n'
 import type {
   Env, Context, Next,
   HTTPResponseError,
   ServerOptions,
 } from './types'
-import { resolve, resolveMiddleware } from './utils/resolve'
+import { resolve, resolveMiddleware, mw } from './utils/resolve'
 import { getMiddlewares, getHandler } from './register'
 import request, { GET_REQUEST } from './request'
 import response from './response'
 import { isDev } from './utils/environment'
-import { gray } from './utils/colors'
+import { gray } from 't0n/color'
+import { Route } from './types'
 
 const NFHandler = () => response.notFound()
 const EHandler = async (e: Error | HTTPResponseError) => {
@@ -108,24 +108,19 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
 
   if (options?.init) options.init(app)
 
-  const routes = options?.routes || []
-  for (const route of routes) {
+  const routes = options?.routes || [] // @ts-ignore
+  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => { // @ts0ignore
     if (Array.isArray(route)) { // @ts-ignore
-      app[route[0]](route[1], ...mw(route[2], route[3]), ...resolve(getHandler(route[3]), route[3]))
+      _[route[0]](route[1], ...mw(route[2], route[3]), ...resolve(getHandler(route[3]), route[3]))
     } else { // @ts-ignore
-      app[route.method](route.path, describeRoute(route.desc), ...mw(route.middlewares, route.name), ...resolve(route.handle, route.name))
+      _[route.method](route.path, ...mw(route.middlewares, route.name), ...resolve(route.handle, route.name))
     }
   }
 
-  return app
-}
+  for (const route of routes)
+    routeRegister(app, route)
 
-function mw(...objs: string[]): Function[] {
-  return objs.flatMap(obj => {
-    if (typeof obj != 'string') return null
-    // @ts-ignore
-    return getHandler(obj)?.mw || null
-  }).flat().filter(Boolean)
+  return app
 }
 
 export default createApp

package/src/dev.ts

@@ -3,7 +3,7 @@ import { config } from 'dotenv'
 import { getRoutes, getMiddlewares, getConfigs } from './routes'
 import { registerHandler, registerMiddleware } from './register'
 import Config from './config'
-import OAS from './oas'
+import { registerOpenAPI } from './open-api/register'
 import createApp from './create-app'
 import { Ability } from 'rajt/auth'
 import { setEnv, detectEnvironment } from 'rajt/env'
@@ -28,6 +28,6 @@ Ability.roles = Config.get('roles', {})
 
 // @ts-ignore
 const app = createApp({ routes })
-OAS.register(app, Config.get('rajt', {}))
+registerOpenAPI(app, Config.get('rajt', {}))
 
 export default app

package/src/open-api/register.ts

@@ -0,0 +1,67 @@
+import { basicAuth } from 'hono/basic-auth'
+import { Scalar } from '@scalar/hono-api-reference'
+import { Envir } from 't0n'
+import response from '../response'
+import { getHandler } from '../register'
+import type { Hono } from '../types'
+
+export function config(opts: any) {
+  const docs = opts?.docs ?? {}
+
+  const appName = Envir.get('APP_NAME', 'API Docs')
+  const appVersion = Envir.get('APP_VERSION') || Envir.get('VERSION_HASH') || '1.0.0'
+
+  return {
+    ...docs,
+    disable: !!docs?.disable,
+    path: docs?.path || '/docs',
+    auth: docs?.auth || {},
+    agent: !docs?.agent,
+    appName, appVersion,
+  }
+}
+
+export function registerOpenAPI(app: Hono, conf: any) {
+  const opts = config(conf)
+  if (opts.disable) return
+
+  if (opts?.auth?.username && opts?.auth?.password) {
+    app.use(opts.path +'/*', async (c, next) => {
+      const realm = opts.auth?.realm || 'Docs'
+      const unauthorized = response.unauthorized(
+        null,
+        {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
+      )
+      if (!c.req.raw.headers.get('Authorization')) return unauthorized
+      const auth = basicAuth({ username: opts.auth.username, password: opts.auth.password, realm })
+
+      try {
+        await auth(c, next)
+      } catch {
+        return unauthorized
+      }
+    })
+  }
+
+  app.get(opts.path + '/openapi', async () => response.json(getHandler('RAJT_OPENAPI')))
+
+  app.get(
+    opts.path,
+    Scalar({
+      theme: 'saturn',
+      url: opts.path +'/openapi',
+      showDeveloperTools: 'never',
+      telemetry: false,
+      documentDownloadType: 'json', //'direct',
+      isLoading: true,
+      persistAuth: true,
+      hideClientButton: true,
+      pageTitle: opts.appName,
+      agent: { disabled: opts.agent },
+      slug: opts.appName?.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ opts.appVersion,
+      // hideDownloadButton: true,
+      // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
+      customCss: `[href="https://www.scalar.com"]{display:none}`,
+    })
+  )
+}

package/src/open-api/spec.ts

@@ -0,0 +1,41 @@
+import { STATUS_CODES } from 'node:http'
+import { generateSpecs, resolver } from 'hono-openapi'
+import { array, object, string } from 'zod/mini'
+import { Envir } from 't0n'
+import type { Hono } from '../types'
+import { config } from './register'
+
+export async function generateOpenAPI(app: Hono, conf: any) {
+  const opts = config(conf)
+  if (opts.disable) return {}
+
+  return await generateSpecs(app, {
+    documentation: {
+      info: {
+        title: opts.appName,
+        version: opts.appVersion,
+        description: Envir.get('APP_DESCRIPTION', ''),
+      },
+      components: {
+        securitySchemes: {
+          JWT: {
+            type: 'http',
+            scheme: 'bearer',
+            bearerFormat: 'JWT',
+          },
+        },
+        responses: {
+          500: {
+            description: STATUS_CODES[500],
+            content: { // @ts-ignore
+              'application/json': await resolver(object({
+                m: array(string()),
+              })).toOpenAPISchema(),
+            },
+          },
+          ...opts?.responses,
+        },
+      },
+    },
+  })
+}

package/src/prod.ts

@@ -1,5 +1,5 @@
 import Config from './config'
-import OAS from './oas'
+import { registerOpenAPI } from './open-api/register'
 import { Ability } from './auth'
 import createApp from './create-app'
 
@@ -14,6 +14,6 @@ Ability.roles = Config.get('roles', {})
 
 // @ts-ignore
 const app = createApp({ routes })
-OAS.register(app, Config.get('rajt', {}))
+registerOpenAPI(app, Config.get('rajt', {}))
 
 export { app }

package/src/request.ts

@@ -78,11 +78,13 @@ export default class $Request {
   }
 
   get ip(): string | undefined {
-    return this.#c.req.header('cf-connecting-ip')
-      || this.#c.req.header('x-forwarded-for')?.split(',')[0]?.trim()
+    return this.#c.req.header('cf-connecting-ip') // cf
+      || this.#c.req.header('x-forwarded-for')?.split(',').at(-1)?.trim() // aws lambda
       || this.#c.env?.aws?.lambda?.event?.requestContext?.identity?.sourceIp
-      || this.#c.req.header('x-real-ip')
-      || this.#c.env?.remoteAddr?.hostname
+      || this.#c.env?.event?.Records[0]?.cf?.request?.clientIp // aws lambda@edge
+      || this.#c.req.header('x-real-ip') // vercel
+      || this.#c.env?.context?.ip // netlify
+      || this.#c.env?.remoteAddr?.hostname // deno
   }
 
   get userAgent(): string | undefined {

package/src/routes.ts

@@ -13,12 +13,12 @@ import versionSHA from './utils/version-sha'
 import type { Routes, StandardSchemaV1 } from './types'
 import { rn, substep, warn } from './utils/log'
 import { _root } from './utils/paths'
-
-import OAS from './oas'
-import z from 'zod'
-import { resolver } from 'hono-openapi'
+import { generateOpenAPI } from './open-api/spec'
+import type * as z from 'zod'
+import { describeRoute, resolver } from 'hono-openapi'
 import { mimes } from 'hono/utils/mime'
 import { STATUS_CODES } from 'node:http'
+import { mw, resolve as _resolve } from './utils/resolve'
 
 import { highlightedMethod, highlightedURI } from './cli/utils'
 
@@ -344,7 +344,9 @@ export async function cacheRoutes() {
   middlewares.forEach(mw => registerMiddleware(mw.handle))
 
   // @ts-ignore
-  const openApi = await OAS.generateSpecs(createApp({ routes }), configs?.rajt || {})
+  const openApi = await generateOpenAPI(createApp({ routes, routeRegister: (app: Hono, route: Route) => {
+    app[route.method](route.path, describeRoute(route.desc), ...mw(route.middlewares, route.name), ..._resolve(route.handle, route.name))
+  } }), configs?.rajt || {})
 
   const iPath = join(_root, '.rajt/imports.mjs')
   ensureDir(iPath)

package/src/types.ts

@@ -10,7 +10,7 @@ import { mimes, type BaseMime } from 'hono/utils/mime'
 import type { OpenAPIV3_1, OpenAPIV3 } from 'openapi-types'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { DescribeRouteOptions as RawDescribeRouteOptions, ResolverReturnType } from 'hono-openapi'
-import z from 'zod'
+import type * as z from 'zod'
 import Action from './action'
 import request from './request'
 import response from './response'

package/src/utils/log.ts

@@ -1,4 +1,4 @@
-import { blue, bold, gray, green, magenta, red, yellow, white } from './colors'
+import { blue, bold, gray, green, magenta, red, yellow, white } from 't0n/color'
 
 const _step = (color: Function, ...msg: any[]) => {
   const length = msg.length

package/src/utils/resolve.ts

@@ -1,3 +1,5 @@
+import { getHandler } from '../register'
+
 export function resolve(obj: any, id: string) {
   if (typeof obj == 'function' && obj?.length == 2)
     return [obj]
@@ -33,3 +35,11 @@ export function resolveMiddleware(obj: any) {
 
   throw new Error('Invalid middleware provided. Must be a Hono middleware function or MiddlewareClass instance/constructor')
 }
+
+export function mw(...objs: string[]): Function[] {
+  return objs.flatMap(obj => {
+    if (typeof obj != 'string') return null
+    // @ts-ignore
+    return getHandler(obj)?.mw || null
+  }).flat().filter(Boolean)
+}

package/src/validator.ts

@@ -1,5 +1,5 @@
-import { ZodObject } from 'zod'
-import { validator } from 'hono-openapi'
+import type * as z from 'zod'
+import { zValidator } from '@hono/zod-validator'
 import response from './response'
 import type {
   Rule, Rules,
@@ -7,11 +7,11 @@ import type {
 } from './types'
 
 export default class $Validator {
-  private static cache = new Map<string, (schema: ZodObject<any>) => Rule>()
+  private static cache = new Map<string, (schema: z.ZodObject<any>) => Rule>()
 
   private static createRule<T extends keyof ValidationTargets>(
     target: T,
-    schema: ZodObject<any>
+    schema: z.ZodObject<any>
   ): Rule {
     return {
       target,
@@ -24,7 +24,7 @@ export default class $Validator {
     if (this.cache.has(target))
       return this.cache.get(target)
 
-    const fn = (schema: ZodObject<any>) => this.createRule(target, schema)
+    const fn = (schema: z.ZodObject<any>) => this.createRule(target, schema)
     this.cache.set(target, fn)
     return fn
   }
@@ -38,9 +38,9 @@ export default class $Validator {
 
   static parse(rules: Rules): Function[] {
     return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
-      .flatMap(rule => validator(rule.target, rule.schema, (result, c) => {
+      .flatMap(rule => zValidator(rule.target, rule.schema, (result, c) => {
         if (!result.success) // @ts-ignore
-          return response.badRequest(result.error)
+          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
       }))
   }
 }

package/src/oas.ts

@@ -1,110 +0,0 @@
-import { STATUS_CODES } from 'node:http'
-import { basicAuth } from 'hono/basic-auth'
-import { Scalar } from '@scalar/hono-api-reference'
-import { generateSpecs, resolver } from 'hono-openapi'
-import { Envir } from 't0n'
-import z from 'zod'
-import response from './response'
-import { getHandler } from './register'
-import type { Hono } from './types'
-
-// @ts-ignore TODO: remove dependency of 'package.json'...
-import packageJson from '../../../package.json'
-
-export default class OAS {
-  static #config(config: any) {
-    const docs = config?.docs ?? {}
-
-    const appName = Envir.get('APP_NAME', packageJson?.name || 'API Docs')
-    const appVersion = Envir.get('APP_VERSION', packageJson?.version || '1.0.0')
-
-    return {
-      ...docs,
-      disable: !!docs?.disable,
-      path: docs?.path || '/docs',
-      auth: docs?.auth || {},
-      agent: !docs?.agent,
-      appName, appVersion,
-    }
-  }
-
-  static register(app: Hono, config: any) {
-    const opts = this.#config(config)
-    if (opts.disable) return
-
-    if (opts?.auth?.username && opts?.auth?.password) {
-      app.use(opts.path +'/*', async (c, next) => {
-        const realm = opts.auth?.realm || 'Docs'
-        const unauthorized = response.unauthorized(
-          null,
-          {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
-        )
-        if (!c.req.raw.headers.get('Authorization')) return unauthorized
-        const auth = basicAuth({ username: opts.auth.username, password: opts.auth.password, realm })
-
-        try {
-          await auth(c, next)
-        } catch {
-          return unauthorized
-        }
-      })
-    }
-
-    app.get(opts.path + '/openapi', async () => response.json(getHandler('RAJT_OPENAPI')))
-
-    app.get(
-      opts.path,
-      Scalar({
-        theme: 'saturn',
-        url: opts.path +'/openapi',
-        showDeveloperTools: 'never',
-        telemetry: false,
-        documentDownloadType: 'json', //'direct',
-        isLoading: true,
-        persistAuth: true,
-        hideClientButton: true,
-        pageTitle: opts.appName,
-        agent: { disabled: opts.agent },
-        slug: opts.appName?.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^\w\s_-]/g, '').replace(/[\s_-]+/g, '_').replace(/[^\x00-\x7F]/g, '') +'_'+ opts.appVersion,
-        // hideDownloadButton: true,
-        // onLoaded: () => document?.querySelectorAll('[href="https://www.scalar.com"]')?.forEach(el => el.remove()),
-        customCss: `[href="https://www.scalar.com"]{display:none}`,
-      })
-    )
-  }
-
-  static async generateSpecs(app: Hono, config: any) {
-    const opts = this.#config(config)
-    if (opts.disable) return {}
-
-    return await generateSpecs(app, {
-      documentation: {
-        info: {
-          title: opts.appName,
-          version: opts.appVersion,
-          description: Envir.get('APP_DESCRIPTION', packageJson?.description || ''),
-        },
-        components: {
-          securitySchemes: {
-            JWT: {
-              type: 'http',
-              scheme: 'bearer',
-              bearerFormat: 'JWT',
-            },
-          },
-          responses: {
-            500: {
-              description: STATUS_CODES[500],
-              content: { // @ts-ignore
-                'application/json': await resolver(z.object({
-                  m: z.array(z.string()),
-                })).toOpenAPISchema(),
-              },
-            },
-            ...opts?.responses,
-          },
-        },
-      },
-    })
-  }
-}

package/src/utils/colors.ts

@@ -1,102 +0,0 @@
-// ISC License
-
-// Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
-
-// Permission to use, copy, modify, and/or distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-//
-// https://github.com/alexeyraspopov/picocolors/commit/6f0a4638348ed20633d623ee973f9c9a96f65104
-
-import { getColorEnabledAsync } from 'hono/utils/color'
-
-export const enabled = await getColorEnabledAsync()
-export const isColorSupported = enabled
-
-// const { env, stdout } = globalThis?.process ?? {}
-// const enabled =
-//   env &&
-//   !env.NO_COLOR &&
-//   (env.FORCE_COLOR || (stdout?.isTTY && !env.CI && env.TERM !== 'dumb'))
-
-const replaceClose = (
-  str: string,
-  close: string,
-  replace: string,
-  index: number
-): string => {
-  const start = str.substring(0, index) + replace
-  const end = str.substring(index + close.length)
-  const nextIndex = end.indexOf(close)
-  return ~nextIndex
-    ? start + replaceClose(end, close, replace, nextIndex)
-    : start + end
-}
-
-const formatter = (open: string, close: string, replace = open) => {
-  if (!enabled) return String
-  return (input: string) => {
-    const string = '' + input
-    const index = string.indexOf(close, open.length)
-    return ~index
-      ? open + replaceClose(string, close, replace, index) + close
-      : open + string + close
-  }
-}
-
-export const reset = enabled ? (s: string) => `\x1b[0m${s}\x1b[0m` : String
-export const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m')
-export const dim = formatter('\x1b[2m', '\x1b[22m', '\x1b[22m\x1b[2m')
-export const italic = formatter('\x1b[3m', '\x1b[23m')
-export const underline = formatter('\x1b[4m', '\x1b[24m')
-export const inverse = formatter('\x1b[7m', '\x1b[27m')
-export const hidden = formatter('\x1b[8m', '\x1b[28m')
-export const strikethrough = formatter('\x1b[9m', '\x1b[29m')
-
-const endText = '\x1b[39m'
-export const black = formatter('\x1b[30m', endText)
-export const red = formatter('\x1b[31m', endText)
-export const green = formatter('\x1b[32m', endText)
-export const yellow = formatter('\x1b[33m', endText)
-export const blue = formatter('\x1b[34m', endText)
-export const magenta = formatter('\x1b[35m', endText)
-export const purple = formatter('\x1b[38;2;173;127;168m', endText)
-export const cyan = formatter('\x1b[36m', endText)
-export const white = formatter('\x1b[37m', endText)
-export const gray = formatter('\x1b[90m', endText)
-
-const endBg = '\x1b[49m'
-export const bgBlack = formatter('\x1b[40m', endBg)
-export const bgRed = formatter('\x1b[41m', endBg)
-export const bgGreen = formatter('\x1b[42m', endBg)
-export const bgYellow = formatter('\x1b[43m', endBg)
-export const bgBlue = formatter('\x1b[44m', endBg)
-export const bgMagenta = formatter('\x1b[45m', endBg)
-export const bgCyan = formatter('\x1b[46m', endBg)
-export const bgWhite = formatter('\x1b[47m', endBg)
-
-export const blackBright = formatter("\x1b[90m", endText)
-export const redBright = formatter("\x1b[91m", endText)
-export const greenBright = formatter("\x1b[92m", endText)
-export const yellowBright = formatter("\x1b[93m", endText)
-export const blueBright = formatter("\x1b[94m", endText)
-export const magentaBright = formatter("\x1b[95m", endText)
-export const cyanBright = formatter("\x1b[96m", endText)
-export const whiteBright = formatter("\x1b[97m", endText)
-
-export const bgBlackBright = formatter("\x1b[100m", endBg)
-export const bgRedBright = formatter("\x1b[101m", endBg)
-export const bgGreenBright = formatter("\x1b[102m", endBg)
-export const bgYellowBright = formatter("\x1b[103m", endBg)
-export const bgBlueBright = formatter("\x1b[104m", endBg)
-export const bgMagentaBright = formatter("\x1b[105m", endBg)
-export const bgCyanBright = formatter("\x1b[106m", endBg)
-export const bgWhiteBright = formatter("\x1b[107m", endBg)