@gravito/pulse 1.0.1 → 2.1.0

package/dist/index.js

@@ -7153,6 +7153,59 @@ var init_src = __esm(() => {
   init_dist();
 });
 
+// ../atlas/src/errors/index.ts
+var DatabaseError, ConstraintViolationError, UniqueConstraintError, ForeignKeyConstraintError, NotNullConstraintError, TableNotFoundError, ConnectionError;
+var init_errors = __esm(() => {
+  DatabaseError = class DatabaseError extends Error {
+    originalError;
+    query;
+    bindings;
+    constructor(message, originalError, query, bindings) {
+      super(message);
+      this.name = "DatabaseError";
+      this.originalError = originalError;
+      this.query = query;
+      this.bindings = bindings;
+    }
+  };
+  ConstraintViolationError = class ConstraintViolationError extends DatabaseError {
+    constructor(message, originalError, query, bindings) {
+      super(message, originalError, query, bindings);
+      this.name = "ConstraintViolationError";
+    }
+  };
+  UniqueConstraintError = class UniqueConstraintError extends ConstraintViolationError {
+    constructor(message, originalError, query, bindings) {
+      super(message, originalError, query, bindings);
+      this.name = "UniqueConstraintError";
+    }
+  };
+  ForeignKeyConstraintError = class ForeignKeyConstraintError extends ConstraintViolationError {
+    constructor(message, originalError, query, bindings) {
+      super(message, originalError, query, bindings);
+      this.name = "ForeignKeyConstraintError";
+    }
+  };
+  NotNullConstraintError = class NotNullConstraintError extends ConstraintViolationError {
+    constructor(message, originalError, query, bindings) {
+      super(message, originalError, query, bindings);
+      this.name = "NotNullConstraintError";
+    }
+  };
+  TableNotFoundError = class TableNotFoundError extends DatabaseError {
+    constructor(message, originalError, query, bindings) {
+      super(message, originalError, query, bindings);
+      this.name = "TableNotFoundError";
+    }
+  };
+  ConnectionError = class ConnectionError extends DatabaseError {
+    constructor(message, originalError) {
+      super(message, originalError);
+      this.name = "ConnectionError";
+    }
+  };
+});
+
 // ../../node_modules/.bun/bson@6.10.4/node_modules/bson/lib/bson.cjs
 var require_bson = __commonJS((exports) => {
   var TypedArrayPrototypeGetSymbolToStringTag = (() => {
@@ -40473,71 +40526,20 @@ var require_lib4 = __commonJS((exports) => {
   } });
 });
 
-// ../atlas/src/errors/index.ts
-var DatabaseError, ConstraintViolationError, UniqueConstraintError, ForeignKeyConstraintError, NotNullConstraintError, TableNotFoundError, ConnectionError;
-var init_errors = __esm(() => {
-  DatabaseError = class DatabaseError extends Error {
-    originalError;
-    query;
-    bindings;
-    constructor(message, originalError, query, bindings) {
-      super(message);
-      this.name = "DatabaseError";
-      this.originalError = originalError;
-      this.query = query;
-      this.bindings = bindings;
-    }
-  };
-  ConstraintViolationError = class ConstraintViolationError extends DatabaseError {
-    constructor(message, originalError, query, bindings) {
-      super(message, originalError, query, bindings);
-      this.name = "ConstraintViolationError";
-    }
-  };
-  UniqueConstraintError = class UniqueConstraintError extends ConstraintViolationError {
-    constructor(message, originalError, query, bindings) {
-      super(message, originalError, query, bindings);
-      this.name = "UniqueConstraintError";
-    }
-  };
-  ForeignKeyConstraintError = class ForeignKeyConstraintError extends ConstraintViolationError {
-    constructor(message, originalError, query, bindings) {
-      super(message, originalError, query, bindings);
-      this.name = "ForeignKeyConstraintError";
-    }
-  };
-  NotNullConstraintError = class NotNullConstraintError extends ConstraintViolationError {
-    constructor(message, originalError, query, bindings) {
-      super(message, originalError, query, bindings);
-      this.name = "NotNullConstraintError";
-    }
-  };
-  TableNotFoundError = class TableNotFoundError extends DatabaseError {
-    constructor(message, originalError, query, bindings) {
-      super(message, originalError, query, bindings);
-      this.name = "TableNotFoundError";
-    }
-  };
-  ConnectionError = class ConnectionError extends DatabaseError {
-    constructor(message, originalError) {
-      super(message, originalError);
-      this.name = "ConnectionError";
-    }
-  };
-});
-
 // ../atlas/src/drivers/MongoDBDriver.ts
 class MongoDBDriver {
   config;
   client = null;
   db = null;
   MongoClientCtor;
-  constructor(config, deps = {}) {
+  constructor(config, deps) {
     if (config.driver !== "mongodb") {
-      throw new Error(`Invalid driver type '\${config.driver}' for MongoDBDriver`);
+      throw new Error(`Invalid driver type '${config.driver}' for MongoDBDriver`);
     }
     this.config = config;
-    this.MongoClientCtor = deps.MongoClient ?? import_mongodb.MongoClient;
+    if (deps?.MongoClient) {
+      this.MongoClientCtor = deps.MongoClient;
+    }
   }
   getDriverName() {
     return "mongodb";
@@ -40547,13 +40549,22 @@ class MongoDBDriver {
       return;
     }
     try {
-      this.client = new this.MongoClientCtor(this.config.uri ?? `mongodb://\${this.config.host}:\${this.config.port}/\${this.config.database}`);
+      const Ctor = this.MongoClientCtor || (await this.loadMongoModule()).MongoClient;
+      this.client = new Ctor(this.config.uri ?? `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`);
       await this.client.connect();
       this.db = this.client.db(this.config.database);
     } catch (error) {
       throw new ConnectionError("Could not connect to MongoDB cluster", error);
     }
   }
+  async loadMongoModule() {
+    try {
+      const mongodb = await Promise.resolve().then(() => __toESM(require_lib4(), 1));
+      return mongodb;
+    } catch (e) {
+      throw new Error(`MongoDB driver requires the "mongodb" package. Please install it: bun add mongodb. Original Error: ${e}`);
+    }
+  }
   async disconnect() {
     if (this.client) {
       await this.client.close();
@@ -40646,10 +40657,8 @@ class MongoDBDriver {
     return doc;
   }
 }
-var import_mongodb;
 var init_MongoDBDriver = __esm(() => {
   init_errors();
-  import_mongodb = __toESM(require_lib4(), 1);
 });
 
 // ../../node_modules/.bun/sqlstring@2.3.3/node_modules/sqlstring/lib/SqlString.js
@@ -74589,12 +74598,14 @@ class RedisDriver {
   config;
   client = null;
   RedisCtor;
-  constructor(config, deps = {}) {
+  constructor(config, deps) {
     if (config.driver !== "redis") {
       throw new Error(`Invalid driver type '${config.driver}' for RedisDriver`);
     }
     this.config = config;
-    this.RedisCtor = deps.Redis ?? import_ioredis.default;
+    if (deps?.Redis) {
+      this.RedisCtor = deps.Redis;
+    }
   }
   getDriverName() {
     return "redis";
@@ -74604,7 +74615,8 @@ class RedisDriver {
       return;
     }
     try {
-      this.client = new this.RedisCtor({
+      const Ctor = this.RedisCtor || (await this.loadRedisModule()).default;
+      this.client = new Ctor({
         host: this.config.host,
         port: this.config.port ?? 6379,
         password: this.config.password,
@@ -74616,6 +74628,14 @@ class RedisDriver {
       throw new ConnectionError("Could not connect to Redis host", error);
     }
   }
+  async loadRedisModule() {
+    try {
+      const ioredis = await Promise.resolve().then(() => __toESM(require_built3(), 1));
+      return ioredis;
+    } catch (e) {
+      throw new Error(`Redis driver requires the "ioredis" package. Please install it: bun add ioredis. Original Error: ${e}`);
+    }
+  }
   async disconnect() {
     if (this.client) {
       await this.client.quit();
@@ -74687,10 +74707,8 @@ class RedisDriver {
     return false;
   }
 }
-var import_ioredis;
 var init_RedisDriver = __esm(() => {
   init_errors();
-  import_ioredis = __toESM(require_built3(), 1);
 });
 
 // ../../node_modules/.bun/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
@@ -75485,11 +75503,15 @@ class SQLiteDriver {
         });
         this.client.exec("PRAGMA journal_mode = WAL;");
       } else {
-        const { default: Database } = await Promise.resolve().then(() => __toESM(require_lib11(), 1));
-        this.client = new Database(this.config.database, {
-          readonly: this.config.readonly ?? false
-        });
-        this.client.pragma("journal_mode = WAL");
+        try {
+          const { default: Database } = await Promise.resolve().then(() => __toESM(require_lib11(), 1));
+          this.client = new Database(this.config.database, {
+            readonly: this.config.readonly ?? false
+          });
+          this.client.pragma("journal_mode = WAL");
+        } catch (e) {
+          throw new Error(`SQLite driver requires "better-sqlite3" when running in Node.js. Please install it: bun add better-sqlite3. Original Error: ${e}`);
+        }
       }
     } catch (error) {
       throw new ConnectionError("Could not connect to SQLite database", error);
@@ -77756,7 +77778,7 @@ var init_Connection = __esm(() => {
       return new Proxy(this, {
         get(target, prop) {
           if (prop in target) {
-            return target[prop];
+            return Reflect.get(target, prop);
           }
           if (typeof prop === "string" && target.driver && typeof target.driver[prop] === "function") {
             return target.driver[prop].bind(target.driver);
@@ -81111,6 +81133,26 @@ class BaseGenerator {
     await this.writeFile(context.targetDir, ".dockerignore", this.generateDockerIgnore());
     await this.writeFile(context.targetDir, "ARCHITECTURE.md", this.generateArchitectureDoc(context));
     await this.generateCheckScripts(context);
+    await this.generateSkills(context);
+  }
+  async generateSkills(context) {
+    const skillsDir = path2.resolve(this.config.templatesDir, "skills");
+    const targetSkillsDir = path2.join(".skills");
+    try {
+      await fs2.access(skillsDir);
+    } catch {
+      return;
+    }
+    const files = await walk(skillsDir);
+    for (const filePath of files) {
+      const relativePath = path2.relative(skillsDir, filePath);
+      const targetPath = path2.join(targetSkillsDir, relativePath);
+      let content = await fs2.readFile(filePath, "utf-8");
+      try {
+        content = this.stubGenerator.render(content, context);
+      } catch {}
+      await this.writeFile(context.targetDir, targetPath, content);
+    }
   }
   async applyOverlays(context) {
     const profile = context.profile;
@@ -83314,6 +83356,8 @@ export class ${name}ServiceProvider extends ServiceProvider {
     return `export default {
   name: process.env.APP_NAME ?? '${context.name}',
   env: process.env.APP_ENV ?? 'development',
+  port: Number.parseInt(process.env.PORT ?? '3000', 10),
+  VIEW_DIR: process.env.VIEW_DIR ?? 'src/views',
   debug: process.env.APP_DEBUG === 'true',
   url: process.env.APP_URL ?? 'http://localhost:3000',
 }
@@ -83960,6 +84004,16 @@ export default {
    */
   env: process.env.APP_ENV ?? 'development',
 
+  /**
+   * Application port
+   */
+  port: Number.parseInt(process.env.PORT ?? '3000', 10),
+
+  /**
+   * View directory
+   */
+  VIEW_DIR: process.env.VIEW_DIR ?? 'src/views',
+
   /**
    * Debug mode
    */
@@ -84083,8 +84137,7 @@ export default {
    */
   providers: {
     users: {
-      driver: 'database',
-      table: 'users',
+      driver: 'callback', // Custom callback provider
     },
   },
 }
@@ -85332,6 +85385,8 @@ class ActionDomainGenerator extends BaseGenerator {
     return `export default {
   name: process.env.APP_NAME ?? '${context.name}',
   env: process.env.APP_ENV ?? 'development',
+  port: Number.parseInt(process.env.PORT ?? '3000', 10),
+  VIEW_DIR: process.env.VIEW_DIR ?? 'src/views',
   debug: process.env.APP_DEBUG === 'true',
   url: process.env.APP_URL ?? 'http://localhost:3000',
   key: process.env.APP_KEY,
@@ -85649,6 +85704,115 @@ Created with \u2764\uFE0F using Gravito Framework
   }
 }
 
+// ../scaffold/src/generators/StandaloneEngineGenerator.ts
+class StandaloneEngineGenerator extends BaseGenerator {
+  get architectureType() {
+    return "standalone-engine";
+  }
+  get displayName() {
+    return "Standalone Engine";
+  }
+  get description() {
+    return "High-performance pure Gravito Engine (minimal)";
+  }
+  getDirectoryStructure(context) {
+    return [
+      {
+        type: "directory",
+        name: "src",
+        children: [
+          {
+            type: "file",
+            name: "index.ts",
+            content: this.getIndexContent()
+          }
+        ]
+      },
+      {
+        type: "file",
+        name: "README.md",
+        content: this.getReadmeContent(context)
+      }
+    ];
+  }
+  async generateCommonFiles(context) {
+    await this.writeFile(context.targetDir, "package.json", this.generatePackageJson(context));
+    await this.writeFile(context.targetDir, "tsconfig.json", this.generateTsConfig());
+    await this.writeFile(context.targetDir, ".gitignore", this.generateGitignore());
+  }
+  generatePackageJson(context) {
+    const pkg = {
+      name: context.nameKebabCase,
+      version: "0.1.0",
+      type: "module",
+      scripts: {
+        dev: "bun run --watch src/index.ts",
+        build: "bun build ./src/index.ts --outdir ./dist --target bun",
+        start: "bun run dist/index.js",
+        test: "bun test"
+      },
+      dependencies: {
+        "@gravito/core": "^1.1.0"
+      },
+      devDependencies: {
+        "bun-types": "latest",
+        typescript: "^5.0.0"
+      }
+    };
+    return JSON.stringify(pkg, null, 2);
+  }
+  generateArchitectureDoc(_context) {
+    return "";
+  }
+  getIndexContent() {
+    return `import { Gravito } from '@gravito/core/engine'
+
+const app = new Gravito()
+
+// Basic Route
+app.get('/', (c) => c.text('Hello Gravito Engine!'))
+
+// JSON Response
+app.get('/json', (c) => c.json({ message: 'High Performance' }))
+
+// Path Parameters
+app.get('/user/:name', (c) => {
+  const name = c.req.param('name')
+  return c.text(\`Hello \${name}\`)
+})
+
+export default app
+`;
+  }
+  getReadmeContent(context) {
+    return `# ${context.name}
+
+A high-performance web application powered by Gravito Engine.
+
+## Getting Started
+
+### Install Dependencies
+
+\`\`\`bash
+bun install
+\`\`\`
+
+### Run Development Server
+
+\`\`\`bash
+bun run dev
+\`\`\`
+
+### Production Build
+
+\`\`\`bash
+bun run build
+bun start
+\`\`\`
+`;
+  }
+}
+
 // ../scaffold/src/Scaffold.ts
 var __dirname = "/Users/carl/Dev/Carl/gravito-core/packages/scaffold/src";
 
@@ -85681,6 +85845,11 @@ class Scaffold {
         name: "Action Domain",
         description: "Single Action Controllers pattern for high-clarity APIs"
       },
+      {
+        type: "standalone-engine",
+        name: "Standalone Engine",
+        description: "High-performance pure Gravito Engine (minimal)"
+      },
       {
         type: "satellite",
         name: "Gravito Satellite",
@@ -85738,6 +85907,8 @@ class Scaffold {
         return new ActionDomainGenerator(config);
       case "satellite":
         return new SatelliteGenerator(config);
+      case "standalone-engine":
+        return new StandaloneEngineGenerator(config);
       default:
         throw new Error(`Unknown architecture type: ${type}`);
     }
@@ -85761,7 +85932,7 @@ import { confirm, note, spinner } from "@clack/prompts";
 // ../core/package.json
 var package_default = {
   name: "@gravito/core",
-  version: "1.0.0",
+  version: "1.2.0",
   description: "",
   module: "./dist/index.js",
   main: "./dist/index.cjs",
@@ -85777,6 +85948,11 @@ var package_default = {
       types: "./dist/compat.d.ts",
       import: "./dist/compat.js",
       require: "./dist/compat.cjs"
+    },
+    "./engine": {
+      types: "./dist/engine/index.d.ts",
+      import: "./dist/engine/index.js",
+      require: "./dist/engine/index.cjs"
     }
   },
   files: [
@@ -85833,6 +86009,36 @@ class PhotonRequestWrapper {
   constructor(photonCtx) {
     this.photonCtx = photonCtx;
   }
+  static create(photonCtx) {
+    const instance = new PhotonRequestWrapper(photonCtx);
+    return new Proxy(instance, {
+      get(target, prop, receiver) {
+        if (prop in target) {
+          const value = Reflect.get(target, prop, receiver);
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        }
+        const nativeReq = target.photonCtx.req;
+        if (prop in nativeReq) {
+          const value = nativeReq[prop];
+          if (typeof value === "function") {
+            return value.bind(nativeReq);
+          }
+          return value;
+        }
+        return;
+      },
+      set(target, prop, value) {
+        if (prop in target) {
+          return Reflect.set(target, prop, value);
+        }
+        target.photonCtx.req[prop] = value;
+        return true;
+      }
+    });
+  }
   get url() {
     return this.photonCtx.req.url;
   }
@@ -85894,7 +86100,7 @@ class PhotonContextWrapper {
   _req;
   constructor(photonCtx) {
     this.photonCtx = photonCtx;
-    this._req = new PhotonRequestWrapper(photonCtx);
+    this._req = PhotonRequestWrapper.create(photonCtx);
   }
   static create(photonCtx) {
     const instance = new PhotonContextWrapper(photonCtx);
@@ -86001,7 +86207,7 @@ function toPhotonMiddleware(middleware) {
   return async (c, next) => {
     const ctx = PhotonContextWrapper.create(c);
     const gravitoNext = async () => {
-      await next();
+      return await next();
     };
     return middleware(ctx, gravitoNext);
   };
@@ -87659,20 +87865,20 @@ class RouteGroup {
   group(callback) {
     callback(this);
   }
-  get(path4, requestOrHandler, handler) {
-    return this.router.req("get", path4, requestOrHandler, handler, this.options);
+  get(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.router.req("get", path4, requestOrHandlerOrMiddleware, handler, this.options);
   }
-  post(path4, requestOrHandler, handler) {
-    return this.router.req("post", path4, requestOrHandler, handler, this.options);
+  post(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.router.req("post", path4, requestOrHandlerOrMiddleware, handler, this.options);
   }
-  put(path4, requestOrHandler, handler) {
-    return this.router.req("put", path4, requestOrHandler, handler, this.options);
+  put(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.router.req("put", path4, requestOrHandlerOrMiddleware, handler, this.options);
   }
-  delete(path4, requestOrHandler, handler) {
-    return this.router.req("delete", path4, requestOrHandler, handler, this.options);
+  delete(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.router.req("delete", path4, requestOrHandlerOrMiddleware, handler, this.options);
   }
-  patch(path4, requestOrHandler, handler) {
-    return this.router.req("patch", path4, requestOrHandler, handler, this.options);
+  patch(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.router.req("patch", path4, requestOrHandlerOrMiddleware, handler, this.options);
   }
   resource(name, controller, options = {}) {
     const actions = [
@@ -87817,20 +88023,20 @@ class Router {
   middleware(...handlers) {
     return new RouteGroup(this, { middleware: handlers.flat() });
   }
-  get(path4, requestOrHandler, handler) {
-    return this.req("get", path4, requestOrHandler, handler);
+  get(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.req("get", path4, requestOrHandlerOrMiddleware, handler);
   }
-  post(path4, requestOrHandler, handler) {
-    return this.req("post", path4, requestOrHandler, handler);
+  post(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.req("post", path4, requestOrHandlerOrMiddleware, handler);
   }
-  put(path4, requestOrHandler, handler) {
-    return this.req("put", path4, requestOrHandler, handler);
+  put(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.req("put", path4, requestOrHandlerOrMiddleware, handler);
   }
-  delete(path4, requestOrHandler, handler) {
-    return this.req("delete", path4, requestOrHandler, handler);
+  delete(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.req("delete", path4, requestOrHandlerOrMiddleware, handler);
   }
-  patch(path4, requestOrHandler, handler) {
-    return this.req("patch", path4, requestOrHandler, handler);
+  patch(path4, requestOrHandlerOrMiddleware, handler) {
+    return this.req("patch", path4, requestOrHandlerOrMiddleware, handler);
   }
   resource(name, controller, options = {}) {
     const actions = [
@@ -87870,17 +88076,25 @@ class Router {
       }
     }
   }
-  req(method, path4, requestOrHandler, handler, options = {}) {
+  req(method, path4, requestOrHandlerOrMiddleware, handler, options = {}) {
     const fullPath = (options.prefix || "") + path4;
     let formRequestMiddleware = null;
+    let routeMiddleware = [];
     let finalRouteHandler;
     if (handler !== undefined) {
-      if (isFormRequestClass(requestOrHandler)) {
-        formRequestMiddleware = formRequestToMiddleware(requestOrHandler);
+      if (isFormRequestClass(requestOrHandlerOrMiddleware)) {
+        formRequestMiddleware = formRequestToMiddleware(requestOrHandlerOrMiddleware);
+      } else {
+        const middleware = requestOrHandlerOrMiddleware;
+        if (Array.isArray(middleware)) {
+          routeMiddleware = middleware;
+        } else {
+          routeMiddleware = [middleware];
+        }
       }
       finalRouteHandler = handler;
     } else {
-      finalRouteHandler = requestOrHandler;
+      finalRouteHandler = requestOrHandlerOrMiddleware;
     }
     let resolvedHandler;
     if (Array.isArray(finalRouteHandler)) {
@@ -87896,6 +88110,9 @@ class Router {
     if (formRequestMiddleware) {
       handlers.push(formRequestMiddleware);
     }
+    if (routeMiddleware.length > 0) {
+      handlers.push(...routeMiddleware);
+    }
     handlers.push(resolvedHandler);
     if (options.domain) {
       const domainCheck = async (c, next) => {
@@ -88106,8 +88323,7 @@ class PlanetCore {
       const cookieJar = new CookieJar(this.encrypter);
       c.set("cookieJar", cookieJar);
       c.route = (name, params, query) => this.router.url(name, params, query);
-      await next();
-      return;
+      return await next();
     });
     this.router = new Router(this);
     this.adapter.onError(async (err, c) => {
@@ -88444,6 +88660,655 @@ class ServiceProvider {
     return Array.from(ServiceProvider.publishables.keys());
   }
 }
+// ../core/src/engine/AOTRouter.ts
+class AOTRouter {
+  staticRoutes = new Map;
+  dynamicRouter = new RadixRouter;
+  globalMiddleware = [];
+  pathMiddleware = new Map;
+  add(method, path4, handler, middleware = []) {
+    const normalizedMethod = method.toLowerCase();
+    if (this.isStaticPath(path4)) {
+      const key = `${normalizedMethod}:${path4}`;
+      this.staticRoutes.set(key, { handler, middleware });
+    } else {
+      const wrappedHandler = handler;
+      this.dynamicRouter.add(normalizedMethod, path4, [wrappedHandler]);
+      if (middleware.length > 0) {
+        this.pathMiddleware.set(`${normalizedMethod}:${path4}`, middleware);
+      }
+    }
+  }
+  use(...middleware) {
+    this.globalMiddleware.push(...middleware);
+  }
+  usePattern(pattern, ...middleware) {
+    const existing = this.pathMiddleware.get(pattern) ?? [];
+    this.pathMiddleware.set(pattern, [...existing, ...middleware]);
+  }
+  match(method, path4) {
+    const normalizedMethod = method.toLowerCase();
+    const staticKey = `${normalizedMethod}:${path4}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        middleware: this.collectMiddleware(path4, staticRoute.middleware)
+      };
+    }
+    const match2 = this.dynamicRouter.match(normalizedMethod, path4);
+    if (match2 && match2.handlers.length > 0) {
+      const handler = match2.handlers[0];
+      const routeKey = this.findDynamicRouteKey(normalizedMethod, path4);
+      const routeMiddleware = routeKey ? this.pathMiddleware.get(routeKey) ?? [] : [];
+      return {
+        handler,
+        params: match2.params,
+        middleware: this.collectMiddleware(path4, routeMiddleware)
+      };
+    }
+    return {
+      handler: null,
+      params: {},
+      middleware: []
+    };
+  }
+  collectMiddlewarePublic(path4, routeMiddleware) {
+    return this.collectMiddleware(path4, routeMiddleware);
+  }
+  collectMiddleware(path4, routeMiddleware) {
+    if (this.globalMiddleware.length === 0 && this.pathMiddleware.size === 0 && routeMiddleware.length === 0) {
+      return [];
+    }
+    const middleware = [];
+    if (this.globalMiddleware.length > 0) {
+      middleware.push(...this.globalMiddleware);
+    }
+    if (this.pathMiddleware.size > 0) {
+      for (const [pattern, mw] of this.pathMiddleware) {
+        if (pattern.includes(":"))
+          continue;
+        if (this.matchPattern(pattern, path4)) {
+          middleware.push(...mw);
+        }
+      }
+    }
+    if (routeMiddleware.length > 0) {
+      middleware.push(...routeMiddleware);
+    }
+    return middleware;
+  }
+  isStaticPath(path4) {
+    return !path4.includes(":") && !path4.includes("*");
+  }
+  matchPattern(pattern, path4) {
+    if (pattern === "*")
+      return true;
+    if (pattern === path4)
+      return true;
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      return path4.startsWith(prefix);
+    }
+    return false;
+  }
+  findDynamicRouteKey(method, _path) {
+    for (const key of this.pathMiddleware.keys()) {
+      if (key.startsWith(`${method}:`)) {
+        return key;
+      }
+    }
+    return null;
+  }
+  getRoutes() {
+    const routes = [];
+    for (const key of this.staticRoutes.keys()) {
+      const [method, path4] = key.split(":");
+      routes.push({ method, path: path4, type: "static" });
+    }
+    return routes;
+  }
+}
+
+// ../core/src/engine/analyzer.ts
+function analyzeHandler(handler) {
+  const source = handler.toString();
+  return {
+    usesHeaders: source.includes(".header(") || source.includes(".header)") || source.includes(".headers(") || source.includes(".headers)"),
+    usesQuery: source.includes(".query(") || source.includes(".query)") || source.includes(".queries(") || source.includes(".queries)"),
+    usesBody: source.includes(".json()") || source.includes(".text()") || source.includes(".formData()") || source.includes(".body"),
+    usesParams: source.includes(".param(") || source.includes(".param)") || source.includes(".params(") || source.includes(".params)"),
+    isAsync: source.includes("async") || source.includes("await")
+  };
+}
+function getOptimalContextType(analysis) {
+  if (analysis.usesHeaders) {
+    return "fast";
+  }
+  if (!analysis.usesQuery && !analysis.usesBody && !analysis.usesParams) {
+    return "minimal";
+  }
+  if (!analysis.usesQuery && !analysis.usesBody && analysis.usesParams) {
+    return "minimal";
+  }
+  if (analysis.usesBody) {
+    return "full";
+  }
+  return "fast";
+}
+
+// ../core/src/engine/FastContext.ts
+class FastRequestImpl {
+  _request;
+  _params;
+  _url = new URL("http://localhost");
+  _query = null;
+  _headers = null;
+  reset(request, params = {}) {
+    this._request = request;
+    this._params = params;
+    this._url.href = request.url;
+    this._query = null;
+    this._headers = null;
+  }
+  get url() {
+    return this._request.url;
+  }
+  get method() {
+    return this._request.method;
+  }
+  get path() {
+    return this._url.pathname;
+  }
+  param(name) {
+    return this._params[name];
+  }
+  params() {
+    return { ...this._params };
+  }
+  query(name) {
+    if (!this._query) {
+      this._query = this._url.searchParams;
+    }
+    return this._query.get(name) ?? undefined;
+  }
+  queries() {
+    if (!this._query) {
+      this._query = this._url.searchParams;
+    }
+    const result = {};
+    for (const [key, value] of this._query.entries()) {
+      const existing = result[key];
+      if (existing === undefined) {
+        result[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    }
+    return result;
+  }
+  header(name) {
+    return this._request.headers.get(name) ?? undefined;
+  }
+  headers() {
+    if (!this._headers) {
+      this._headers = {};
+      for (const [key, value] of this._request.headers.entries()) {
+        this._headers[key] = value;
+      }
+    }
+    return { ...this._headers };
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  get raw() {
+    return this._request;
+  }
+}
+
+class FastContext {
+  _req = new FastRequestImpl;
+  _headers = new Headers;
+  reset(request, params = {}) {
+    this._req.reset(request, params);
+    this._headers = new Headers;
+    return this;
+  }
+  get req() {
+    return this._req;
+  }
+  json(data2, status = 200) {
+    this._headers.set("Content-Type", "application/json; charset=utf-8");
+    return new Response(JSON.stringify(data2), {
+      status,
+      headers: this._headers
+    });
+  }
+  text(text, status = 200) {
+    this._headers.set("Content-Type", "text/plain; charset=utf-8");
+    return new Response(text, {
+      status,
+      headers: this._headers
+    });
+  }
+  html(html, status = 200) {
+    this._headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(html, {
+      status,
+      headers: this._headers
+    });
+  }
+  redirect(url, status = 302) {
+    this._headers.set("Location", url);
+    return new Response(null, {
+      status,
+      headers: this._headers
+    });
+  }
+  body(data2, status = 200) {
+    return new Response(data2, {
+      status,
+      headers: this._headers
+    });
+  }
+  header(name, value) {
+    this._headers.set(name, value);
+  }
+  status(_code) {}
+}
+
+// ../core/src/engine/MinimalContext.ts
+class MinimalRequest {
+  _request;
+  _params;
+  _path;
+  constructor(_request, _params, _path) {
+    this._request = _request;
+    this._params = _params;
+    this._path = _path;
+  }
+  get url() {
+    return this._request.url;
+  }
+  get method() {
+    return this._request.method;
+  }
+  get path() {
+    return this._path;
+  }
+  param(name) {
+    return this._params[name];
+  }
+  params() {
+    return { ...this._params };
+  }
+  query(name) {
+    const url = new URL(this._request.url);
+    return url.searchParams.get(name) ?? undefined;
+  }
+  queries() {
+    const url = new URL(this._request.url);
+    const result = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      const existing = result[key];
+      if (existing === undefined) {
+        result[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    }
+    return result;
+  }
+  header(name) {
+    return this._request.headers.get(name) ?? undefined;
+  }
+  headers() {
+    const result = {};
+    for (const [key, value] of this._request.headers.entries()) {
+      result[key] = value;
+    }
+    return result;
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  get raw() {
+    return this._request;
+  }
+}
+
+class MinimalContext {
+  _req;
+  constructor(request, params, path4) {
+    this._req = new MinimalRequest(request, params, path4);
+  }
+  get req() {
+    return this._req;
+  }
+  json(data2, status = 200) {
+    return new Response(JSON.stringify(data2), {
+      status,
+      headers: { "Content-Type": "application/json; charset=utf-8" }
+    });
+  }
+  text(text, status = 200) {
+    return new Response(text, {
+      status,
+      headers: { "Content-Type": "text/plain; charset=utf-8" }
+    });
+  }
+  html(html, status = 200) {
+    return new Response(html, {
+      status,
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: { Location: url }
+    });
+  }
+  body(data2, status = 200) {
+    return new Response(data2, { status });
+  }
+  header(_name, _value) {
+    console.warn("MinimalContext.header() is a no-op. Use FastContext for custom headers.");
+  }
+  status(_code) {}
+  reset(_request, _params) {
+    throw new Error("MinimalContext does not support reset. Create a new instance instead.");
+  }
+}
+
+// ../core/src/engine/path.ts
+function extractPath(url) {
+  const protocolEnd = url.indexOf("://");
+  const searchStart = protocolEnd === -1 ? 0 : protocolEnd + 3;
+  const pathStart = url.indexOf("/", searchStart);
+  if (pathStart === -1) {
+    return "/";
+  }
+  const queryStart = url.indexOf("?", pathStart);
+  if (queryStart === -1) {
+    return url.slice(pathStart);
+  }
+  return url.slice(pathStart, queryStart);
+}
+
+// ../core/src/engine/pool.ts
+class ObjectPool {
+  pool = [];
+  factory;
+  reset;
+  maxSize;
+  constructor(factory, reset, maxSize = 256) {
+    this.factory = factory;
+    this.reset = reset;
+    this.maxSize = maxSize;
+  }
+  acquire() {
+    const obj = this.pool.pop();
+    if (obj !== undefined) {
+      return obj;
+    }
+    return this.factory();
+  }
+  release(obj) {
+    if (this.pool.length < this.maxSize) {
+      this.reset(obj);
+      this.pool.push(obj);
+    }
+  }
+  clear() {
+    this.pool = [];
+  }
+  get size() {
+    return this.pool.length;
+  }
+  get capacity() {
+    return this.maxSize;
+  }
+  prewarm(count) {
+    const targetSize = Math.min(count, this.maxSize);
+    while (this.pool.length < targetSize) {
+      const obj = this.factory();
+      this.reset(obj);
+      this.pool.push(obj);
+    }
+  }
+}
+
+// ../core/src/engine/Gravito.ts
+class Gravito {
+  router = new AOTRouter;
+  contextPool;
+  errorHandler;
+  notFoundHandler;
+  staticRoutes;
+  isPureStaticApp = true;
+  constructor(options = {}) {
+    const poolSize = options.poolSize ?? 256;
+    this.contextPool = new ObjectPool(() => new FastContext, (ctx) => ctx.reset(new Request("http://localhost")), poolSize);
+    this.contextPool.prewarm(Math.min(32, poolSize));
+    if (options.onError) {
+      this.errorHandler = options.onError;
+    }
+    if (options.onNotFound) {
+      this.notFoundHandler = options.onNotFound;
+    }
+    this.compileRoutes();
+  }
+  get(path4, ...handlers) {
+    return this.addRoute("get", path4, handlers);
+  }
+  post(path4, ...handlers) {
+    return this.addRoute("post", path4, handlers);
+  }
+  put(path4, ...handlers) {
+    return this.addRoute("put", path4, handlers);
+  }
+  delete(path4, ...handlers) {
+    return this.addRoute("delete", path4, handlers);
+  }
+  patch(path4, ...handlers) {
+    return this.addRoute("patch", path4, handlers);
+  }
+  options(path4, ...handlers) {
+    return this.addRoute("options", path4, handlers);
+  }
+  head(path4, ...handlers) {
+    return this.addRoute("head", path4, handlers);
+  }
+  all(path4, ...handlers) {
+    const methods = ["get", "post", "put", "delete", "patch", "options", "head"];
+    for (const method of methods) {
+      this.addRoute(method, path4, handlers);
+    }
+    return this;
+  }
+  use(pathOrMiddleware, ...middleware) {
+    this.isPureStaticApp = false;
+    if (typeof pathOrMiddleware === "string") {
+      this.router.usePattern(pathOrMiddleware, ...middleware);
+    } else {
+      this.router.use(pathOrMiddleware, ...middleware);
+    }
+    return this;
+  }
+  route(_path, _app) {
+    console.warn("route() method is not yet fully implemented");
+    return this;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  notFound(handler) {
+    this.notFoundHandler = handler;
+    return this;
+  }
+  fetch = (request) => {
+    const path4 = extractPath(request.url);
+    const method = request.method.toLowerCase();
+    const staticKey = `${method}:${path4}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      if (staticRoute.useMinimal) {
+        const ctx = new MinimalContext(request, {}, path4);
+        try {
+          const result = staticRoute.handler(ctx);
+          if (result instanceof Response) {
+            return result;
+          }
+          return result;
+        } catch (error) {
+          return this.handleErrorSync(error, request, path4);
+        }
+      }
+      return this.handleWithMiddleware(request, path4, staticRoute);
+    }
+    return this.handleDynamicRoute(request, method, path4);
+  };
+  async handleWithMiddleware(request, path4, route) {
+    const ctx = this.contextPool.acquire();
+    try {
+      ctx.reset(request, {});
+      const middleware = this.collectMiddlewareForPath(path4, route.middleware);
+      if (middleware.length === 0) {
+        return await route.handler(ctx);
+      }
+      return await this.executeMiddleware(ctx, middleware, route.handler);
+    } catch (error) {
+      return await this.handleError(error, ctx);
+    } finally {
+      this.contextPool.release(ctx);
+    }
+  }
+  handleDynamicRoute(request, method, path4) {
+    const match2 = this.router.match(method.toUpperCase(), path4);
+    if (!match2.handler) {
+      return this.handleNotFoundSync(request, path4);
+    }
+    const ctx = this.contextPool.acquire();
+    const execute = async () => {
+      try {
+        ctx.reset(request, match2.params);
+        if (match2.middleware.length === 0) {
+          return await match2.handler(ctx);
+        }
+        return await this.executeMiddleware(ctx, match2.middleware, match2.handler);
+      } catch (error) {
+        return await this.handleError(error, ctx);
+      } finally {
+        this.contextPool.release(ctx);
+      }
+    };
+    return execute();
+  }
+  handleErrorSync(error, request, path4) {
+    if (this.errorHandler) {
+      const ctx = new MinimalContext(request, {}, path4);
+      const result = this.errorHandler(error, ctx);
+      if (result instanceof Response) {
+        return result;
+      }
+      return result;
+    }
+    console.error("Unhandled error:", error);
+    return new Response(JSON.stringify({
+      error: "Internal Server Error",
+      message: error.message
+    }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  handleNotFoundSync(request, path4) {
+    if (this.notFoundHandler) {
+      const ctx = new MinimalContext(request, {}, path4);
+      const result = this.notFoundHandler(ctx);
+      if (result instanceof Response) {
+        return result;
+      }
+      return result;
+    }
+    return new Response(JSON.stringify({ error: "Not Found" }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  collectMiddlewareForPath(path4, routeMiddleware) {
+    if (this.router.globalMiddleware.length === 0 && this.router.pathMiddleware.size === 0) {
+      return routeMiddleware;
+    }
+    return this.router.collectMiddlewarePublic(path4, routeMiddleware);
+  }
+  compileRoutes() {
+    this.staticRoutes = this.router.staticRoutes;
+    const hasGlobalMiddleware = this.router.globalMiddleware.length > 0;
+    const hasPathMiddleware = this.router.pathMiddleware.size > 0;
+    this.isPureStaticApp = !hasGlobalMiddleware && !hasPathMiddleware;
+    for (const [_key, route] of this.staticRoutes) {
+      const analysis = analyzeHandler(route.handler);
+      const optimalType = getOptimalContextType(analysis);
+      route.useMinimal = this.isPureStaticApp && route.middleware.length === 0 && optimalType === "minimal";
+    }
+  }
+  addRoute(method, path4, handlers) {
+    if (handlers.length === 0) {
+      throw new Error(`No handler provided for ${method.toUpperCase()} ${path4}`);
+    }
+    const handler = handlers[handlers.length - 1];
+    const middleware = handlers.slice(0, -1);
+    this.router.add(method, path4, handler, middleware);
+    this.compileRoutes();
+    return this;
+  }
+  async executeMiddleware(ctx, middleware, handler) {
+    let index = 0;
+    const next = async () => {
+      if (index < middleware.length) {
+        const mw = middleware[index++];
+        return await mw(ctx, next);
+      }
+      return;
+    };
+    const result = await next();
+    if (result instanceof Response) {
+      return result;
+    }
+    return await handler(ctx);
+  }
+  async handleError(error, ctx) {
+    if (this.errorHandler) {
+      return await this.errorHandler(error, ctx);
+    }
+    console.error("Unhandled error:", error);
+    return ctx.json({
+      error: "Internal Server Error",
+      message: error.message
+    }, 500);
+  }
+}
 // ../core/src/index.ts
 var VERSION = package_default.version;
 
@@ -88993,6 +89858,11 @@ async function initCommand(options = {}) {
           label: "\uD83C\uDFDB\uFE0F Domain-Driven Design (DDD)",
           hint: "\u5B8C\u6574\u7684 DDD \u67B6\u69CB\uFF0C\u5305\u542B Modules\u3001Bounded Contexts"
         },
+        {
+          value: "standalone-engine",
+          label: "\uD83D\uDE80 Standalone Engine",
+          hint: "\u7D14\u6DE8\u7684\u9AD8\u6027\u80FD\u5F15\u64CE\uFF0C\u7121\u6846\u67B6\u4F9D\u8CF4 (Pure High-Performance Engine)"
+        },
         {
           value: "action-domain",
           label: "\u26A1 Action-Domain-Responder (ADR)",
@@ -89106,7 +89976,8 @@ async function initCommand(options = {}) {
       clean: "\uD83E\uDDC5 Clean Architecture",
       ddd: "\uD83C\uDFDB\uFE0F Domain-Driven Design",
       satellite: "\uD83D\uDEF0\uFE0F Satellite Service",
-      "action-domain": "\u26A1 Action-Domain-Responder"
+      "action-domain": "\u26A1 Action-Domain-Responder",
+      "standalone-engine": "\uD83D\uDE80 Standalone Engine"
     };
     note2(`\u5C08\u6848\u540D\u7A31: ${pc3.cyan(projectName)}
 \u67B6\u69CB\u6A21\u5F0F: ${pc3.green(archLabels[architecture])}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravito/pulse",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "The official CLI for Gravito Galaxy Architecture. Scaffold projects and manage your universe.",
   "bin": {
     "gravito": "bin/gravito.mjs"