rajt 0.0.96 → 0.0.98

package/bin/rajt.js

@@ -93,8 +93,8 @@ function semiver(a, b, bool) {
 function directly() {
   try {
     const arg = (process.argv[1] || '')?.replace(/\\/g, '/');
-    return arg?.endsWith('node_modules/.bin/rajt')
-      || arg?.endsWith('node_modules/rajt/bin/rajt.js')
+    return arg?.endsWith('.bin/rajt')
+      || arg?.endsWith('rajt/bin/rajt.js')
   } catch {
     return false
   }

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.96",
+  "version": "0.0.98",
   "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,44 +35,37 @@
     "zip": "zip -j ../../lambda.zip ../../.rajt/dist/index.js"
   },
   "dependencies": {
-    "cripta": "^0.1",
-    "forj": "^0.1",
-    "t0n": "^0.1",
     "@hono/node-server": "^1.19.9",
     "@hono/standard-validator": "^0.2.2",
     "@scalar/hono-api-reference": "^0.9.40",
-    "chokidar-cli": "^3.0.0",
+    "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",
     "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.11",
     "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"
   },
   "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",
-    "@types/node": "^20.11.0",
-    "bun-types": "^1.2.14",
+    "@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"
   },

package/src/auth/ability.ts

@@ -13,12 +13,6 @@ export class Ability {
   static fromRoutes(actions: Routes) {
     if (!actions?.length) return
 
-    const paths = actions?.map(a => Array.isArray(a) ? a[0] + a[1] : a.method + a.path) || []
-    const items = new Set(paths)
-
-    if (items.size != actions.length)
-      throw new Error(`Duplicate routes detected: "${paths.filter((path, index) => paths.indexOf(path) != index).join('", "')}"`)
-
     this.#abilities = Array.from(new Set(actions?.map(a => Array.isArray(a) ? a[3] : a.name) || []))
       .map(a => this.format(a))
       .filter(Boolean)

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/deploy.ts

@@ -1,8 +1,9 @@
 import { spawn } from 'node:child_process'
 import { defineCommand } from 'citty'
 
-import { _root, normalizePlatform, platformError, getRuntime } from '../utils'
+import { normalizePlatform, platformError, getRuntime } from '../utils'
 import { error } from '../../utils/log'
+import { _root } from '../../utils/paths'
 import { platforms } from '../constants'
 
 import build from './build'

package/src/cli/commands/dev.ts

@@ -4,11 +4,12 @@ import { spawn, type ChildProcess } from 'node:child_process'
 import { defineCommand } from 'citty'
 import type { Miniflare } from 'miniflare'
 import {
-	_root, build, wait, watch, normalizePlatform, platformError, getRuntime,
+	build, wait, watch, normalizePlatform, platformError, getRuntime,
 	wranglerConfig, createMiniflare, localflareManifest,
 	getDockerHost
 } from '../utils'
 import { error, event, log, rn, warn } from '../../utils/log'
+import { _root } from '../../utils/paths'
 import { withPort } from '../../utils/port'
 import shutdown from '../../utils/shutdown'
 
@@ -165,7 +166,9 @@ export default defineCommand({
 					let localflare: Miniflare | null = null
 					const startWorker = async () => {
 						if (worker) await worker.dispose()
-						if (localflare) await localflare.dispose()
+            if (localflare) await localflare.dispose()
+
+            // await wait(500)
 
 						const workerConfig = await wranglerConfig()
 						workerConfig.host = host
@@ -179,7 +182,7 @@ export default defineCommand({
 								...workerConfig.vars,
 								LOCALFLARE_MANIFEST: JSON.stringify(localflareManifest(workerConfig)),
 							},
-							main: 'node_modules/localflare-api/dist/worker/index.js',
+							main: '.rajt/localfire.js',
 							port: 8788,
 							inspectorPort: 9230,
 						})

package/src/cli/commands/make.ts

@@ -1,9 +1,10 @@
 import { defineCommand } from 'citty'
 import { join, relative } from 'pathe'
 import { Migrator } from 'forj'
-import { _root, makeFile, hasExt, camelCase, kebabCase } from '../utils'
+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,8 +2,9 @@ import { defineCommand } from 'citty'
 import { spawn } from 'node:child_process'
 import { join } from 'pathe'
 import { Migrator } from 'forj'
-import { gray } from '../../utils/colors'
-import { _root, getRuntime, cleanDB, cleanDir } from '../utils'
+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'
 
 export default defineCommand({

package/src/cli/commands/routes.ts

@@ -2,9 +2,9 @@ import { join } from 'pathe'
 import { defineCommand } from 'citty'
 import { inspectRoutes } from 'hono/dev'
 import { IMPORT } from 't0n'
-import { gray, purple, red, yellow } from '../../utils/colors'
-import { __rajt } from '../utils'
+import { _rajt } from '../../utils/paths'
 import { rn } from '../../utils/log'
+import { highlightedURI, highlightedMethod } from '../utils'
 
 export default defineCommand({
 	meta: {
@@ -26,7 +26,7 @@ export default defineCommand({
 		},
 	},
 	async run({ args }) {
-		const mod = await IMPORT(join(__rajt, 'dev.ts'))
+		const mod = await IMPORT(join(_rajt, 'dev.ts'))
 		const app = mod.default
 
 		const opts = {
@@ -39,28 +39,6 @@ export default defineCommand({
 		let maxMethodLength = 0
 		let maxPathLength = 0
 
-		const colorMethod = (method: string, str?: string) => {
-			const val = str || method
-
-			switch (method) {
-				case 'HEAD':
-				case 'OPTIONS':
-				case 'CONNECT':
-				case 'TRACE':
-					return gray(val)
-				case 'GET':
-					return purple(val)
-				case 'POST':
-				case 'PUT':
-				case 'PATCH':
-					return yellow(val)
-				case 'DELETE':
-					return red(val)
-			}
-
-			return val
-		}
-
 		let routes = inspectRoutes(app)
 			.filter(({ method, path, isMiddleware }) => {
 				const key = method + '-' + path
@@ -88,17 +66,12 @@ export default defineCommand({
 			const { method, path } = route
 
 			let mLength = method.length
-			let str = colorMethod(method)
+			let str = highlightedMethod(method, null, true)
 
-			if (method == 'GET') {
+			if (method == 'GET')
 				mLength += 5
-				str += gray('|') + colorMethod('HEAD')
-			}
 
-			console.log(str + ' '.repeat(maxMethodLength - mLength) +'  '+ path.replace(
-				/(?::([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]+\})?|\*)/g,
-				_ => colorMethod(method, _)
-			))
+			console.log(str + ' '.repeat(maxMethodLength - mLength) +'  '+ highlightedURI(path, method))
 		})
 
 		rn()

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

@@ -3,21 +3,19 @@ import { Miniflare } from 'miniflare'
 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 crypto, { createHash } from 'node:crypto'
+import { createHash, createHmac } from 'node:crypto'
 
 import { findWranglerConfig, parseWranglerConfig, WRANGLER_CONFIG_FILES } from 'localflare-core'
 import type { WranglerConfig, LocalflareManifest } from 'localflare-core'
 
 import chokidar from 'chokidar'
-import { gray, bold, italic } from '../utils/colors'
+import { gray, bold, italic, purple, yellow, red } from 't0n/color'
 import type { ChokidarEventName, Platform } from './types'
 
 import { cacheRoutes } from '../routes'
 import { substep, event, error, wait as wwait, warn, log } from '../utils/log'
 import { platforms } from './constants'
-
-export const _root = join(dirname(new URL(import.meta.url).pathname), '../../../../')
-export const __rajt = join(_root, 'node_modules/rajt/src')
+import { _rajt, _root } from '../utils/paths'
 
 export function normalizePlatform(platform: Platform) {
   platform = platform?.toLowerCase() as Platform
@@ -91,7 +89,7 @@ export const build = async (platform: Platform) => {
   // @ts-ignore
   platform = platform != 'node' ? '-'+ platform : ''
   const opts = {
-    entryPoints: [join(__rajt, `prod${platform}.ts`)],
+    entryPoints: [join(_rajt, `prod${platform}.ts`)],
     bundle: true,
     minify: true,
     outfile: join(_root, dist +'/index.js'),
@@ -122,6 +120,12 @@ export const build = async (platform: Platform) => {
     // sourcemap: true,
     // logLevel: 'info',
     plugins: [
+      {
+        name: 'rajt-resolver',
+        setup(build) {
+          build.onResolve({ filter: /\.rajt[\/\\]/ }, args => ({ path: join(_root, args.path) }))
+        }
+      },
       {
         name: 'preserve-class-names',
         setup(build) {
@@ -199,11 +203,11 @@ export function cleanDir(path: string) {
 }
 
 function durableObjectNamespace(name: string, uniqueKey: string) {
-  const key = crypto.createHash('sha256').update(uniqueKey).digest()
-  const nameHmac = crypto.createHmac('sha256', key).update(name).digest().subarray(0, 16)
+  const key = createHash('sha256').update(uniqueKey).digest()
+  const nameHmac = createHmac('sha256', key).update(name).digest().subarray(0, 16)
   return Buffer.concat([
     nameHmac,
-    crypto.createHmac('sha256', key).update(nameHmac).digest().subarray(0, 16)
+    createHmac('sha256', key).update(nameHmac).digest().subarray(0, 16)
   ]).toString('hex')
 }
 
@@ -474,3 +478,30 @@ export const camelCase = (text: string) =>
     .filter(word => word.length > 0)
     .map(word => word.charAt(0).toUpperCase() + word.slice(1))
     .join('')
+
+export const highlightedMethod = (method: string, str?: string | null, siblings: boolean = false): string => {
+  const val = str || method
+
+  switch (method) {
+    case 'HEAD':
+    case 'OPTIONS':
+    case 'CONNECT':
+    case 'TRACE':
+      return gray(val)
+    case 'GET':
+      return purple(val) + (siblings ? gray('|') + highlightedMethod('HEAD') : '')
+    case 'POST':
+    case 'PUT':
+    case 'PATCH':
+      return yellow(val)
+    case 'DELETE':
+      return red(val)
+  }
+
+  return val
+}
+
+export const highlightedURI = (uri: string, method: string) => uri.replace(
+  /(?::([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]+\})?|\*)/g,
+  _ => highlightedMethod(method, _)
+)

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

@@ -13,7 +13,7 @@ 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'
 
 const NFHandler = () => response.notFound()
 const EHandler = async (e: Error | HTTPResponseError) => {

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 './oas'
 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/oas.ts

@@ -8,103 +8,98 @@ 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 function config(opts: any) {
+  const docs = opts?.docs ?? {}
 
-export default class OAS {
-  static #config(config: any) {
-    const docs = config?.docs ?? {}
+  const appName = Envir.get('APP_NAME', 'API Docs')
+  const appVersion = Envir.get('APP_VERSION') || Envir.get('VERSION_HASH') || '1.0.0'
 
-    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,
-    }
+  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
+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 })
+  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
-        }
-      })
-    }
+      try {
+        await auth(c, next)
+      } catch {
+        return unauthorized
+      }
+    })
+  }
 
-    app.get(opts.path + '/openapi', async () => response.json(getHandler('RAJT_OPENAPI')))
+  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}`,
-      })
-    )
-  }
+  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 {}
+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', packageJson?.description || ''),
-        },
-        components: {
-          securitySchemes: {
-            JWT: {
-              type: 'http',
-              scheme: 'bearer',
-              bearerFormat: 'JWT',
-            },
+  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(z.object({
-                  m: z.array(z.string()),
-                })).toOpenAPISchema(),
-              },
+        },
+        responses: {
+          500: {
+            description: STATUS_CODES[500],
+            content: { // @ts-ignore
+              'application/json': await resolver(z.object({
+                m: z.array(z.string()),
+              })).toOpenAPISchema(),
             },
-            ...opts?.responses,
           },
+          ...opts?.responses,
         },
       },
-    })
-  }
+    },
+  })
 }

package/src/prod.ts

@@ -1,12 +1,12 @@
 import Config from './config'
-import OAS from './oas'
+import { registerOpenAPI } from './oas'
 import { Ability } from './auth'
 import createApp from './create-app'
 
 // @ts-ignore
-import '../../../.rajt/imports.mjs'
+import '.rajt/imports.mjs'
 // @ts-ignore
-import routes from '../../../.rajt/routes.json'
+import routes from '.rajt/routes.json'
 
 // @ts-ignore
 Ability.fromRoutes(routes)
@@ -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

@@ -1,5 +1,5 @@
-import { existsSync, readdirSync, statSync, writeFileSync } from 'node:fs'
-import { dirname, join, resolve } from 'pathe'
+import { copyFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, resolve, relative } from 'pathe'
 
 import glob from 'tiny-glob'
 import { config } from 'dotenv'
@@ -11,16 +11,16 @@ import { isAnonFn } from './utils/func'
 import ensureDir from './utils/ensuredir'
 import versionSHA from './utils/version-sha'
 import type { Routes, StandardSchemaV1 } from './types'
-import { substep, warn } from './utils/log'
+import { rn, substep, warn } from './utils/log'
+import { _root } from './utils/paths'
 
-import OAS from './oas'
+import { generateOpenAPI } from './oas'
 import z from 'zod'
 import { resolver } from 'hono-openapi'
 import { mimes } from 'hono/utils/mime'
 import { STATUS_CODES } from 'node:http'
 
-const __filename = new URL(import.meta.url).pathname
-const __root = resolve(dirname(__filename), '../../..')
+import { highlightedMethod, highlightedURI } from './cli/utils'
 
 const importName = (name?: string) => (name || 'Fn'+ Math.random().toString(36).substring(2)).replace(/\.ts$/, '')
 const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string[] = []): Promise<void> => {
@@ -105,9 +105,17 @@ export async function getRoutes(
   let length = 0
   const keys: Set<string> = new Set()
   const bag: Record<string, string[]> = {}
+  const _route = (key: string, _: string) => {
+    if (!keys.has(key)) {
+      keys.add(key)
+    } else {
+      ;(bag[key] ||= []).push(_)
+      length++
+    }
+  }
 
   await Promise.all(dirs.map(dir => walk(
-    resolve(__root, dir),
+    resolve(_root, dir),
     dir,
     (path: string, baseDir: string, handle: any, middlewares: string[]) => {
       const name = importName(handle?.name)
@@ -136,21 +144,26 @@ export async function getRoutes(
         desc,
       })
 
-      if (!keys.has(name)) {
-        keys.add(name)
-      } else {
-        ;(bag[name] ||= []).push(file)
-        length++
-      }
+      const routeKey = method +'|'+ uri
+      _route(name, file)
+      _route(routeKey, file)
     }
   )))
 
   if (length) {
     hasDuplicatedRoutes = true
     Object.entries(bag).forEach(([name, paths]) => {
-      warn(`Route "${name}" has `+ (paths.length > 1 ? `registered ${paths.length} times:` : 'already been registered:'))
+      if (name.includes('|')) {
+        let [method, uri] = name.split('|')
+        method = method.toUpperCase()
+        name =  `${highlightedMethod(method, null, true)}  "${highlightedURI(uri, method)}"`
+      }
+
+      warn(`Route ${name} has `+ (paths.length > 1 ? `registered ${paths.length} times:` : 'already been registered:'))
       substep(...paths)
     })
+
+    rn()
   }
 
   return sortRoutes(routes)
@@ -224,7 +237,7 @@ export async function getMiddlewares(
   const mw: Routes = []
 
   await Promise.all(dirs.map(dir => walk(
-    resolve(__root, dir),
+    resolve(_root, dir),
     dir,
     (fullPath: string, baseDir: string, handle: any) => {
       // @ts-ignore
@@ -246,15 +259,15 @@ function extractName(file: string) {
 export async function getConfigs(
   dirs: string[] = ['configs']
 ): Promise<Record<string, any>> {
-  dirs = dirs.filter(dir => existsSync(join(__root, dir)))
+  dirs = dirs.filter(dir => existsSync(join(_root, dir)))
   if (!dirs?.length) return {}
   const configs: Record<string, any> = {}
 
-  const files = (await glob(join(__root, dirs?.length > 1 ? `{${dirs.join(',')}}` : dirs[0], '/**/*.{ts,js,cjs,mjs,json}')))
+  const files = (await glob(join(_root, dirs?.length > 1 ? `{${dirs.join(',')}}` : dirs[0], '/**/*.{ts,js,cjs,mjs,json}')))
     .filter(file => !file.includes('.d.'))
 
   for (const file of files) {
-    const mod = await IMPORT(join(__root, file))
+    const mod = await IMPORT(join(_root, file))
     const keyPath = extractName(file).split('.')
 
     keyPath.reduce((acc, key, index) => {
@@ -296,16 +309,26 @@ function stringifyToJS(value: unknown): string {
   return 'undefined'
 }
 
+export async function dependencyEntry(lib: string, root: string) {
+  const path = await import.meta.resolve(lib)
+  return relative(root, path.replace('file://', ''))
+}
+
+async function dependencyPath(lib: string) {
+  const entry = await dependencyEntry(lib, join(_root, '.rajt'))
+  return entry.substring(0, entry.lastIndexOf(lib) + lib.length)
+}
+
 export async function cacheRoutes() {
   const env = Object.entries(
-    config({ path: '../../.env.prod' })?.parsed || {}
+    config({ path: join(_root, '.env.prod') })?.parsed || {}
   ).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
 
   const version = versionSHA('../../.git') // @ts-ignore
   env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version]) // @ts-ignore
   env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
 
-  const rolePath = join(__root, 'configs/roles.ts')
+  const rolePath = join(_root, 'configs/roles.ts')
   ensureDir(rolePath)
   if (!existsSync(rolePath))
     writeFileSync(rolePath, `export default {\n\n}`)
@@ -321,15 +344,20 @@ 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 }), configs?.rajt || {})
 
-  const iPath = join(__root, '.rajt/imports.mjs')
+  const iPath = join(_root, '.rajt/imports.mjs')
   ensureDir(iPath)
+
+  const localfireEntry = await dependencyEntry('localflare-api', _root)
+  copyFileSync(localfireEntry, join(_root, '.rajt/localfire.js'))
+
+  const _rajtDir = await dependencyPath('rajt')
   writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
-${Object.entries(configs)?.length ? `import Config from '../node_modules/rajt/src/config'\nConfig.add(${stringifyToJS(configs)})` : ''}
+${env?.length ? `import { Envir } from '${await dependencyPath('t0n')}/dist/index'\nEnvir.add({${env.map(([key, val]) => key +':'+ stringifyToJS(val)).join(',')}})` : ''}
+${Object.entries(configs)?.length ? `import Config from '${_rajtDir}/src/config'\nConfig.add(${stringifyToJS(configs)})` : ''}
 
-import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
+import { registerHandler, registerMiddleware } from '${_rajtDir}/src/register'
 
 ${Object.entries(openApi)?.length ? `registerHandler('RAJT_OPENAPI', ${stringifyToJS(openApi)})` : ''}
 
@@ -355,7 +383,7 @@ try {
 }
 `)
 
-  const rPath = join(__root, '.rajt/routes.json')
+  const rPath = join(_root, '.rajt/routes.json')
   ensureDir(rPath)
   writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
     route.method,

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/paths.ts

@@ -0,0 +1,5 @@
+import { dirname, join } from 'pathe'
+import { Envir } from 't0n'
+
+export const _rajt = join(dirname(new URL(import.meta.url).pathname), '..')
+export const _root = Envir.get('npm_config_local_prefix') || Envir.get('PWD') || join(_rajt, '../../../')

package/src/validator.ts

@@ -1,4 +1,4 @@
-import { ZodObject } from 'zod'
+import type { ZodObject } from 'zod'
 import { validator } from 'hono-openapi'
 import response from './response'
 import type {

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)