typespeed 2.4.10 → 2.5.0

package/dist/decorator-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * 装饰器双签名感知工具。
+ *
+ * typespeed 2.5.x 起，装饰器同时支持两套运行时签名：
+ *   - legacy（experimentalDecorators: true，2.4.x 现状）：
+ *       类装饰器 (ctor)；方法/属性装饰器 (target, key)；带 descriptor 的方法 (target, key, descriptor)；参数 (target, key, index)
+ *   - 标准（TC39 装饰器提案，当前 Stage 2.7，experimentalDecorators: false）：
+ *       统一 (value, context)，context 恒为带 kind 字段的对象
+ *
+ * 装饰器函数本质是普通函数，运行时收到什么签名由「调用方（用户代码）」的编译模式决定，
+ * 因此库可以单份源码、运行时按签名形态分流：legacy 分支逻辑与 2.4.x 逐字一致，标准分支为新增。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStdArgs = exports.isStd = void 0;
+/**
+ * 判断装饰器收到的运行时参数是否为标准装饰器签名 (value, context)。
+ *
+ * 判据（与 `2.5.x-新版装饰器使用方案.md` 一致）：
+ *   参数个数 === 2 且第二个参数是「带 string 类型 kind 字段」的对象。
+ *
+ * 为什么这个判据可靠：
+ *   - legacy 类装饰器只有 1 参 → 不满足 length === 2
+ *   - legacy 方法/属性装饰器第二参是 string 的 key → 不是对象
+ *   - legacy 带 descriptor 的方法 / 参数装饰器是 3 参 → 不满足 length === 2
+ *   - 标准模式第二参恒是带 kind 的对象 → 命中
+ */
+function isStd(args) {
+    return args.length === 2
+        && typeof args[1] === "object"
+        && args[1] !== null
+        && typeof args[1].kind === "string";
+}
+exports.isStd = isStd;
+/**
+ * 从标准装饰器参数中解出 (value, context)。
+ * 仅应在 isStd(args) 为 true 时调用。
+ */
+function getStdArgs(args) {
+    return [args[0], args[1]];
+}
+exports.getStdArgs = getStdArgs;

package/dist/route.decorator.js

@@ -4,6 +4,8 @@ exports.jwt = exports.upload = exports.setRouter = exports.requestMapping = expo
 const multiparty = require("multiparty");
 const express_jwt_1 = require("express-jwt");
 const core_decorator_1 = require("./core.decorator");
+const decorator_utils_1 = require("./decorator-utils");
+const bind_decorator_1 = require("./bind.decorator");
 const routerMapper = {
     "get": {},
     "post": {},
@@ -28,7 +30,53 @@ function setRouter(app) {
 }
 exports.setRouter = setRouter;
 function mapperFunction(method, value) {
-    return (target, propertyKey) => {
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [methodFn, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                const className = this.constructor.name;
+                const propertyKey = String(ctx.name);
+                applyRouteBind(className, propertyKey, methodFn);
+                routerMapper[method][value] = {
+                    "path": value,
+                    "name": [className, propertyKey].toString(),
+                    "target": this.constructor,
+                    "propertyKey": propertyKey,
+                    "invoker": async (req, res, next) => {
+                        const routerBean = (0, core_decorator_1.getComponent)(this.constructor);
+                        try {
+                            let paramTotal = routerBean[propertyKey].length;
+                            if (routerParamsTotal[[className, propertyKey].toString()]) {
+                                paramTotal = Math.max(paramTotal, routerParamsTotal[[className, propertyKey].toString()]);
+                            }
+                            const callArgs = [req, res, next];
+                            if (paramTotal > 0) {
+                                for (let i = 0; i < paramTotal; i++) {
+                                    if (routerParams[[className, propertyKey, i].toString()]) {
+                                        callArgs[i] = routerParams[[className, propertyKey, i].toString()](req, res, next);
+                                    }
+                                }
+                            }
+                            const testResult = await routerBean[propertyKey].apply(routerBean, callArgs);
+                            if (typeof testResult === "object") {
+                                res.json(testResult);
+                            }
+                            else if (typeof testResult !== "undefined") {
+                                res.send(testResult);
+                            }
+                            return testResult;
+                        }
+                        catch (err) {
+                            next(err);
+                        }
+                    }
+                };
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
+        applyRouteBind(target.constructor.name, propertyKey, target[propertyKey]);
         routerMapper[method][value] = {
             "path": value,
             "name": [target.constructor.name, propertyKey].toString(),
@@ -65,7 +113,22 @@ function mapperFunction(method, value) {
         };
     };
 }
-function upload(target, propertyKey) {
+function upload(...args) {
+    if ((0, decorator_utils_1.isStd)(args)) {
+        const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+        ctx.addInitializer(function () {
+            const key = [this.constructor.name, String(ctx.name)].toString();
+            if (routerMiddleware[key]) {
+                routerMiddleware[key].push(uploadMiddleware);
+            }
+            else {
+                routerMiddleware[key] = [uploadMiddleware];
+            }
+        });
+        return;
+    }
+    const target = args[0];
+    const propertyKey = args[1];
     const key = [target.constructor.name, propertyKey].toString();
     if (routerMiddleware[key]) {
         routerMiddleware[key].push(uploadMiddleware);
@@ -83,7 +146,22 @@ function uploadMiddleware(req, res, next) {
     });
 }
 function jwt(jwtConfig) {
-    return (target, propertyKey) => {
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                const key = [this.constructor.name, String(ctx.name)].toString();
+                if (routerMiddleware[key]) {
+                    routerMiddleware[key].push((0, express_jwt_1.expressjwt)(jwtConfig));
+                }
+                else {
+                    routerMiddleware[key] = [(0, express_jwt_1.expressjwt)(jwtConfig)];
+                }
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         const key = [target.constructor.name, propertyKey].toString();
         if (routerMiddleware[key]) {
             routerMiddleware[key].push((0, express_jwt_1.expressjwt)(jwtConfig));
@@ -96,15 +174,34 @@ function jwt(jwtConfig) {
 exports.jwt = jwt;
 function before(constructorFunction, methodName) {
     const targetBean = (0, core_decorator_1.getComponent)(constructorFunction);
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const hookKey = String(ctx.name);
+            ctx.addInitializer(function () {
+                const currentMethod = this[methodName];
+                if (currentMethod && currentMethod.length > 0) {
+                    routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+                }
+                Object.assign(this, {
+                    [methodName]: function (...innerArgs) {
+                        this[hookKey](...innerArgs);
+                        return currentMethod.apply(this, innerArgs);
+                    }
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         const currentMethod = targetBean[methodName];
         if (currentMethod.length > 0) {
             routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
         }
         Object.assign(targetBean, {
-            [methodName]: function (...args) {
-                target[propertyKey](...args);
-                return currentMethod.apply(targetBean, args);
+            [methodName]: function (...innerArgs) {
+                target[propertyKey](...innerArgs);
+                return currentMethod.apply(targetBean, innerArgs);
             }
         });
     };
@@ -112,14 +209,34 @@ function before(constructorFunction, methodName) {
 exports.before = before;
 function after(constructorFunction, methodName) {
     const targetBean = (0, core_decorator_1.getComponent)(constructorFunction);
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const hookKey = String(ctx.name);
+            ctx.addInitializer(function () {
+                const currentMethod = this[methodName];
+                if (currentMethod && currentMethod.length > 0) {
+                    routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+                }
+                Object.assign(this, {
+                    [methodName]: function (...innerArgs) {
+                        const result = currentMethod.apply(this, innerArgs);
+                        const afterResult = this[hookKey](result);
+                        return afterResult !== null && afterResult !== void 0 ? afterResult : result;
+                    }
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         const currentMethod = targetBean[methodName];
         if (currentMethod.length > 0) {
             routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
         }
         Object.assign(targetBean, {
-            [methodName]: function (...args) {
-                const result = currentMethod.apply(targetBean, args);
+            [methodName]: function (...innerArgs) {
+                const result = currentMethod.apply(targetBean, innerArgs);
                 const afterResult = target[propertyKey](result);
                 return afterResult !== null && afterResult !== void 0 ? afterResult : result;
             }
@@ -160,6 +277,54 @@ function getParamInFunction(fn, index) {
     const result = code.slice(code.indexOf('(') + 1, code.indexOf(')')).match(/([^\s,]+)/g);
     return result[index] || null;
 }
+/** 解析函数参数名列表（供 route @bind 做「参数名 → 索引」映射） */
+function getParamNames(fn) {
+    const code = fn.toString().replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg, '').replace(/=>.*$/mg, '').replace(/=[^,)]+/g, '');
+    const paramsStr = code.slice(code.indexOf('(') + 1, code.indexOf(')'));
+    if (!paramsStr.trim())
+        return [];
+    return paramsStr.split(',').map(p => {
+        const matched = p.trim().match(/([A-Za-z_$][\w$]*)/);
+        return matched ? matched[1] : p.trim();
+    }).filter(Boolean);
+}
+/** 把 route @bind 的「来源字符串」转成参数解析器 */
+function getRouteSourceResolver(source, paramName) {
+    switch (source) {
+        case "req": return (req, res, next) => req;
+        case "res": return (req, res, next) => res;
+        case "next": return (req, res, next) => next;
+        case "reqBody": return (req, res, next) => req.body;
+        case "reqParam": return (req, res, next) => req.params[paramName];
+        case "reqQuery": return (req, res, next) => req.query[paramName];
+        case "reqForm": return (req, res, next) => req.body[paramName];
+        default: return null;
+    }
+}
+/** 读取 @bind 声明，把「参数名 → 来源」转成 routerParams 的「索引 → 解析器」 */
+function applyRouteBind(className, propertyKey, method) {
+    const bindMapping = (0, bind_decorator_1.getBindMapping)(className, propertyKey);
+    if (!bindMapping)
+        return;
+    const paramNames = getParamNames(method);
+    const nameToIndex = {};
+    paramNames.forEach((paramName, index) => {
+        if (paramName && nameToIndex[paramName] === undefined)
+            nameToIndex[paramName] = index;
+    });
+    for (const bindName in bindMapping) {
+        const source = bindMapping[bindName];
+        if (typeof source !== "string")
+            continue; // 跳过 database 的数值映射
+        const index = nameToIndex[bindName];
+        if (index === undefined)
+            continue;
+        const resolver = getRouteSourceResolver(source, bindName);
+        if (resolver) {
+            routerParams[[className, propertyKey, index].toString()] = resolver;
+        }
+    }
+}
 function reqQuery(target, propertyKey, parameterIndex) {
     const key = [target.constructor.name, propertyKey, parameterIndex].toString();
     const paramName = getParamInFunction(target[propertyKey], parameterIndex);

package/dist/typespeed.d.ts

@@ -5,68 +5,74 @@ import "reflect-metadata";
 
 /**设置路由中间件 */
 declare function setRouter(app: express.Application): void;
-/**上传文件装饰器，装饰页面具备解析上传文件的能力 */
-declare function upload(target: any, propertyKey: string): void;
+/**上传文件装饰器，装饰页面具备解析上传文件的能力（legacy 方法装饰器；2.5.x 起兼容标准 (value, context) 签名） */
+declare function upload(...args: any[]): any;
 /**
  * 页面支持 JWT 鉴权能力
  * @param jwtConfig jwt 配置
  */
-declare function jwt(jwtConfig: any): (target: any, propertyKey: string) => void;
+declare function jwt(jwtConfig: any): (...args: any[]) => any;
 /**
  * GET 请求装饰器
  * @param value 请求路径
  */
-declare const getMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const getMapping: (value: string) => (...args: any[]) => any;
 /**
  * POST 请求装饰器
  * @param value 请求路径
  */
-declare const postMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const postMapping: (value: string) => (...args: any[]) => any;
 /**
  * 请求装饰器，不区分请求类型
  * @param value 请求路径
  */
-declare const requestMapping: (value: string) => (target: any, propertyKey: string) => void;
+declare const requestMapping: (value: string) => (...args: any[]) => any;
 /**
  * INSERT 装饰器
  * 将方法作为 INSERT SQL 使用
  * @param sql INSERT SQL 语句
  */
-declare function insert(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function insert(sql: string): (...args: any[]) => any;
 /**
  * UPDATE 装饰器
  * 将方法作为 UPDATE SQL 使用
  * @param sql UPDATE SQL 语句
  */
-declare function update(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function update(sql: string): (...args: any[]) => any;
 /**
  * DELETE 装饰器
  * 将方法作为 DELETE SQL 使用
  * @param sql DELETE SQL 语句
  */
-declare function remove(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function remove(sql: string): (...args: any[]) => any;
 /**
  * SELECT 装饰器
  * 将方法作为 SELECT SQL 使用
  * @param sql SELECT SQL 语句
  */
-declare function select(sql: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function select(sql: string): (...args: any[]) => any;
 /**
  * SELECT 结果类型装饰器，和 @select 配合使用
  * @param dataClass 结果类型
  */
-declare function resultType(dataClass: any): (target: any, propertyKey: string) => void;
+declare function resultType(dataClass: any): (...args: any[]) => any;
 /**
  * SQL 参数装饰器，标注 SQL 语句的绑定参数值，和 @select @insert @update @remove 配合使用
  * @param name 参数在 SQL 语句内的标记值
  */
 declare function param(name: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * 方法级参数绑定装饰器（标准装饰器删除了参数装饰器后的替代，legacy 模式也可用）。
+ * database 场景映射 SQL 占位符 → 参数索引（值为 number）；route 场景映射参数名 → 请求来源（值为 string）。
+ * @param mapping 绑定声明，如 { name: 0, id: 1 } 或 { id: "reqParam", body: "reqBody" }
+ */
+declare function bind(mapping: Record<string, string | number>): (...args: any[]) => any;
 /**
  * SELECT 缓存装饰器，自动缓存 SELECT 查询结果，和 @select 配合使用
  * 当执行 @insert @update @remove 时，会自动清除缓存。
  * @param ttl 缓存时间，单位秒
  */
-declare function cache(ttl: number): (target: any, propertyKey: string) => void;
+declare function cache(ttl: number): (...args: any[]) => any;
 /**模型数据操作类 */
 declare class Model {
     /**分页数据 */
@@ -139,23 +145,21 @@ declare class Model {
  * 
  * 被装饰的类将作为应用程序入口，框架将启动该类的 main 方法
  */
-declare function app<T extends {
-    new(...args: any[]): {};
-}>(constructor: T): void;
+declare function app(...args: any[]): any;
 /**获取配置文件中的配置项 */
 declare function config(node: string): any;
-/**组件装饰器，被装饰的类可以通过 @autoware 取得实例 */
-declare function component(constructorFunction: any): void;
+/**组件装饰器，被装饰的类可以通过 @autoware 取得实例（legacy 类装饰器；2.5.x 起兼容标准 (value, context) 签名） */
+declare function component(...args: any[]): any;
 /**获取组件实例函数，返回结果同 @autoware */
 declare function getComponent(constructorFunction: any): any;
-/**提供对象装饰器，框架将使用 @bean 装饰的方法来获取对象实例 */
-declare function bean(target: any, propertyKey: string): void;
+/**提供对象装饰器，框架将使用 @bean 装饰的方法来获取对象实例（legacy 方法装饰器；2.5.x 起兼容标准签名） */
+declare function bean(...args: any[]): any;
 /**获取对象实例函数，返回结果由 @bean 装饰的方法提供 */
 declare function getBean(mappingClass: Function): any;
 /**配置装饰器，装饰类成员变量值，获取配置文件中的配置项 */
 declare function value(configPath: string): any;
 /**自动装配装饰器，无参数版本，被装饰的类成员变量将自动注入实例 */
-declare function autoware(target: any, propertyKey: string): void;
+declare function autoware(...args: any[]): any;
 /**自动装配装饰器，带参数版本，可输入参数作为实例初始化参数，被装饰的类成员变量将自动注入实例 */
 declare function resource(...args: any[]): any;
 /**日志函数，输出打印日志 */
@@ -165,11 +169,11 @@ declare function logx(message: any): void;
 /**错误日志函数，输出打印错误日志 */
 declare function error(message?: any, ...optionalParams: any[]): void;
 /**路由页面前置执行装饰器，参数指向路由页面方法，被装饰的方法将在路由页面之前执行 */
-declare function before(constructorFunction: any, methodName: string): (target: any, propertyKey: string) => void;
+declare function before(constructorFunction: any, methodName: string): (...args: any[]) => any;
 /**路由页面后置执行装饰器，参数指向路由页面方法，被装饰的方法将在路由页面之后执行 */
-declare function after(constructorFunction: any, methodName: string): (target: any, propertyKey: string) => void;
+declare function after(constructorFunction: any, methodName: string): (...args: any[]) => any;
 /**定时程序装饰器，参数支持 crontab 格式字符串，可根据参数定时执行被装饰的方法 */
-declare function schedule(cronTime: string | Date): (target: any, propertyKey: string) => void;
+declare function schedule(cronTime: string | Date): (...args: any[]) => any;
 /**RabbitMQ 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
 declare function rabbitListener(queue: string): (target: any, propertyKey: string) => void;
 /**Redis 监听装饰器，参数是监听的队列名称，当接受到消息时将执行被装饰方法 */
@@ -396,4 +400,4 @@ declare class SocketIo {
 /**Socket IO 服务实现类 */
 declare const io: IoServer;
 
-export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, logx, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, resultType, cache, Model, SocketIo, io };
+export { ExpressServer, LogDefault, NodeCache, RabbitMQ, rabbitListener, redisSubscriber, ReadWriteDb, Redis, CacheFactory, DataSourceFactory, LogFactory, ServerFactory, AuthenticationFactory, next, reqBody, reqQuery, reqForm, reqParam, req, req as request, res, res as response, component, bean, resource, log, logx, app, before, after, value, error, config, autoware, getBean, getComponent, schedule, getMapping, postMapping, requestMapping, setRouter, upload, jwt, insert, update, remove, select, param, bind, resultType, cache, Model, SocketIo, io };

package/dist/typespeed.js

@@ -19,6 +19,7 @@ require("reflect-metadata");
 const fs = require("fs");
 const path = require("path");
 const walkSync = require("walk-sync");
+const decorator_utils_1 = require("./decorator-utils");
 let globalConfig = {};
 const corePath = __dirname;
 const mainPath = path.dirname(getRootPath(new Error().stack.split("\n")) || process.argv[1]);
@@ -33,7 +34,18 @@ if (fs.existsSync(configFile)) {
 }
 globalConfig["MAIN_PATH"] = mainPath;
 globalConfig["CORE_PATH"] = corePath;
-function app(constructor) {
+function app(...args) {
+    if ((0, decorator_utils_1.isStd)(args)) {
+        const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+        ctx.addInitializer(function () {
+            startApp(this.constructor);
+        });
+        return;
+    }
+    startApp(args[0]);
+}
+exports.app = app;
+function startApp(constructor) {
     const coreFiles = walkSync(corePath, { globs: ['**/*.ts'], ignore: ['**/*.d.ts', 'scaffold/**'] });
     const mainFiles = walkSync(mainPath, { globs: ['**/*.ts'] });
     (async function () {
@@ -56,13 +68,28 @@ function app(constructor) {
         main["main"]();
     }());
 }
-exports.app = app;
 function config(node) {
     return globalConfig[node] || null;
 }
 exports.config = config;
 function value(configPath) {
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            // 标准 field 装饰器：返回 initializer 注入配置值（标准模式下无 design:type）。
+            return (initialValue) => {
+                if (globalConfig === undefined) {
+                    return initialValue;
+                }
+                let pathNodes = configPath.split(".");
+                let nodeValue = globalConfig;
+                for (let i = 0; i < pathNodes.length; i++) {
+                    nodeValue = nodeValue[pathNodes[i]];
+                }
+                return nodeValue === undefined ? initialValue : nodeValue;
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         if (globalConfig === undefined) {
             Object.defineProperty(target, propertyKey, {
                 get: () => {
@@ -86,10 +113,14 @@ function value(configPath) {
 }
 exports.value = value;
 function getRootPath(lines) {
-    const macths = ["at Function.Module._load", "at Module.require", "at require", "at Object.<anonymous>"];
+    // 兼容新旧 Node 栈帧（Node<22: "Function.Module._load" / Node22+: "Function._load"）、
+    // mocha(ts-node) 下 "Context.<anonymous>" 与中间可能插入的 "wrapModuleLoad" 帧：
+    // 按顺序出现匹配（不要求严格相邻），提高在各种加载器下的容错。
+    const macths = [/at Function(\.Module)?\._load/, "at Module.require", /at require\b/, /at (Object|Context)\.<anonymous>/];
     let matchIndex = 0;
     for (let line of lines) {
-        if (line.includes(macths[matchIndex])) {
+        const matcher = macths[matchIndex];
+        if (matcher instanceof RegExp ? matcher.test(line) : line.includes(matcher)) {
             if (matchIndex === macths.length - 1) {
                 let arr = line.split("(")[1].split(":");
                 arr.pop();
@@ -98,15 +129,13 @@ function getRootPath(lines) {
             }
             matchIndex++;
         }
-        else {
-            matchIndex = 0;
-        }
     }
     return undefined;
 }
 __exportStar(require("./core.decorator"), exports);
 __exportStar(require("./route.decorator"), exports);
 __exportStar(require("./database.decorator"), exports);
+__exportStar(require("./bind.decorator"), exports);
 var log_factory_class_1 = require("./factory/log-factory.class");
 Object.defineProperty(exports, "LogFactory", { enumerable: true, get: function () { return log_factory_class_1.default; } });
 var cache_factory_class_1 = require("./factory/cache-factory.class");

package/introduction/decorator-next/dist/main.js

@@ -0,0 +1,116 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Symbol.metadata polyfill：Node 22/24/26 都没有 Symbol.metadata，
+// 标准装饰器的 context.metadata 依赖它，缺失会 TypeError，必须最先执行。
+Symbol.metadata ??= Symbol("Symbol.metadata");
+const express_1 = __importDefault(require("express"));
+const typespeed_1 = require("../../../dist/typespeed");
+class CacheBean {
+    name = "cache-bean";
+}
+let TestService = (() => {
+    let _classDecorators = [typespeed_1.component];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _getCache_decorators;
+    let _cache_decorators;
+    let _cache_initializers = [];
+    let _cache_extraInitializers = [];
+    let _test_decorators;
+    var TestService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getCache_decorators = [(0, typespeed_1.bean)(CacheBean)];
+            _cache_decorators = [(0, typespeed_1.autoware)(CacheBean)];
+            _test_decorators = [(0, typespeed_1.getMapping)("/std/test/:id"), (0, typespeed_1.bind)({ id: "reqParam" })];
+            __esDecorate(this, null, _getCache_decorators, { kind: "method", name: "getCache", static: false, private: false, access: { has: obj => "getCache" in obj, get: obj => obj.getCache }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _test_decorators, { kind: "method", name: "test", static: false, private: false, access: { has: obj => "test" in obj, get: obj => obj.test }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, null, _cache_decorators, { kind: "field", name: "cache", static: false, private: false, access: { has: obj => "cache" in obj, get: obj => obj.cache, set: (obj, value) => { obj.cache = value; } }, metadata: _metadata }, _cache_initializers, _cache_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TestService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        getCache() { return new CacheBean(); }
+        cache = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _cache_initializers, void 0));
+        // 标准模式：无参数装饰器，@bind 声明「参数名 → 来源」
+        async test(id) {
+            return { id, cache: this.cache.name };
+        }
+        constructor() {
+            __runInitializers(this, _cache_extraInitializers);
+        }
+    };
+    return TestService = _classThis;
+})();
+// 验证 1：@component / @autoware / @bean
+const svc = (0, typespeed_1.getComponent)(TestService);
+console.log("[component] registered:", svc !== undefined);
+console.log("[autoware(CacheBean)] injected:", svc && svc.cache?.name);
+console.log("[bean(CacheBean)] factory:", (0, typespeed_1.getBean)(CacheBean)?.name);
+// 验证 2：@getMapping + @bind 路由，走 setRouter 真实 HTTP 请求
+const app = (0, express_1.default)();
+(0, typespeed_1.setRouter)(app);
+const server = app.listen(0, () => {
+    const addr = server.address();
+    const port = addr.port;
+    httpGet(`http://127.0.0.1:${port}/std/test/123`, (body) => {
+        console.log("[route @bind] response:", body);
+        const parsed = JSON.parse(body);
+        const ok = svc !== undefined
+            && svc.cache?.name === "cache-bean"
+            && (0, typespeed_1.getBean)(CacheBean)?.name === "cache-bean"
+            && parsed.id === "123"
+            && parsed.cache === "cache-bean";
+        console.log(ok ? "STANDARD DECORATORS OK" : "STANDARD DECORATORS FAILED");
+        server.close();
+        process.exit(ok ? 0 : 1);
+    });
+});
+function httpGet(url, cb) {
+    require("http").get(url, (res) => {
+        let data = "";
+        res.on("data", (chunk) => { data += chunk; });
+        res.on("end", () => cb(data));
+    });
+}

package/introduction/decorator-next/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "typespeed-example-std",
+  "version": "1.0.0",
+  "private": true,
+  "description": "typespeed 标准装饰器（TC39 Stage 2.7）示例：experimentalDecorators: false + Symbol.metadata polyfill",
+  "scripts": {
+    "build": "tsc -p .",
+    "start": "node dist/main.js"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@types/node": "^18.19.3"
+  }
+}