@kevisual/router 0.0.53 → 0.0.55

package/dist/router-browser.d.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import * as node_querystring from 'node:querystring';
-import { IncomingMessage } from 'node:http';
 import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
 import { Query, DataOpts, Result } from '@kevisual/query/query';
 
@@ -109,6 +107,16 @@ type RouteOpts<U = {}, T = SimpleObject$1> = {
 };
 type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'nextRoute'>;
 declare const pickValue: readonly ["path", "key", "id", "description", "type", "middleware", "metadata"];
+type Skill<T = SimpleObject$1> = {
+    skill: string;
+    title: string;
+    summary?: string;
+    args?: {
+        [key: string]: any;
+    };
+} & T;
+/** */
+declare const createSkill: <T = SimpleObject$1>(skill: Skill<T>) => Skill<T>;
 type RouteInfo = Pick<Route, (typeof pickValue)[number]>;
 declare class Route<U = {
     [key: string]: any;
@@ -432,16 +440,6 @@ declare class CustomError extends Error {
     };
 }
 
-declare const parseBody: <T = Record<string, any>>(req: IncomingMessage) => Promise<T>;
-declare const parseSearch: (req: IncomingMessage) => node_querystring.ParsedUrlQuery;
-/**
- * 把url当个key 的 value 的字符串转成json
- * @param value
- */
-declare const parseSearchValue: (value?: string, opts?: {
-    decode?: boolean;
-}) => any;
-
 type RouteObject = {
     [key: string]: RouteOpts$1;
 };
@@ -512,5 +510,5 @@ declare class QueryUtil<T extends RouteObject = RouteObject> {
 
 declare const App: typeof QueryRouterServer;
 
-export { App, CustomError, Mini, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, define, parseBody, parseSearch, parseSearchValue, util };
-export type { RouteArray, RouteContext, RouteObject, RouteOpts, Rule, Run, Schema };
+export { App, CustomError, Mini, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, createSkill, define, util };
+export type { RouteArray, RouteContext, RouteObject, RouteOpts, Rule, Run, Schema, Skill };

package/dist/router-browser.js

@@ -1,5 +1,3 @@
-import url from 'node:url';
-
 const urlAlphabet =
   'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
 
@@ -147,6 +145,13 @@ const listenProcess = async ({ app, emitter, params, timeout = 10 * 60 * 60 * 10
 };
 
 const pickValue = ['path', 'key', 'id', 'description', 'type', 'middleware', 'metadata'];
+/** */
+const createSkill = (skill) => {
+    return {
+        args: {},
+        ...skill
+    };
+};
 class Route {
     /**
      * 一级路径
@@ -3770,7 +3775,7 @@ function initializeContext(params) {
         external: params?.external ?? undefined,
     };
 }
-function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     var _a;
     const def = schema._zod.def;
     // check for schema in seens
@@ -3814,7 +3819,7 @@ function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
             // Also set ref if processor didn't (for inheritance)
             if (!result.ref)
                 result.ref = parent;
-            process$1(parent, ctx, params);
+            process(parent, ctx, params);
             ctx.seen.get(parent).isParent = true;
         }
     }
@@ -4161,14 +4166,14 @@ function isTransforming(_schema, _ctx) {
  */
 const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
     const ctx = initializeContext({ ...params, processors });
-    process$1(schema, ctx);
+    process(schema, ctx);
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
 };
 const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
     const { libraryOptions, target } = params ?? {};
     const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
-    process$1(schema, ctx);
+    process(schema, ctx);
     extractDefs(ctx, schema);
     return finalize(ctx, schema);
 };
@@ -4307,7 +4312,7 @@ const arrayProcessor = (schema, ctx, _json, params) => {
     if (typeof maximum === "number")
         json.maxItems = maximum;
     json.type = "array";
-    json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
+    json.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 const objectProcessor = (schema, ctx, _json, params) => {
     const json = _json;
@@ -4316,7 +4321,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
     json.properties = {};
     const shape = def.shape;
     for (const key in shape) {
-        json.properties[key] = process$1(shape[key], ctx, {
+        json.properties[key] = process(shape[key], ctx, {
             ...params,
             path: [...params.path, "properties", key],
         });
@@ -4346,7 +4351,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
             json.additionalProperties = false;
     }
     else if (def.catchall) {
-        json.additionalProperties = process$1(def.catchall, ctx, {
+        json.additionalProperties = process(def.catchall, ctx, {
             ...params,
             path: [...params.path, "additionalProperties"],
         });
@@ -4357,7 +4362,7 @@ const unionProcessor = (schema, ctx, json, params) => {
     // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches)
     // This includes both z.xor() and discriminated unions
     const isExclusive = def.inclusive === false;
-    const options = def.options.map((x, i) => process$1(x, ctx, {
+    const options = def.options.map((x, i) => process(x, ctx, {
         ...params,
         path: [...params.path, isExclusive ? "oneOf" : "anyOf", i],
     }));
@@ -4370,11 +4375,11 @@ const unionProcessor = (schema, ctx, json, params) => {
 };
 const intersectionProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    const a = process$1(def.left, ctx, {
+    const a = process(def.left, ctx, {
         ...params,
         path: [...params.path, "allOf", 0],
     });
-    const b = process$1(def.right, ctx, {
+    const b = process(def.right, ctx, {
         ...params,
         path: [...params.path, "allOf", 1],
     });
@@ -4387,7 +4392,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 };
 const nullableProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    const inner = process$1(def.innerType, ctx, params);
+    const inner = process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     if (ctx.target === "openapi-3.0") {
         seen.ref = def.innerType;
@@ -4399,20 +4404,20 @@ const nullableProcessor = (schema, ctx, json, params) => {
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
 const defaultProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const prefaultProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     if (ctx.io === "input")
@@ -4420,7 +4425,7 @@ const prefaultProcessor = (schema, ctx, json, params) => {
 };
 const catchProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     let catchValue;
@@ -4435,20 +4440,20 @@ const catchProcessor = (schema, ctx, json, params) => {
 const pipeProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
     const innerType = ctx.io === "input" ? (def.in._zod.def.type === "transform" ? def.out : def.in) : def.out;
-    process$1(innerType, ctx, params);
+    process(innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = innerType;
 };
 const readonlyProcessor = (schema, ctx, json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
     json.readOnly = true;
 };
 const optionalProcessor = (schema, ctx, _json, params) => {
     const def = schema._zod.def;
-    process$1(def.innerType, ctx, params);
+    process(def.innerType, ctx, params);
     const seen = ctx.seen.get(schema);
     seen.ref = def.innerType;
 };
@@ -5207,93 +5212,6 @@ const createSchema = (rule) => {
     }
 };
 
-typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
-// @ts-ignore
-typeof Deno !== 'undefined' && typeof Deno.version === 'object' && typeof Deno.version.deno === 'string';
-// @ts-ignore
-const isBun = typeof Bun !== 'undefined' && typeof Bun.version === 'string';
-
-const parseBody = async (req) => {
-    const resolveBody = (body) => {
-        // 获取 Content-Type 头信息
-        const contentType = req.headers['content-type'] || '';
-        const resolve = (data) => {
-            return data;
-        };
-        // 处理 application/json
-        if (contentType.includes('application/json')) {
-            return resolve(JSON.parse(body));
-        }
-        // 处理 application/x-www-form-urlencoded
-        if (contentType.includes('application/x-www-form-urlencoded')) {
-            const formData = new URLSearchParams(body);
-            const result = {};
-            formData.forEach((value, key) => {
-                // 尝试将值解析为 JSON，如果失败则保留原始字符串
-                try {
-                    result[key] = JSON.parse(value);
-                }
-                catch {
-                    result[key] = value;
-                }
-            });
-            return resolve(result);
-        }
-        // 默认尝试 JSON 解析
-        try {
-            return resolve(JSON.parse(body));
-        }
-        catch {
-            return resolve({});
-        }
-    };
-    if (isBun) {
-        // @ts-ignore
-        const body = req.body;
-        if (body) {
-            return resolveBody(body);
-        }
-        return {};
-    }
-    return new Promise((resolve, reject) => {
-        const arr = [];
-        req.on('data', (chunk) => {
-            arr.push(chunk);
-        });
-        req.on('end', () => {
-            try {
-                const body = Buffer.concat(arr).toString();
-                resolve(resolveBody(body));
-            }
-            catch (e) {
-                resolve({});
-            }
-        });
-    });
-};
-const parseSearch = (req) => {
-    const parsedUrl = url.parse(req.url, true);
-    return parsedUrl.query;
-};
-/**
- * 把url当个key 的 value 的字符串转成json
- * @param value
- */
-const parseSearchValue = (value, opts) => {
-    if (!value)
-        return {};
-    const decode = opts?.decode ?? false;
-    if (decode) {
-        value = decodeURIComponent(value);
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch (e) {
-        return {};
-    }
-};
-
 function define(value) {
     return value;
 }
@@ -5428,4 +5346,4 @@ class QueryUtil {
 
 const App = QueryRouterServer;
 
-export { App, CustomError, Mini, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, define, parseBody, parseSearch, parseSearchValue, util };
+export { App, CustomError, Mini, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, createSkill, define, util };

package/dist/router.d.ts

@@ -1,13 +1,13 @@
+import { z } from 'zod';
+import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
+import { Query, DataOpts, Result } from '@kevisual/query/query';
 import * as http from 'node:http';
 import http__default, { IncomingMessage, ServerResponse } from 'node:http';
 import https from 'node:https';
 import http2 from 'node:http2';
 import { EventEmitter } from 'eventemitter3';
 import { WebSocketServer } from 'ws';
-import { z } from 'zod';
 import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'http';
-import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
-import { Query, DataOpts, Result } from '@kevisual/query/query';
 
 type RouterContextT = {
     code?: number;
@@ -114,6 +114,16 @@ type RouteOpts<U = {}, T = SimpleObject$1> = {
 };
 type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'nextRoute'>;
 declare const pickValue: readonly ["path", "key", "id", "description", "type", "middleware", "metadata"];
+type Skill<T = SimpleObject$1> = {
+    skill: string;
+    title: string;
+    summary?: string;
+    args?: {
+        [key: string]: any;
+    };
+} & T;
+/** */
+declare const createSkill: <T = SimpleObject$1>(skill: Skill<T>) => Skill<T>;
 type RouteInfo = Pick<Route, (typeof pickValue)[number]>;
 declare class Route<U = {
     [key: string]: any;
@@ -371,34 +381,138 @@ declare class QueryRouterServer extends QueryRouter {
 declare class Mini extends QueryRouterServer {
 }
 
-declare class Connect {
-    path: string;
-    key?: string;
-    _fn?: (ctx?: RouteContext) => Promise<RouteContext>;
-    description?: string;
-    connects: {
-        path: string;
-        key?: string;
-    }[];
-    share: boolean;
-    constructor(path: string);
-    use(path: string): void;
-    useList(paths: string[]): void;
-    useConnect(connect: Connect): void;
-    useConnectList(connects: Connect[]): void;
-    getPathList(): string[];
-    set fn(fn: (ctx?: RouteContext) => Promise<RouteContext>);
-    get fn(): (ctx?: RouteContext) => Promise<RouteContext>;
+type BaseRule = {
+    value?: any;
+    required?: boolean;
+    message?: string;
+};
+type RuleString = {
+    type: 'string';
+    min?: number;
+    max?: number;
+    regex?: string;
+} & BaseRule;
+type RuleNumber = {
+    type: 'number';
+    min?: number;
+    max?: number;
+} & BaseRule;
+type RuleBoolean = {
+    type: 'boolean';
+} & BaseRule;
+type RuleArray = {
+    type: 'array';
+    items: Rule;
+} & BaseRule;
+type RuleObject = {
+    type: 'object';
+    properties: {
+        [key: string]: Rule;
+    };
+} & BaseRule;
+type RuleAny = {
+    type: 'any';
+} & BaseRule;
+type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
+declare const createSchema: (rule: Rule) => z.ZodType<any, any, any>;
+
+type Schema = z.ZodType<any, any, any>;
+
+/** 自定义错误 */
+declare class CustomError extends Error {
+    code?: number;
+    data?: any;
+    message: string;
+    tips?: string;
+    constructor(code?: number | string, message?: string, tips?: string);
+    static fromCode(code?: number): CustomError;
+    static fromErrorData(code?: number, data?: any): CustomError;
+    static parseError(e: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
+    /**
+     * 判断 throw 的错误是否不是当前这个错误
+     * @param err
+     * @returns
+     */
+    static isError(error: unknown): error is CustomError;
+    parse(e?: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
 }
-declare class QueryConnect {
-    connects: Connect[];
-    constructor();
-    add(connect: Connect): void;
-    remove(connect: Connect): void;
-    getList(): {
-        path: string;
-        key: string;
-    }[];
+
+type RouteObject = {
+    [key: string]: RouteOpts$1;
+};
+type SimpleObject = Record<string, any>;
+declare function define<T extends Record<string, RouteOpts$1>>(value: T): {
+    [K in keyof T]: T[K] & RouteOpts$1;
+};
+type RouteArray = RouteOpts$1[];
+type ChainOptions = {
+    app: QueryRouterServer$1;
+};
+declare class Chain {
+    object: RouteOpts$1;
+    app?: QueryRouterServer$1;
+    constructor(object: RouteOpts$1, opts?: ChainOptions);
+    get key(): string;
+    get path(): string;
+    setDescription(desc: string): this;
+    setMeta(metadata: {
+        [key: string]: any;
+    }): this;
+    setPath(path: string): this;
+    setMiddleware(middleware: RouteMiddleware$1[]): this;
+    setKey(key: string): this;
+    setId(key: string): this;
+    setRun<U extends SimpleObject = {}>(run: Run$1<U>): this;
+    define<U extends SimpleObject = {}>(run: Run$1<U>): this;
+    createRoute(): this;
+}
+type QueryChainOptions = {
+    query?: Query;
+    omitKeys?: string[];
+};
+declare class QueryChain {
+    obj: SimpleObject;
+    query: Query;
+    omitKeys: string[];
+    constructor(value?: SimpleObject, opts?: QueryChainOptions);
+    omit(obj: SimpleObject, key?: string[]): {
+        [x: string]: any;
+    };
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData?: SimpleObject): Pick<RouteOpts$1, 'path' | 'key' | 'metadata' | 'description'>;
+    post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+    get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+}
+declare const util: {
+    getChain: (obj: RouteOpts$1, opts?: ChainOptions) => Chain;
+};
+declare class QueryUtil<T extends RouteObject = RouteObject> {
+    obj: T;
+    app: QueryRouterServer$1;
+    query: Query;
+    constructor(object: T, opts?: ChainOptions & QueryChainOptions);
+    static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions): QueryUtil<U>;
+    static create<U extends Record<string, RouteOpts$1>>(value: U, opts?: ChainOptions): QueryUtil<U>;
+    get<K extends keyof T>(key: K): RouteOpts$1;
+    chain<K extends keyof T>(key: K, opts?: ChainOptions): Chain;
+    queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions): QueryChain;
+    static Chain: typeof Chain;
+    static QueryChain: typeof QueryChain;
+    get routeObject(): T;
 }
 
 type Cors$2 = {
@@ -731,140 +845,6 @@ declare const handleServer: (req: IncomingMessage, res: ServerResponse) => Promi
     token: string;
 }>;
 
-/** 自定义错误 */
-declare class CustomError extends Error {
-    code?: number;
-    data?: any;
-    message: string;
-    tips?: string;
-    constructor(code?: number | string, message?: string, tips?: string);
-    static fromCode(code?: number): CustomError;
-    static fromErrorData(code?: number, data?: any): CustomError;
-    static parseError(e: CustomError): {
-        code: number;
-        data: any;
-        message: string;
-        tips: string;
-    };
-    /**
-     * 判断 throw 的错误是否不是当前这个错误
-     * @param err
-     * @returns
-     */
-    static isError(error: unknown): error is CustomError;
-    parse(e?: CustomError): {
-        code: number;
-        data: any;
-        message: string;
-        tips: string;
-    };
-}
-
-type BaseRule = {
-    value?: any;
-    required?: boolean;
-    message?: string;
-};
-type RuleString = {
-    type: 'string';
-    min?: number;
-    max?: number;
-    regex?: string;
-} & BaseRule;
-type RuleNumber = {
-    type: 'number';
-    min?: number;
-    max?: number;
-} & BaseRule;
-type RuleBoolean = {
-    type: 'boolean';
-} & BaseRule;
-type RuleArray = {
-    type: 'array';
-    items: Rule;
-} & BaseRule;
-type RuleObject = {
-    type: 'object';
-    properties: {
-        [key: string]: Rule;
-    };
-} & BaseRule;
-type RuleAny = {
-    type: 'any';
-} & BaseRule;
-type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
-declare const createSchema: (rule: Rule) => z.ZodType<any, any, any>;
-
-type Schema = z.ZodType<any, any, any>;
-
-type RouteObject = {
-    [key: string]: RouteOpts$1;
-};
-type SimpleObject = Record<string, any>;
-declare function define<T extends Record<string, RouteOpts$1>>(value: T): {
-    [K in keyof T]: T[K] & RouteOpts$1;
-};
-type RouteArray = RouteOpts$1[];
-type ChainOptions = {
-    app: QueryRouterServer$1;
-};
-declare class Chain {
-    object: RouteOpts$1;
-    app?: QueryRouterServer$1;
-    constructor(object: RouteOpts$1, opts?: ChainOptions);
-    get key(): string;
-    get path(): string;
-    setDescription(desc: string): this;
-    setMeta(metadata: {
-        [key: string]: any;
-    }): this;
-    setPath(path: string): this;
-    setMiddleware(middleware: RouteMiddleware$1[]): this;
-    setKey(key: string): this;
-    setId(key: string): this;
-    setRun<U extends SimpleObject = {}>(run: Run$1<U>): this;
-    define<U extends SimpleObject = {}>(run: Run$1<U>): this;
-    createRoute(): this;
-}
-type QueryChainOptions = {
-    query?: Query;
-    omitKeys?: string[];
-};
-declare class QueryChain {
-    obj: SimpleObject;
-    query: Query;
-    omitKeys: string[];
-    constructor(value?: SimpleObject, opts?: QueryChainOptions);
-    omit(obj: SimpleObject, key?: string[]): {
-        [x: string]: any;
-    };
-    /**
-     * 生成
-     * @param queryData
-     * @returns
-     */
-    getKey(queryData?: SimpleObject): Pick<RouteOpts$1, 'path' | 'key' | 'metadata' | 'description'>;
-    post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
-    get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
-}
-declare const util: {
-    getChain: (obj: RouteOpts$1, opts?: ChainOptions) => Chain;
-};
-declare class QueryUtil<T extends RouteObject = RouteObject> {
-    obj: T;
-    app: QueryRouterServer$1;
-    query: Query;
-    constructor(object: T, opts?: ChainOptions & QueryChainOptions);
-    static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions): QueryUtil<U>;
-    static create<U extends Record<string, RouteOpts$1>>(value: U, opts?: ChainOptions): QueryUtil<U>;
-    get<K extends keyof T>(key: K): RouteOpts$1;
-    chain<K extends keyof T>(key: K, opts?: ChainOptions): Chain;
-    queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions): QueryChain;
-    static Chain: typeof Chain;
-    static QueryChain: typeof QueryChain;
-    get routeObject(): T;
-}
-
 type RouterHandle = (msg: {
     path: string;
     [key: string]: any;
@@ -962,5 +942,5 @@ type GlobOptions = {
 };
 declare const loadTS: (match?: string, { cwd, load }?: GlobOptions) => Promise<any[]>;
 
-export { App, Connect, CustomError, Mini, QueryConnect, QueryRouter, QueryRouterServer, QueryUtil, Route, ServerNode, createSchema, define, handleServer, loadTS, util };
-export type { HttpListenerFun, Listener, OnListener, OnWebSocketFn, RouteArray, RouteContext, RouteMiddleware, RouteObject, RouteOpts, RouterReq, RouterRes, Rule, Run, Schema, WS, WebSocketListenerFun, WebSocketReq, WebSocketRes };
+export { App, CustomError, Mini, QueryRouter, QueryRouterServer, QueryUtil, Route, ServerNode, createSchema, createSkill, define, handleServer, loadTS, util };
+export type { HttpListenerFun, Listener, OnListener, OnWebSocketFn, RouteArray, RouteContext, RouteMiddleware, RouteObject, RouteOpts, RouterReq, RouterRes, Rule, Run, Schema, Skill, WS, WebSocketListenerFun, WebSocketReq, WebSocketRes };