@asterflow/router 1.0.13 → 2.0.0

package/README.md

@@ -4,162 +4,69 @@
 
 ![license-info](https://img.shields.io/github/license/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
 ![stars-info](https://img.shields.io/github/stars/AsterFlow/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
-![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Frequest&style=for-the-badge&colorA=302D41&colorB=b4befe)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Frouter&style=for-the-badge&colorA=302D41&colorB=b4befe)
 
-![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/request?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/router?style=for-the-badge&colorA=302D41&colorB=3ac97b)
 
 </div>
 
-> Type-safe and flexible routing system for AsterFlow applications.
+> Typed route and middleware definitions (`Method`, `Router`, `Middleware`) for AsterFlow applications.
 
 ## 📦 Installation
 
 ```bash
-npm install @asterflow/router
-# or
 bun install @asterflow/router
 ```
 
-## 💡 About
+### ✨ Features
 
-@asterflow/router is the routing foundation of AsterFlow. It provides a powerful, type-safe routing system with support for middleware, parameter validation, and flexible route organization.
+- **`Method`** - defines a single route bound to one HTTP verb, passed as the first argument (`new Method('post', {...})` or `Method.POST`). `Method.create(method)` defers the handler so plugins can chain in request extensions (e.g. `.multipart({...})`) before the terminal `.handler(fn)` call.
+- **`Router`** - groups handlers for several HTTP verbs under one path. `Router.builder()` gives an extensible, per-method builder (`.method('post', b => ...)`) so each verb can carry its own request extensions independently.
+- **`Middleware`** - typed middleware chain. `onRun` either calls `next(params)` to continue (merging `params` into the typed `middleware` context) or returns an `AsterResponse` to short-circuit the chain.
+- **Schema validation** - route schemas accept a Zod schema or a `@caeljs/tsh` shape; the parsed result is inferred straight into the handler's `schema` argument.
+- **Extension registry** - a `WeakMap`-based store (`extensionRegistry.ts`) that plugins use to attach per-router, per-method data, read back at request time.
 
-## ✨ Features
+## ❓ How to Use
 
-- **Complete Type Safety:** Full TypeScript support with type inference for routes, parameters, and responses
-- **Middleware System:** Support for middlewares with typed context and chaining
-- **Parameter Validation:** Built-in support for Zod and @caeljs/tsh
-- **URL Analysis:** Integrated URL parser with support for dynamic parameters, query strings, and fragments
-- **Standardized Responses:** Typed response system with helpers for common HTTP codes
-- **Flexible Organization:** Support for individual routes (Method) and grouped routes (Router)
+For a normal route, use `new Method(method, options)` - the HTTP method comes first, either as a plain string or as one of `Method`'s own constants (`Method.GET`, `Method.POST`, ...) - and validate the body with Zod:
 
-## 🚀 Usage
-
-### Basic Router Route
-
-```typescript
-import { Router } from '@asterflow/router'
-
-const router = new Router({
-  path: '/hello/:name',
-  methods: {
-    get({ response, url }) {
-      const params = url.getParams()
-      return response.success({ 
-        message: `Hello ${params.name}!` 
-      })
-    }
-  }
-})
-```
-
-### Using Middlewares
-
-```typescript
-import { Middleware, Router } from '@asterflow/router'
-
-const authMiddleware = new Middleware({
-  name: 'auth',
-  onRun({ next }) {
-    return next({
-      isAuthenticated: true,
-      user: { id: 1 }
-    })
-  }
-})
-
-const router = new Router({
-  path: '/protected',
-  use: [authMiddleware],
-  methods: {
-    get({ response, middleware }) {
-      if (!middleware.isAuthenticated) {
-        return response.unauthorized({ message: 'Not authenticated' })
-      }
-      return response.success({ user: middleware.user })
-    }
-  }
-})
-```
-
-### Validation with Zod
-
-```typescript
+```ts
 import { Method } from '@asterflow/router'
 import { z } from 'zod'
 
-const createUser = new Method({
+export default new Method(Method.POST, {
   path: '/users',
-  method: 'post',
-  schema: z.object({
-    name: z.string(),
-    email: z.string().email()
-  }),
-  handler: ({ schema, response }) => {
-    return response.created({
-      user: {
-        name: schema.name,
-        email: schema.email
-      }
-    })
-  }
-})
-```
-
-### URL Parameters
-
-```typescript
-import { Router } from '@asterflow/router'
-
-const router = new Router({
-  // Supports dynamic parameters (:id), 
-  // query strings (?page) and 
-  // fragments (#section)
-  path: '/users/:id=number?page#section',
-  methods: {
-    get({ url, response }) {
-      console.log(url.getParams())      // { id: number }
-      console.log(url.getSearchParams()) // { page: string }
-      console.log(url.getFragment())     // 'section'
-      return response.success({ /* ... */ })
-    }
+  schema: z.object({ name: z.string(), email: z.string().email() }),
+  handler({ schema, response }) {
+    return response.created({ user: schema })
   }
 })
 ```
 
-### Integrating with Fastify
+Only reach for `Method.create(method, options?)` when you need a plugin's fully-typed extension - like multipart's `.multipart(schema)` - chained in before the handler. `create()` defers the handler so the extension can widen the request type first, and `options` is optional:
 
-```typescript
-import { adapters } from '@asterflow/adapter'
-import { AsterFlow } from 'asterflow'
-import fastify from 'fastify'
-
-const server = fastify()
-const app = new AsterFlow({ 
-  driver: adapters.fastify 
-})
-
-// Add routes
-app.controller(router)
+```ts
+import { Method } from '@asterflow/router'
 
-// Start the server
-app.listen(server, { port: 3333 }, (err) => {
-  if (err) {
-    console.error(err)
-    process.exit(1)
-  }
-  console.log('Server listening!')
-})
+export default Method.create(Method.POST)
+  .multipart({
+    avatar: { mimeTypes: ['image/png', 'image/jpeg'], maxSize: 5 * 1024 * 1024, required: true }
+  })
+  .handler(({ request, response }) => {
+    const avatar = request.getFile('avatar')
+    return response.success({ filename: avatar.filename })
+  })
 ```
 
+Both examples use `export default`: it's what `app.controller(route)` expects when you register a route by hand, and it's the export `@asterflow/fs`'s file-based routing looks for in every route file.
+
 ## 🔗 Related Packages
 
-- [asterflow](https://www.npmjs.com/package/asterflow) - Core framework
-- [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - Adapters for different HTTP servers
-- [@asterflow/response](https://www.npmjs.com/package/@asterflow/response) - Type-safe HTTP response system
-- [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - Unified HTTP request system
-- [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - A modular and typed plugin system
+- [asterflow](https://www.npmjs.com/package/asterflow) - core framework, depends on this package to register and run routes
+- [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - request abstraction; this package imports its `Request`/`AsterRequest` types for route and middleware handlers
+- [@asterflow/fs](https://www.npmjs.com/package/@asterflow/fs) - filesystem-based routing plugin, builds routes with `Method`/`Router`
+- [@asterflow/multipart](https://www.npmjs.com/package/@asterflow/multipart) - multipart upload plugin, extends `Method` routes
 
 ## 📄 License
 
-MIT - See [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.
+This project is licensed under the [MIT License](../../LICENSE).

package/dist/cjs/index.cjs

@@ -1,45 +1,78 @@
 "use strict";
-var o = Object.defineProperty;
-var c = Object.getOwnPropertyDescriptor;
-var w = Object.getOwnPropertyNames;
-var y = Object.prototype.hasOwnProperty;
-var M = (t, e) => {
-  for (var n in e)
-    o(t, n, { get: e[n], enumerable: !0 });
-}, u = (t, e, n, d) => {
+var i = Object.defineProperty;
+var x = Object.getOwnPropertyDescriptor;
+var M = Object.getOwnPropertyNames;
+var w = Object.prototype.hasOwnProperty;
+var f = (r, e) => {
+  for (var t in e)
+    i(r, t, { get: e[t], enumerable: !0 });
+}, g = (r, e, t, s) => {
   if (e && typeof e == "object" || typeof e == "function")
-    for (let s of w(e))
-      !y.call(t, s) && s !== n && o(t, s, { get: () => e[s], enumerable: !(d = c(e, s)) || d.enumerable });
-  return t;
+    for (let n of M(e))
+      !w.call(r, n) && n !== t && i(r, n, { get: () => e[n], enumerable: !(s = x(e, n)) || s.enumerable });
+  return r;
 };
-var x = (t) => u(o({}, "__esModule", { value: !0 }), t);
+var A = (r) => g(i({}, "__esModule", { value: !0 }), r);
 // packages/router/src/index.ts
-var R = {};
-M(R, {
-  Method: () => p,
-  MethodType: () => m,
-  Middleware: () => i,
-  Router: () => a
+var E = {};
+f(E, {
+  Method: () => u,
+  MethodType: () => c,
+  Middleware: () => l,
+  RouteMethodBuilder: () => a,
+  Router: () => d,
+  RouterBuilder: () => p,
+  getRouteExtensions: () => S,
+  setRouteExtensions: () => h
 });
-module.exports = x(R);
+module.exports = A(E);
+// packages/router/src/controllers/extensionRegistry.ts
+var m =  new WeakMap();
+function h(r, e) {
+  Object.keys(e).length !== 0 && m.set(r, e);
+}
+function S(r) {
+  return m.get(r);
+}
 // packages/router/src/controllers/Router.ts
-var a = class t {
+var d = class r {
   name;
   path;
+  param;
   schema;
   description;
   methods;
   use;
   constructor(e) {
-    let { name: n, path: d, schema: s, description: h, methods: l } = e;
-    this.name = n, this.path = d, this.schema = s, this.description = h, this.methods = l, this.use = e.use;
+    let { name: t, path: s, param: n, schema: y, description: P, methods: R } = e;
+    this.name = t, this.path = s ?? n, this.schema = y, this.description = P, this.methods = R, this.use = e.use;
   }
   static create() {
-    return (e) => new t(e);
+    return (e) => new r(e);
+  }
+  static builder(e) {
+    return new p(e);
+  }
+}, a = class {
+  registrations = {};
+  extend(e, t) {
+    return t && Object.assign(this.registrations, t), this;
+  }
+  handler(e) {
+    return { handler: e, registrations: this.registrations };
+  }
+}, p = class extends d {
+  perMethodRegistrations = {};
+  constructor(e = {}) {
+    super({ ...e, methods: {} });
+  }
+  method(e, t) {
+    let s = t(new a());
+    return this.methods[e] = s.handler, Object.keys(s.registrations).length > 0 && (this.perMethodRegistrations[e] = s.registrations, h(this, this.perMethodRegistrations)), this;
   }
 };
 // packages/router/src/controllers/Middleware.ts
-var i = class {
+var l = class {
   name;
   onRun;
   constructor(e) {
@@ -47,22 +80,49 @@ var i = class {
   }
 };
 // packages/router/src/controllers/Method.ts
-var p = class {
+var u = class r {
+  static ALL = "all";
+  static GET = "get";
+  static POST = "post";
+  static PUT = "put";
+  static DELETE = "delete";
+  static OPTIONS = "options";
+  static HEAD = "head";
+  static PATCH = "patch";
   path;
+  param;
   method;
   schema;
   name;
   use;
   handler;
-  constructor(e) {
-    this.path = e.path, this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
+  extensions = {};
+  constructor(e, t) {
+    this.path = t.path ?? t.param, this.method = e, this.schema = t.schema, this.use = t.use, this.handler = t.handler ?? ((s) => {
+      if (typeof s != "function")
+        throw new TypeError("This route was built with Method.create(...) but never finished with a terminal .handler(...) call before being used.");
+      return this.handler = s, this;
+    });
+  }
+  static create(e, t = {}) {
+    return new r(e, {
+      ...t,
+      handler: void 0
+    });
+  }
+  extend(e, t) {
+    return t && Object.assign(this.extensions, t), this;
   }
 };
 // packages/router/src/types/method.ts
-var m =  ((r) => (r.all = "all", r.get = "get", r.post = "post", r.put = "put", r.delete = "delete", r.options = "options", r.head = "head", r.patch = "patch", r))(m || {});
+var c =  ((o) => (o.all = "all", o.get = "get", o.post = "post", o.put = "put", o.delete = "delete", o.options = "options", o.head = "head", o.patch = "patch", o))(c || {});
 0 && (module.exports = {
   Method,
   MethodType,
   Middleware,
-  Router
+  RouteMethodBuilder,
+  Router,
+  RouterBuilder,
+  getRouteExtensions,
+  setRouteExtensions
 });

package/dist/mjs/index.js

@@ -1,21 +1,50 @@
+// packages/router/src/controllers/extensionRegistry.ts
+var p =  new WeakMap();
+function i(r, e) {
+  Object.keys(e).length !== 0 && p.set(r, e);
+}
+function R(r) {
+  return p.get(r);
+}
 // packages/router/src/controllers/Router.ts
-var s = class r {
+var n = class r {
   name;
   path;
+  param;
   schema;
   description;
   methods;
   use;
   constructor(e) {
-    let { name: o, path: a, schema: i, description: p, methods: m } = e;
-    this.name = o, this.path = a, this.schema = i, this.description = p, this.methods = m, this.use = e.use;
+    let { name: t, path: s, param: u, schema: m, description: c, methods: y } = e;
+    this.name = t, this.path = s ?? u, this.schema = m, this.description = c, this.methods = y, this.use = e.use;
   }
   static create() {
     return (e) => new r(e);
   }
+  static builder(e) {
+    return new a(e);
+  }
+}, d = class {
+  registrations = {};
+  extend(e, t) {
+    return t && Object.assign(this.registrations, t), this;
+  }
+  handler(e) {
+    return { handler: e, registrations: this.registrations };
+  }
+}, a = class extends n {
+  perMethodRegistrations = {};
+  constructor(e = {}) {
+    super({ ...e, methods: {} });
+  }
+  method(e, t) {
+    let s = t(new d());
+    return this.methods[e] = s.handler, Object.keys(s.registrations).length > 0 && (this.perMethodRegistrations[e] = s.registrations, i(this, this.perMethodRegistrations)), this;
+  }
 };
 // packages/router/src/controllers/Middleware.ts
-var n = class {
+var h = class {
   name;
   onRun;
   constructor(e) {
@@ -23,22 +52,49 @@ var n = class {
   }
 };
 // packages/router/src/controllers/Method.ts
-var d = class {
+var l = class r {
+  static ALL = "all";
+  static GET = "get";
+  static POST = "post";
+  static PUT = "put";
+  static DELETE = "delete";
+  static OPTIONS = "options";
+  static HEAD = "head";
+  static PATCH = "patch";
   path;
+  param;
   method;
   schema;
   name;
   use;
   handler;
-  constructor(e) {
-    this.path = e.path, this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
+  extensions = {};
+  constructor(e, t) {
+    this.path = t.path ?? t.param, this.method = e, this.schema = t.schema, this.use = t.use, this.handler = t.handler ?? ((s) => {
+      if (typeof s != "function")
+        throw new TypeError("This route was built with Method.create(...) but never finished with a terminal .handler(...) call before being used.");
+      return this.handler = s, this;
+    });
+  }
+  static create(e, t = {}) {
+    return new r(e, {
+      ...t,
+      handler: void 0
+    });
+  }
+  extend(e, t) {
+    return t && Object.assign(this.extensions, t), this;
   }
 };
 // packages/router/src/types/method.ts
-var h =  ((t) => (t.all = "all", t.get = "get", t.post = "post", t.put = "put", t.delete = "delete", t.options = "options", t.head = "head", t.patch = "patch", t))(h || {});
+var P =  ((o) => (o.all = "all", o.get = "get", o.post = "post", o.put = "put", o.delete = "delete", o.options = "options", o.head = "head", o.patch = "patch", o))(P || {});
 export {
-  d as Method,
-  h as MethodType,
-  n as Middleware,
-  s as Router
+  l as Method,
+  P as MethodType,
+  h as Middleware,
+  d as RouteMethodBuilder,
+  n as Router,
+  a as RouterBuilder,
+  R as getRouteExtensions,
+  i as setRouteExtensions
 };

package/dist/types/controllers/Method.d.ts

@@ -1,16 +1,75 @@
 import type { Runtime } from '@asterflow/adapter';
 import type { AnyAsterflow } from 'asterflow';
 import type { Responders } from '@asterflow/response';
-import type { MethodHandler, MethodKeys, MethodOptions } from '../types/method';
+import type { DefaultMethodProps, MethodBuilderOptions, MethodCallProps, MethodConstructorOptions, MethodHandler, MethodKeys, MethodProps } from '../types/method';
 import type { MiddlewareOutput } from '../types/mindleware';
 import type { AnySchema } from '../types/schema';
+import type { MergeProps } from '../types/utils';
 import type { Middleware } from './Middleware';
-export declare class Method<Responder extends Responders, const Path extends string = string, const Drive extends Runtime = Runtime, const Method extends MethodKeys = MethodKeys, const Schema extends AnySchema = AnySchema, const Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Instance extends AnyAsterflow = AnyAsterflow, const Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> {
-    path: Path;
-    method: Method;
-    schema?: Schema;
+/**
+ * `handler`'s field type: a concrete `MethodHandler<...>` once finished, or
+ * - while `Handler` is `undefined` (pending) - the terminal chain call
+ * itself, `<H extends MethodHandler<...>>(fn: H) => Method<..., H>`.
+ */
+export type MethodHandlerSlot<Props extends MethodProps> = Props['handler'] extends undefined ? <H extends MethodHandler<Props['path'], Props['drive'], Props['responder'], Props['schema'], Props['middlewares'], Props['context'], Props['instance'], Props['requestExt']>>(fn: H) => Method<MergeProps<Props, {
+    handler: H;
+}>> : Props['handler'];
+export declare class Method<const Props extends MethodProps = DefaultMethodProps> {
+    /** Convenience constants for `new Method(Method.POST, {...})` / `Method.create(Method.POST)` - a plain `'post'` string works just as well. */
+    static readonly ALL: 'all';
+    static readonly GET: 'get';
+    static readonly POST: 'post';
+    static readonly PUT: 'put';
+    static readonly DELETE: 'delete';
+    static readonly OPTIONS: 'options';
+    static readonly HEAD: 'head';
+    static readonly PATCH: 'patch';
+    path: Props['path'];
+    param?: Props['path'];
+    method: Props['methodKey'];
+    schema?: Props['schema'];
     name?: string;
-    use?: Middlewares;
-    handler: Handler;
-    constructor(options: MethodOptions<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler>);
+    use?: Props['middlewares'];
+    /**
+     * While pending (`Handler` is `undefined`), this field's runtime value is
+     * a self-replacing closure: calling it with the real handler assigns that
+     * function back onto `handler` and returns `this`. Lexically bound to
+     * `this`, so it still works detached from `route` (as `Asterflow`'s
+     * `runHandler` does). Throws if called with anything but a function.
+     */
+    handler: MethodHandlerSlot<Props>;
+    /** Plugin registrations from `extend` (e.g. multipart's `.multipart(schema)`), read back via `route.extensions.multipart`. */
+    readonly extensions: Record<string, unknown>;
+    constructor(method: Props['methodKey'], options: MethodConstructorOptions<Props>);
+    /**
+     * Defers `handler` to a terminal `.handler(fn)` call so plugins can chain
+     * `request` extensions first, e.g.
+     * `Method.create(Method.POST).multipart({...}).handler(...)`. Returns a
+     * real `Method`, not a separate class.
+     *
+     * `options` is optional - every one of its fields already is - so a route
+     * with nothing but a method and a deferred handler can skip it entirely:
+     * `Method.create(Method.GET).handler(...)`.
+     *
+     * Static, not folded into the constructor: a constructor shares one set
+     * of type-parameter defaults, and the default that infers an eager inline
+     * handler's parameters isn't the one that correctly types a pending
+     * route's `handler` field - verified empirically. Only a method can give
+     * each its own.
+     *
+     * Plugins add their own chain method via `declare module '@asterflow/router'
+     * { interface Method<...> { theirMethod(...): Method<...> } }` plus a real
+     * `Method.prototype.theirMethod = ...` implementation calling `extend`.
+     */
+    static create<Responder extends Responders, const Path extends string = string, const Drive extends Runtime = Runtime, const MethodKey extends MethodKeys = MethodKeys, const Schema extends AnySchema = AnySchema, const Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = []>(method: MethodKey, options?: MethodBuilderOptions<MethodCallProps<Responder, Path, Drive, MethodKey, Schema, Middlewares, MiddlewareOutput<Middlewares>, AnyAsterflow, {}, undefined>>): Method<MethodCallProps<Responder, Path, Drive, MethodKey, Schema, Middlewares, MiddlewareOutput<Middlewares>, AnyAsterflow, {}, undefined>>;
+    /**
+     * Primitive every plugin's chain method calls. `typeFragment` only drives
+     * inference of `E`, never read at runtime; `runtimeData` merges into
+     * `this.extensions`. Meaningful only pre-`.handler(fn)` - calling it after
+     * loses precise `Handler` typing (`any`) rather than fighting the bound.
+     */
+    extend<E extends Record<string, unknown>>(_typeFragment: E, runtimeData?: Record<string, unknown>): Method<MergeProps<Props, {
+        requestExt: Props['requestExt'] & E;
+        handler: Props['handler'] extends undefined ? undefined : any;
+    }>>;
 }

package/dist/types/controllers/Middleware.d.ts

@@ -1,13 +1,13 @@
 import type { Responders } from '@asterflow/response';
 import type { MiddlewareOptions } from '../types/mindleware';
 import type { AnySchema } from '../types/schema';
-export declare class Middleware<Responder extends Responders, Schema extends AnySchema, const Name extends string = string, const Parameters extends Record<string, unknown> = Record<string, unknown>> {
+export declare class Middleware<Responder extends Responders = Responders, Schema extends AnySchema = AnySchema, const Name extends string = string, const Parameters extends Record<string, unknown> = Record<string, unknown>> {
     readonly name: Name;
     readonly onRun: <RequestType extends import("@asterflow/adapter").Runtime>(args: {
         response: import("@asterflow/response").AsterResponse<Responder, import("@asterflow/response").BodyMap<Responder>, keyof Responder, import("@asterflow/response").BaseContext>;
         request: import("@asterflow/request").AsterRequest<RequestType, {}>;
-        schema: import("..").InferSchema<Schema>;
+        schema: import("@asterflow/router").InferSchema<Schema>;
         next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;
-    }) => MiddlewareOptions<Responder, Schema, Name, Parameters>;
+    }) => import("@asterflow/router").MiddlewareResult<Responder, Schema, Name, Parameters> | Promise<import("@asterflow/router").MiddlewareResult<Responder, Schema, Name, Parameters>>;
     constructor(options: MiddlewareOptions<Responder, Schema, Name, Parameters>);
 }

package/dist/types/controllers/Router.d.ts

@@ -1,20 +1,73 @@
 import type { Responders } from '@asterflow/response';
 import type { MethodKeys } from '../types/method';
 import type { MiddlewareOutput } from '../types/mindleware';
-import type { RouteHandler, RouterOptions } from '../types/router';
+import type { BuiltRouteHandler, DefaultRouterProps, DefaultRouteMethodBuilderProps, DefaultRouterBuilderProps, RouteBuilderHandler, RouteHandler, RouteMethodBuilderProps, RouterBuilderOptions, RouterBuilderProps, RouterCallProps, RouterOptions, RouterProps } from '../types/router';
 import type { AnySchema, SchemaDynamic } from '../types/schema';
+import type { MergeProps } from '../types/utils';
 import type { Middleware } from './Middleware';
-export declare class Router<Responder extends Responders, const Path extends string = string, const Schema extends SchemaDynamic<MethodKeys> = SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[] = [], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Routers extends {
-    [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-} = {
-    [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-}> {
+export declare class Router<const Props extends RouterProps = DefaultRouterProps> {
     name?: string;
-    path: Path;
-    schema?: Schema;
+    path: Props['path'];
+    param?: Props['path'];
+    schema?: Props['schema'];
     description?: string;
-    methods: Routers;
-    use?: Middlewares;
-    constructor(options: RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>);
-    static create<Responder extends Responders>(): <const Path extends string, const Schema extends SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], const Context extends MiddlewareOutput<Middlewares>, const Routers extends { [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>; }>(options: RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>) => Router<Responder, Path, Schema, Middlewares, Context, Routers>;
+    methods: Props['routers'];
+    use?: Props['middlewares'];
+    constructor(options: RouterOptions<Props>);
+    static create<Responder extends Responders>(): <const Path extends string, const Schema extends SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], const Context extends MiddlewareOutput<Middlewares>, const Routers extends { [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>; }>(options: RouterOptions<RouterCallProps<Responder, Path, Schema, Middlewares, Context, Routers>>) => Router<RouterCallProps<Responder, Path, Schema, Middlewares, Context, Routers>>;
+    /**
+     * Entry point for the extensible builder (`RouterBuilder`, which extends
+     * `Router` itself): each HTTP method is added via `.method(key, ...)`
+     * instead of one `methods: {...}` object, so plugins can chain in
+     * per-method `request` extensions, e.g.
+     * `Router.builder({ use: [authMiddleware] }).method('post', b => b.multipart({...}).handler(...))`.
+     * `options` is entirely optional (name/path/use/schema) - `Router.builder()`
+     * with no arguments at all is valid too. The result is already a real
+     * `Router` - no finalization call needed.
+     */
+    static builder<Responder extends Responders, const Path extends string = string, const Schema extends SchemaDynamic<MethodKeys> = SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[] = []>(options?: RouterBuilderOptions<RouterCallProps<Responder, Path, Schema, Middlewares, MiddlewareOutput<Middlewares>, {}>>): RouterBuilder<RouterCallProps<Responder, Path, Schema, Middlewares, MiddlewareOutput<Middlewares>, {}>>;
+}
+/**
+ * Scoped to a single HTTP method within a `RouterBuilder.method(key, ...)`
+ * call - plugins' chain methods work identically here as on `Method` (same
+ * `extend` primitive), but the accumulated `RequestExt` only ever
+ * affects *this* method's handler, not sibling methods on the same router.
+ */
+export declare class RouteMethodBuilder<const Props extends RouteMethodBuilderProps = DefaultRouteMethodBuilderProps> {
+    private readonly registrations;
+    extend<E extends Record<string, unknown>>(_typeFragment: E, runtimeData?: Record<string, unknown>): RouteMethodBuilder<MergeProps<Props, {
+        requestExt: Props['requestExt'] & E;
+    }>>;
+    handler<Handler extends RouteBuilderHandler<Props['path'], Props['responder'], Props['methodKey'], Props['schema'], Props['context'], Props['requestExt']>>(fn: Handler): BuiltRouteHandler<Handler>;
+}
+/**
+ * The extensible counterpart to `new Router({...})`. Each HTTP method is
+ * added via `.method(key, builder => builder.somePluginExtension({...}).handler(...))`,
+ * so different methods on the same router can have independently typed
+ * `request` extensions - e.g. `multipart` criteria declared for `post` only.
+ *
+ * Extends `Router` directly rather than staging into a separate object: each
+ * `.method(...)` call mutates `this.methods` in place and returns `this`, so
+ * the instance is a real, usable `Router` from the moment `Router.builder(...)`
+ * is called (`instanceof Router` holds immediately) - no finalization step.
+ * Same self-completing shape as `Method.create(...)`'s pending `handler`.
+ *
+ * Defined in this same file (not a separate one) because it extends `Router`
+ * at class-definition time - splitting the two across mutually-importing
+ * modules creates a circular value import, which throws
+ * "Cannot access 'Router' before initialization" depending on load order.
+ */
+export declare class RouterBuilder<const Props extends RouterBuilderProps = DefaultRouterBuilderProps> extends Router<Props> {
+    private readonly perMethodRegistrations;
+    constructor(options?: RouterBuilderOptions<Props>);
+    method<MethodKey extends MethodKeys, Handler>(key: MethodKey, build: (builder: RouteMethodBuilder<{
+        responder: Props['responder'];
+        path: Props['path'];
+        methodKey: MethodKey;
+        schema: Props['schema'];
+        context: Props['context'];
+        requestExt: {};
+    }>) => BuiltRouteHandler<Handler>): RouterBuilder<MergeProps<Props, {
+        routers: Props['routers'] & Record<MethodKey, Handler>;
+    }>>;
 }

package/dist/types/controllers/extensionRegistry.d.ts

@@ -0,0 +1,10 @@
+/** Called by `RouterBuilder.method(...)` each time a method registers plugin data. */
+export declare function setRouteExtensions(route: object, extensions: Record<string, unknown>): void;
+/**
+ * Reads back whatever a plugin stashed for this router, e.g.
+ * `getRouteExtensions(router)?.post?.multipart`. Returns `undefined` for
+ * routers built without `RouterBuilder` (`new Router({...})`) or that never
+ * called any extension method. `Method` routes never go through here - see
+ * `Method#extensions` instead.
+ */
+export declare function getRouteExtensions(route: object): Record<string, unknown> | undefined;

package/dist/types/index.d.ts

@@ -1,7 +1,9 @@
 export * from './controllers/Router';
 export * from './controllers/Middleware';
 export * from './controllers/Method';
+export * from './controllers/extensionRegistry';
 export * from './types/router';
 export * from './types/schema';
 export * from './types/method';
 export * from './types/mindleware';
+export * from './types/utils';

package/dist/types/types/method.d.ts

@@ -2,10 +2,12 @@ import type { Runtime } from '@asterflow/adapter';
 import type { AnyAsterflow } from 'asterflow';
 import type { AsterRequest } from '@asterflow/request';
 import type { Responders, AsterResponse } from '@asterflow/response';
-import type { Analyze, ParsePath } from '@asterflow/url-parser';
+import type { Analyze } from '@asterflow/url-parser';
+import type { Method } from '../controllers/Method';
 import type { Middleware } from '../controllers/Middleware';
 import type { AnyMiddleware, MiddlewareOutput } from './mindleware';
 import type { AnySchema, InferSchema } from './schema';
+import type { Prettify } from './utils';
 export declare enum MethodType {
     all = "all",
     get = "get",
@@ -16,22 +18,92 @@ export declare enum MethodType {
     head = "head",
     patch = "patch"
 }
-export type AnyMethodHandler = MethodHandler<string, Runtime, Responders, AnySchema, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>, AnyAsterflow>;
 export type MethodKeys = keyof typeof MethodType;
-export type MethodHandler<Path extends string, Drive extends Runtime, Responder extends Responders, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Instance extends AnyAsterflow> = (args: {
+/** `Method`'s single generic parameter - the fields it needs to type a single route. */
+export interface MethodProps {
+    responder: Responders;
+    path: string;
+    drive: Runtime;
+    methodKey: MethodKeys;
+    schema: AnySchema;
+    middlewares: readonly AnyMiddleware[];
+    context: unknown;
+    instance: AnyAsterflow;
+    requestExt: Record<string, unknown>;
+    handler: ((args: any) => any) | undefined;
+}
+export type AnyMethod = Method<any>;
+/**
+ * Assembles `MethodProps`'s fields from independently-inferred generics into
+ * one named object type - same rationale as `RouterCallProps` in
+ * `types/router.ts`: `Method.create()`/`AsterFlow.method()` keep their own
+ * independent generics (needed for contextual typing of the handler
+ * callback), this alias just replaces the repeated object-literal with a name.
+ *
+ * Wrapped in `Prettify` so a resolved `Method<MethodCallProps<...>>` shows as
+ * a labeled `{ responder: ..., path: "...", ... }` object on hover instead of
+ * `MethodCallProps<Responders, "...", Runtime.Node, "post", ...>` - a
+ * positional arg list you'd otherwise have to cross-reference against this
+ * declaration to read.
+ */
+export type MethodCallProps<Responder extends Responders, Path extends string, Drive extends Runtime, MethodKey extends MethodKeys, Schema extends AnySchema, Middlewares extends readonly AnyMiddleware[], Context, Instance extends AnyAsterflow, RequestExt extends Record<string, unknown>, Handler> = Prettify<{
+    responder: Responder;
+    path: Path;
+    drive: Drive;
+    methodKey: MethodKey;
+    schema: Schema;
+    middlewares: Middlewares;
+    context: Context;
     instance: Instance;
-    request: AsterRequest<Drive>;
+    requestExt: RequestExt;
+    handler: Handler;
+}>;
+export type DefaultMethodProps = {
+    responder: Responders;
+    path: string;
+    drive: Runtime;
+    methodKey: MethodKeys;
+    schema: AnySchema;
+    middlewares: [];
+    context: MiddlewareOutput<[]>;
+    instance: AnyAsterflow;
+    requestExt: {};
+    handler: MethodHandler<string, Runtime, Responders, AnySchema, [], MiddlewareOutput<[]>, AnyAsterflow, {}>;
+};
+export type MethodHandler<Path extends string, Drive extends Runtime, Responder extends Responders, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context, Instance extends AnyAsterflow, RequestExt extends Record<string, unknown> = {}> = (args: {
+    instance: Instance;
+    request: ExtendedRequest<Drive, RequestExt>;
     response: AsterResponse<Responder>;
-    url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
+    url: Analyze<string, Analyze<Path>>;
     schema: InferSchema<Schema>;
     middleware: Context;
 }) => Promise<AsterResponse<Responder>> | AsterResponse<Responder>;
-export type MethodOptions<Responder extends Responders, Path extends string, Drive extends Runtime, Method extends MethodKeys, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Instance extends AnyAsterflow, Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> = {
-    path: Path;
+export type MethodOptions<Props extends MethodProps> = {
+    path?: Props['path'];
+    param?: Props['path'];
     name?: string;
     description?: string;
-    use?: Middlewares;
-    method: Method;
-    schema?: Schema;
-    handler: Handler;
+    use?: Props['middlewares'];
+    method: Props['methodKey'];
+    schema?: Props['schema'];
+    handler: MethodHandler<Props['path'], Props['drive'], Props['responder'], Props['schema'], Props['middlewares'], Props['context'], Props['instance']>;
 };
+/**
+ * `new Method(method, options)`'s second argument - everything
+ * `MethodOptions` has except `method` itself, which is passed positionally
+ * instead of repeated inside the options object.
+ */
+export type MethodConstructorOptions<Props extends MethodProps> = Omit<MethodOptions<Props>, 'method'>;
+/**
+ * `Method.create(method, options?)`'s second argument: everything
+ * `MethodConstructorOptions` has except `handler`, supplied later via the
+ * terminal `.handler()` call instead. Every remaining field is optional, so
+ * this argument can be omitted entirely, e.g. `Method.create(Method.POST)`.
+ */
+export type MethodBuilderOptions<Props extends MethodProps> = Omit<MethodConstructorOptions<Props>, 'handler'>;
+/**
+ * `RequestExt`'s keys replace (not merely add to) the base request's -
+ * `Omit` then intersect, so a plugin's narrowed method (e.g. multipart's
+ * `getFile`) is the only signature available, not an extra overload.
+ */
+export type ExtendedRequest<Drive extends Runtime, RequestExt extends Record<string, unknown>> = Omit<AsterRequest<Drive>, keyof RequestExt> & RequestExt;

package/dist/types/types/mindleware.d.ts

@@ -9,6 +9,14 @@ export type AnyMiddlewares = readonly AnyMiddleware[];
  * Accumulate the output types (`P`) from an array of middlewares into a single object
  */
 export type MiddlewareOutput<Ms extends readonly AnyMiddleware[]> = Ms extends readonly [infer First, ...infer Rest] ? First extends Middleware<any, any, any, infer P> ? Rest extends readonly AnyMiddleware[] ? P & MiddlewareOutput<Rest> : P : unknown : unknown;
+/**
+ * What a middleware's `onRun` may return: either `next(params)`'s result -
+ * continue the chain, merging `params` into the accumulated `middleware`
+ * context - or an `AsterResponse` (e.g. `response.unauthorized({...})`) to
+ * short-circuit the chain and send that response immediately, without
+ * running the remaining middlewares or the route handler.
+ */
+export type MiddlewareResult<Responder extends Responders = Responders, Schema extends AnySchema = AnySchema, Name extends string = string, Parameters extends Record<string, unknown> = Record<string, unknown>> = MiddlewareOptions<Responder, Schema, Name, Parameters> | AsterResponse<Responder>;
 export type MiddlewareOptions<Responder extends Responders = Responders, Schema extends AnySchema = AnySchema, Name extends string = string, Parameters extends Record<string, unknown> = Record<string, unknown>> = {
     name: Name;
     onRun<RequestType extends Runtime>(args: {
@@ -16,5 +24,5 @@ export type MiddlewareOptions<Responder extends Responders = Responders, Schema
         request: Request<RequestType>;
         schema: InferSchema<Schema>;
         next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;
-    }): MiddlewareOptions<Responder, Schema, Name, Parameters>;
+    }): MiddlewareResult<Responder, Schema, Name, Parameters> | Promise<MiddlewareResult<Responder, Schema, Name, Parameters>>;
 };

package/dist/types/types/router.d.ts

@@ -1,31 +1,126 @@
 import type { Runtime } from '@asterflow/adapter';
 import type { Request } from '@asterflow/request';
 import type { AsterResponse, Responders } from '@asterflow/response';
-import type { Analyze, ParsePath } from '@asterflow/url-parser';
+import type { Analyze } from '@asterflow/url-parser';
 import type { Method } from '../controllers/Method';
 import type { Middleware } from '../controllers/Middleware';
-import type { Router } from '../controllers/Router';
+import type { Router, RouteMethodBuilder } from '../controllers/Router';
 import type { MethodKeys } from './method';
-import type { AnyMiddleware, MiddlewareOutput } from './mindleware';
+import type { AnyMiddleware } from './mindleware';
 import type { AnySchema, InferredData, SchemaDynamic } from './schema';
-export type AnyRouteHandler = {
-    [Method in MethodKeys]?: RouteHandler<string, Responders, Method, SchemaDynamic<Method>, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>>;
+import type { Prettify } from './utils';
+export type AnyRouter = Router<any> | Method<any>;
+/** `Router`'s single generic parameter - the fields it needs to type a finished router. */
+export interface RouterProps {
+    responder: Responders;
+    path: string;
+    schema: SchemaDynamic<MethodKeys>;
+    middlewares: readonly AnyMiddleware[];
+    context: unknown;
+    routers: Partial<Record<MethodKeys, unknown>>;
+}
+export type DefaultRouterProps = {
+    responder: Responders;
+    path: string;
+    schema: SchemaDynamic<MethodKeys>;
+    middlewares: [];
+    context: unknown;
+    routers: {};
 };
-export type AnyRouter = Router<any, any, any, any, any, any> | Method<any, any, any, any, any, any, any, any, any>;
-export type RouteHandler<Path extends string, Responder extends Responders, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>> = <RequestType extends Runtime>(args: {
+/**
+ * Assembles `RouterProps`'s fields from independently-inferred generics into
+ * one named object type. Entry points (`Router.create()`, `.builder()`,
+ * `AsterFlow.router()`) can't infer a single `Props` object directly from
+ * their call site - each field is inferred from a different part of
+ * `options`, and contextual typing of the `methods` handlers depends on
+ * `Path`/`Responder`/`Schema`/`Middlewares`/`Context` existing as separate
+ * type-vars at that point - so they keep independent generics. This alias
+ * just replaces the "respell the object literal 2-3x per signature" pattern
+ * with one name.
+ *
+ * Wrapped in `Prettify` so a resolved `Router<RouterCallProps<...>>` shows as
+ * a labeled `{ responder: ..., path: "...", ... }` object on hover instead of
+ * `RouterCallProps<Responders, "...", ...>` - a positional arg list you'd
+ * otherwise have to cross-reference against this declaration to read.
+ */
+export type RouterCallProps<Responder extends Responders, Path extends string, Schema extends SchemaDynamic<MethodKeys>, Middlewares extends readonly AnyMiddleware[], Context, Routers extends Partial<Record<MethodKeys, unknown>>> = Prettify<{
+    responder: Responder;
+    path: Path;
+    schema: Schema;
+    middlewares: Middlewares;
+    context: Context;
+    routers: Routers;
+}>;
+/** `RouterBuilder`'s single generic parameter - same fields as `RouterProps`, but `routers` accumulates as `.method(...)` is chained. */
+export interface RouterBuilderProps {
+    responder: Responders;
+    path: string;
+    schema: SchemaDynamic<MethodKeys>;
+    middlewares: readonly AnyMiddleware[];
+    context: unknown;
+    routers: Partial<Record<MethodKeys, unknown>>;
+}
+export type DefaultRouterBuilderProps = {
+    responder: Responders;
+    path: string;
+    schema: SchemaDynamic<MethodKeys>;
+    middlewares: [];
+    context: unknown;
+    routers: {};
+};
+/** `RouteMethodBuilder`'s single generic parameter - the fields it needs to type a scoped-to-one-HTTP-method builder. */
+export interface RouteMethodBuilderProps {
+    responder: Responders;
+    path: string;
+    methodKey: MethodKeys;
+    schema: SchemaDynamic<MethodKeys>;
+    context: unknown;
+    requestExt: Record<string, unknown>;
+}
+export type DefaultRouteMethodBuilderProps = {
+    responder: Responders;
+    path: string;
+    methodKey: MethodKeys;
+    schema: SchemaDynamic<MethodKeys>;
+    context: unknown;
+    requestExt: {};
+};
+export type AnyRouteMethodBuilder = RouteMethodBuilder<any>;
+export type RouteHandler<Path extends string, Responder extends Responders, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context> = <RequestType extends Runtime>(args: {
     request: Request<RequestType>;
     response: AsterResponse<Responder>;
-    url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
+    url: Analyze<string, Analyze<Path>>;
     schema: InferredData<Method, Schema>;
     middleware: Context;
 }) => Promise<AsterResponse> | AsterResponse;
-export type RouterOptions<Path extends string, Schema extends SchemaDynamic<MethodKeys>, Responder extends Responders, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Routers extends {
-    [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-}> = {
+export type RouterOptions<Props extends RouterProps> = {
     name?: string;
     description?: string;
-    path: Path;
-    use?: Middlewares;
-    schema?: Schema;
-    methods: Routers;
+    path?: Props['path'];
+    param?: Props['path'];
+    use?: Props['middlewares'];
+    schema?: Props['schema'];
+    methods: Props['routers'];
+};
+/** `RouterBuilder`'s constructor options: `RouterOptions` minus `methods` - each method is added via `.method(key, ...)` instead. */
+export type RouterBuilderOptions<Props extends RouterBuilderProps> = {
+    name?: string;
+    description?: string;
+    path?: Props['path'];
+    param?: Props['path'];
+    use?: Props['middlewares'];
+    schema?: Props['schema'];
+};
+/** A single HTTP method's handler on a `RouterBuilder`, with `RequestExt` replacing (not merely adding to) the base request's matching keys - same `Omit`-then-intersect as `ExtendedRequest`. */
+export type RouteBuilderHandler<Path extends string, Responder extends Responders, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Context, RequestExt extends Record<string, unknown>> = <RequestType extends Runtime>(args: {
+    request: Omit<Request<RequestType>, keyof RequestExt> & RequestExt;
+    response: AsterResponse<Responder>;
+    url: Analyze<string, Analyze<Path>>;
+    schema: InferredData<Method, Schema>;
+    middleware: Context;
+}) => Promise<AsterResponse> | AsterResponse;
+/** What a `RouterBuilder.method(key, build)` callback must return - built via `RouteMethodBuilder`. */
+export type BuiltRouteHandler<Handler> = {
+    handler: Handler;
+    registrations: Record<string, unknown>;
 };

package/dist/types/types/utils.d.ts

@@ -0,0 +1,9 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Produces a new `Props` object type equal to `Props` with `Patch`'s keys
+ * overridden. Lets a fluent builder method name only the field(s) actually
+ * changing instead of respelling every unchanged generic slot.
+ */
+export type MergeProps<Props, Patch> = Prettify<Omit<Props, keyof Patch> & Patch>;

package/package.json

@@ -1,12 +1,30 @@
 {
   "name": "@asterflow/router",
-  "version": "1.0.13",
+  "version": "2.0.0",
+  "description": "Typed route and middleware definitions (Method, Router, Middleware) for AsterFlow applications.",
+  "keywords": [
+    "asterflow",
+    "router",
+    "routing",
+    "middleware",
+    "http",
+    "typescript"
+  ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
   "typings": "dist/types/index.d.ts",
   "type": "module",
   "license": "MIT",
+  "author": "Ashu11-A",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AsterFlow/AsterFlow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AsterFlow/AsterFlow/issues"
+  },
+  "homepage": "https://github.com/AsterFlow/AsterFlow",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -18,14 +36,14 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@asterflow/request": "1.0.13",
-    "@asterflow/response": "1.0.10",
-    "@asterflow/url-parser": "^2.0.3",
-    "asterflow": "0.0.5"
+    "@asterflow/request": "^1.0.13",
+    "@asterflow/response": "^1.0.10",
+    "@asterflow/url-parser": "^4.1.1",
+    "asterflow": "^1.0.0"
   },
   "peerDependencies": {
     "@caeljs/tsh": "^1.1.3",
-    "zod": "^3.25.63",
+    "zod": "^3.25.67",
     "typescript": "^5.8.3"
   }
 }