silgi 0.33.1 → 0.34.0

package/dist/core/index.mjs

@@ -1,15 +1,15 @@
 import { createConsola } from 'consola';
 import { defu } from 'defu';
 import { createHooks } from 'hookable';
-import { c as createRouteRules } from '../_chunks/routeRules.mjs';
+import { createRouter, addRoute, findRoute } from 'rou3';
 import { getContext } from 'unctx';
 import { Buffer } from 'node:buffer';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig } from 'silgi/runtime';
 import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
+import { FastURL, FastResponse } from 'srvx';
 import { isRuntimePresents } from 'silgi/kit';
 export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
-import 'ufo';
 
 const silgiCtx = getContext("silgi");
 function useSilgi() {
@@ -35,387 +35,133 @@ function tryUseSilgi() {
   return silgiCtx.tryUse();
 }
 
-var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
-  HttpStatus2[HttpStatus2["CONTINUE"] = 100] = "CONTINUE";
-  HttpStatus2[HttpStatus2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
-  HttpStatus2[HttpStatus2["PROCESSING"] = 102] = "PROCESSING";
-  HttpStatus2[HttpStatus2["EARLY_HINTS"] = 103] = "EARLY_HINTS";
-  HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
-  HttpStatus2[HttpStatus2["CREATED"] = 201] = "CREATED";
-  HttpStatus2[HttpStatus2["ACCEPTED"] = 202] = "ACCEPTED";
-  HttpStatus2[HttpStatus2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
-  HttpStatus2[HttpStatus2["NO_CONTENT"] = 204] = "NO_CONTENT";
-  HttpStatus2[HttpStatus2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
-  HttpStatus2[HttpStatus2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
-  HttpStatus2[HttpStatus2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
-  HttpStatus2[HttpStatus2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
-  HttpStatus2[HttpStatus2["IM_USED"] = 226] = "IM_USED";
-  HttpStatus2[HttpStatus2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
-  HttpStatus2[HttpStatus2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
-  HttpStatus2[HttpStatus2["FOUND"] = 302] = "FOUND";
-  HttpStatus2[HttpStatus2["SEE_OTHER"] = 303] = "SEE_OTHER";
-  HttpStatus2[HttpStatus2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
-  HttpStatus2[HttpStatus2["USE_PROXY"] = 305] = "USE_PROXY";
-  HttpStatus2[HttpStatus2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
-  HttpStatus2[HttpStatus2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
-  HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-  HttpStatus2[HttpStatus2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
-  HttpStatus2[HttpStatus2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
-  HttpStatus2[HttpStatus2["FORBIDDEN"] = 403] = "FORBIDDEN";
-  HttpStatus2[HttpStatus2["NOT_FOUND"] = 404] = "NOT_FOUND";
-  HttpStatus2[HttpStatus2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
-  HttpStatus2[HttpStatus2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
-  HttpStatus2[HttpStatus2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
-  HttpStatus2[HttpStatus2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
-  HttpStatus2[HttpStatus2["CONFLICT"] = 409] = "CONFLICT";
-  HttpStatus2[HttpStatus2["GONE"] = 410] = "GONE";
-  HttpStatus2[HttpStatus2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
-  HttpStatus2[HttpStatus2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
-  HttpStatus2[HttpStatus2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
-  HttpStatus2[HttpStatus2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
-  HttpStatus2[HttpStatus2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
-  HttpStatus2[HttpStatus2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
-  HttpStatus2[HttpStatus2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
-  HttpStatus2[HttpStatus2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
-  HttpStatus2[HttpStatus2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
-  HttpStatus2[HttpStatus2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
-  HttpStatus2[HttpStatus2["LOCKED"] = 423] = "LOCKED";
-  HttpStatus2[HttpStatus2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
-  HttpStatus2[HttpStatus2["TOO_EARLY"] = 425] = "TOO_EARLY";
-  HttpStatus2[HttpStatus2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
-  HttpStatus2[HttpStatus2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
-  HttpStatus2[HttpStatus2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-  HttpStatus2[HttpStatus2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
-  HttpStatus2[HttpStatus2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
-  HttpStatus2[HttpStatus2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
-  HttpStatus2[HttpStatus2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
-  HttpStatus2[HttpStatus2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
-  HttpStatus2[HttpStatus2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-  HttpStatus2[HttpStatus2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
-  HttpStatus2[HttpStatus2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
-  HttpStatus2[HttpStatus2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
-  HttpStatus2[HttpStatus2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
-  HttpStatus2[HttpStatus2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
-  HttpStatus2[HttpStatus2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
-  HttpStatus2[HttpStatus2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
-  return HttpStatus2;
-})(HttpStatus || {});
-var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
-  ErrorSeverity2["DEBUG"] = "DEBUG";
-  ErrorSeverity2["INFO"] = "INFO";
-  ErrorSeverity2["WARNING"] = "WARNING";
-  ErrorSeverity2["ERROR"] = "ERROR";
-  ErrorSeverity2["CRITICAL"] = "CRITICAL";
-  return ErrorSeverity2;
-})(ErrorSeverity || {});
-var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
-  ErrorCategory2["AUTHENTICATION"] = "auth";
-  ErrorCategory2["AUTHORIZATION"] = "authorization";
-  ErrorCategory2["VALIDATION"] = "validation";
-  ErrorCategory2["BUSINESS"] = "business";
-  ErrorCategory2["INFRASTRUCTURE"] = "infrastructure";
-  ErrorCategory2["EXTERNAL"] = "external";
-  ErrorCategory2["UNKNOWN"] = "unknown";
-  return ErrorCategory2;
-})(ErrorCategory || {});
-class ErrorFactory {
-  static createMetadata(metadata) {
-    return {
-      timestamp: Date.now(),
-      ...metadata
-    };
+const EmptyObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+
+function hasProp(obj, prop) {
+  try {
+    return prop in obj;
+  } catch {
+    return false;
   }
-  static create(options) {
-    return new SilgiError({
-      code: options.code ?? options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
-      message: options.message,
-      category: options.category ?? "unknown" /* UNKNOWN */,
-      severity: options.severity ?? "ERROR" /* ERROR */,
-      httpStatus: options.httpStatus ?? 500 /* INTERNAL_SERVER_ERROR */,
-      metadata: this.createMetadata(options.metadata),
-      cause: options.cause,
-      context: options.context
-    });
+}
+function isJSONSerializable(value, _type) {
+  if (value === null || value === void 0) {
+    return true;
   }
-  // Predefined error creators
-  static authenticationError(message, context) {
-    return this.create({
-      message,
-      code: 401,
-      category: "auth" /* AUTHENTICATION */,
-      severity: "ERROR" /* ERROR */,
-      httpStatus: 401 /* UNAUTHORIZED */,
-      context
-    });
+  if (_type !== "object") {
+    return _type === "boolean" || _type === "number" || _type === "string";
   }
-  static authorizationError(message, context) {
-    return this.create({
-      message,
-      code: 403,
-      category: "authorization" /* AUTHORIZATION */,
-      severity: "ERROR" /* ERROR */,
-      httpStatus: 403 /* FORBIDDEN */,
-      context
-    });
+  if (typeof value.toJSON === "function") {
+    return true;
   }
-  static validationError(message, context) {
-    return this.create({
-      message,
-      code: 400,
-      category: "validation" /* VALIDATION */,
-      severity: "WARNING" /* WARNING */,
-      httpStatus: 400 /* BAD_REQUEST */,
-      context
-    });
+  if (Array.isArray(value)) {
+    return true;
   }
-  static notFoundError(message, context) {
-    return this.create({
-      message,
-      code: 404,
-      category: "business" /* BUSINESS */,
-      severity: "WARNING" /* WARNING */,
-      httpStatus: 404 /* NOT_FOUND */,
-      context
-    });
+  if (typeof value.pipe === "function" || typeof value.pipeTo === "function") {
+    return false;
   }
-  static internalError(message, cause) {
-    return this.create({
-      message,
-      code: 500,
-      category: "infrastructure" /* INFRASTRUCTURE */,
-      severity: "CRITICAL" /* CRITICAL */,
-      httpStatus: 500 /* INTERNAL_SERVER_ERROR */,
-      cause
-    });
+  if (value instanceof EmptyObject) {
+    return true;
   }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
 }
+
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+  if (!statusCode) {
+    return defaultStatusCode;
+  }
+  if (typeof statusCode === "string") {
+    statusCode = Number.parseInt(statusCode, 10);
+  }
+  if (statusCode < 100 || statusCode > 999) {
+    return defaultStatusCode;
+  }
+  return statusCode;
+}
+
 class SilgiError extends Error {
-  code;
-  category;
-  severity;
-  httpStatus;
-  metadata;
-  context;
+  static __silgi_error__ = true;
+  statusCode = 500;
+  fatal = false;
+  unhandled = false;
+  statusMessage;
+  data;
   cause;
-  constructor(error) {
-    super(error.message);
-    this.name = "SilgiError";
-    this.code = error.code;
-    this.category = error.category;
-    this.severity = error.severity;
-    this.httpStatus = error.httpStatus;
-    this.metadata = error.metadata ?? { timestamp: Date.now() };
-    this.context = error.context;
-    this.cause = error.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  toString() {
-    let str = `${this.name} [${this.code}] ${this.severity}: ${this.message}`;
-    str += `
-Category: ${this.category}`;
-    str += `
-HTTP Status: ${this.httpStatus}`;
-    if (this.context) {
-      str += `
-Context: ${JSON.stringify(this.context, null, 2)}`;
-    }
-    if (this.metadata) {
-      str += `
-Metadata: ${JSON.stringify(this.metadata, null, 2)}`;
-    }
-    if (this.stack) {
-      str += `
-${this.stack}`;
+  constructor(message, opts = {}) {
+    super(message, opts);
+    if (opts.cause && !this.cause) {
+      this.cause = opts.cause;
     }
-    return str;
   }
   toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
+    const obj = {
       message: this.message,
-      category: this.category,
-      severity: this.severity,
-      httpStatus: this.httpStatus,
-      metadata: this.metadata,
-      context: this.context,
-      stack: this.stack
+      statusCode: sanitizeStatusCode(this.statusCode, 500)
     };
-  }
-  static isError(error) {
-    return error instanceof SilgiError || typeof error === "object" && error !== null && "name" in error && error.name === "SilgiError";
-  }
-  static from(error) {
-    if (error instanceof SilgiError) {
-      return error;
+    if (this.statusMessage) {
+      obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
     }
-    return ErrorFactory.internalError(
-      error instanceof Error ? error.message : String(error),
-      error instanceof Error ? error : void 0
-    );
+    if (this.data !== void 0) {
+      obj.data = this.data;
+    }
+    return obj;
   }
 }
-function isBaseError(error) {
-  return typeof error === "object" && error !== null && "code" in error && "message" in error && "category" in error && "severity" in error && "httpStatus" in error;
-}
-
-function parseURI(uri, uris) {
-  if (!uri) {
-    throw ErrorFactory.create({
-      message: "URI cannot be empty",
-      httpStatus: HttpStatus.BAD_REQUEST,
-      context: { uri }
-    });
-  }
-  if (!uris) {
-    throw ErrorFactory.create({
-      message: "URIs configuration is not provided",
-      httpStatus: HttpStatus.INTERNAL_SERVER_ERROR,
-      context: { uri }
-    });
+function createError(input) {
+  if (typeof input === "string") {
+    return new SilgiError(input);
   }
-  const cleanUri = uri.replace(/^\/*(srn\/)?/, "").replace(/\/*$/, "");
-  const [path, queryString] = cleanUri.split("?");
-  const parts = path.split("/");
-  const query = queryString ? Object.fromEntries(
-    queryString.split("&").map((param) => param.split("="))
-  ) : void 0;
-  const method = query?.method ? query?.method.toLowerCase() : void 0;
-  const namespaceName = parts[0];
-  const serviceName = parts[1];
-  const methodName = method || parts[2];
-  const actionName = method ? parts[2] : parts[3];
-  if (!namespaceName || !serviceName || !methodName || !actionName) {
-    throw ErrorFactory.create({
-      message: "Invalid URI format: Insufficient path segments",
-      httpStatus: HttpStatus.BAD_REQUEST,
-      context: {
-        uri,
-        cleanUri,
-        partsLength: parts.length,
-        method,
-        namespaceName,
-        serviceName,
-        methodName,
-        actionName
-      }
-    });
-  }
-  const baseUri = `${namespaceName}/${serviceName}/${methodName}/${actionName}`;
-  const paramStartIndex = method ? 3 : 4;
-  const parameters = parts.slice(paramStartIndex);
-  const normalizedUri = method ? `${namespaceName}/${serviceName}/${method}/${actionName}${parameters.length ? `/${parameters.join("/")}` : ""}` : cleanUri;
-  const template = uris[baseUri];
-  if (template === void 0) {
-    throw ErrorFactory.create({
-      message: "No route found for URI",
-      httpStatus: HttpStatus.NOT_FOUND,
-      context: {
-        uri,
-        baseUri
-      }
-    });
-  }
-  if (template === "") {
-    if (parameters.length > 0) {
-      throw ErrorFactory.create({
-        message: "No parameters expected for this route",
-        httpStatus: HttpStatus.BAD_REQUEST,
-        context: {
-          uri,
-          baseUri,
-          extraParams: parameters
+  const cause = input.cause;
+  const err = new SilgiError(input.message ?? input.statusMessage ?? "", {
+    cause: cause || input
+  });
+  if (hasProp(input, "stack")) {
+    try {
+      Object.defineProperty(err, "stack", {
+        get() {
+          return input.stack;
         }
       });
-    }
-    if (query && query.method) {
-      delete query.method;
-    }
-    return {
-      namespaceName,
-      serviceName,
-      methodName,
-      actionName,
-      raw: normalizedUri,
-      parts: [namespaceName, serviceName, methodName, actionName],
-      routerParams: {},
-      query,
-      uri: baseUri
-    };
-  }
-  const routeTemplate = typeof template === "string" ? template : template.pattern;
-  const validators = typeof template === "string" ? void 0 : template.validators;
-  const routerParams = {};
-  const templateParts = routeTemplate.split("/").filter(Boolean);
-  const paramValues = parameters;
-  let valueIndex = 0;
-  templateParts.forEach((part) => {
-    if (part.startsWith(":")) {
-      const paramName = part.substring(1);
-      const paramValue = paramValues[valueIndex];
-      if (validators?.[paramName] && paramValue) {
-        if (!validators[paramName](paramValue)) {
-          throw ErrorFactory.create({
-            message: "Invalid value for parameter",
-            httpStatus: HttpStatus.UNPROCESSABLE_ENTITY,
-            context: {
-              uri,
-              paramName,
-              paramValue,
-              validatorName: paramName
-            }
-          });
-        }
+    } catch {
+      try {
+        err.stack = input.stack;
+      } catch {
       }
-      routerParams[paramName] = paramValue || void 0;
-      valueIndex++;
-    } else if (part && part === paramValues[valueIndex]) {
-      valueIndex++;
-    }
-  });
-  return {
-    namespaceName,
-    serviceName,
-    methodName,
-    actionName,
-    raw: normalizedUri,
-    parts: [namespaceName, serviceName, methodName, actionName],
-    routerParams,
-    query: method ? void 0 : query,
-    uri: baseUri
-  };
-}
-
-async function findAction(silgi, uri) {
-  const { parts } = parseURI(uri, silgi.uris);
-  let result = silgi.services;
-  for (const part of parts) {
-    if (result && Object.prototype.hasOwnProperty.call(result, part)) {
-      result = Object.assign({}, result[part]);
-    } else {
-      silgi.logger.fail("Action not found:", `${parts.join("/")}`);
-      continue;
     }
   }
-  return result;
-}
-async function scanAction(silgi) {
-  for (const [key, _value] of Object.entries(silgi.uris)) {
-    const segments = key.split("/").filter(Boolean);
-    if (segments.length !== 4) {
-      console.error(`Invalid URI format for key "${key}". URI must have exactly 4 segments in format: namespace/service/method/action`);
-      continue;
-    }
-    const [namespace, service, method, action] = segments;
-    if (!namespace || !service || !method || !action) {
-      console.error(`Invalid URI segments for key "${key}". All segments must be non-empty`);
-      continue;
-    }
-    const handler = await findAction(silgi, key);
-    silgi.scannedHandlers.set(key, handler);
+  if (input.data) {
+    err.data = input.data;
+  }
+  const statusCode = input.statusCode ?? input.status ?? cause?.statusCode ?? cause?.status;
+  if (typeof statusCode === "number") {
+    err.statusCode = sanitizeStatusCode(statusCode);
   }
+  const statusMessage = input.statusMessage ?? input.statusText ?? cause?.statusMessage ?? cause?.statusText;
+  if (statusMessage) {
+    err.statusMessage = sanitizeStatusMessage(statusMessage);
+  }
+  const fatal = input.fatal ?? cause?.fatal;
+  if (fatal !== void 0) {
+    err.fatal = fatal;
+  }
+  const unhandled = input.unhandled ?? cause?.unhandled;
+  if (unhandled !== void 0) {
+    err.unhandled = unhandled;
+  }
+  return err;
+}
+function isError(input) {
+  return input?.constructor?.__silgi_error__ === true;
 }
 
 function replaceRuntimeValues(obj, runtime) {
@@ -463,7 +209,7 @@ function useSilgiStorage(base = "/memory:cache") {
 }
 async function generateStorageKey(params) {
   const {
-    operation,
+    url,
     input,
     keyGenerator,
     requestId,
@@ -473,18 +219,16 @@ async function generateStorageKey(params) {
   const parts = [
     cacheScopePrefix,
     // Always include scope prefix first
-    operation.namespaceName,
-    operation.serviceName,
-    operation.methodName
+    url.raw
   ].filter(Boolean);
   if (storageOptions?.scope === "request") {
     if (!requestId) {
-      throw ErrorFactory.create({
-        code: HttpStatus.BAD_REQUEST,
-        message: "Request ID is required for request-scoped cache",
-        context: {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Request ID is required for request-scoped cache",
+        data: {
           requestId,
-          operation,
+          url,
           input,
           storageOptions,
           keyGenerator
@@ -515,12 +259,11 @@ async function runSilgiPlugins(silgi) {
 async function createSilgi(config) {
   const hooks = createHooks();
   const silgi = {
-    schemas: config.schemas,
+    router: void 0,
+    routerPrefixs: [],
+    schemas: config.schemas ?? {},
     services: config.services ?? {},
     shared: config.shared ?? void 0,
-    uris: config.uris ?? {},
-    modulesURIs: config.modulesURIs ?? {},
-    scannedHandlers: /* @__PURE__ */ new Map(),
     plugins: config.plugins ?? [],
     framework: config.framework ?? void 0,
     storage: config.options.putStorage ?? void 0,
@@ -538,15 +281,40 @@ async function createSilgi(config) {
       tag: "silgi"
     })).withTag("silgi"),
     captureError: config.captureError ?? (() => {
-    }),
-    routeRules: void 0
+    })
   };
-  const routeRules = createRouteRules();
-  routeRules.importRules(config.options.routeRules ?? {});
-  silgi.routeRules = routeRules;
+  if (!silgi.router) {
+    silgi.router = createRouter();
+  }
+  for (const route in silgi.services) {
+    const routeParts = route.split("/").filter(Boolean);
+    if (routeParts.length > 0) {
+      const prefix = `/${routeParts[0]}`;
+      if (!silgi.routerPrefixs.includes(prefix)) {
+        silgi.routerPrefixs.push(prefix);
+      }
+    }
+    const methods = silgi.services[route];
+    for (const method in methods) {
+      const methodObject = methods[method];
+      if (methodObject) {
+        const _method = (method || "").toUpperCase();
+        const schemaWrapper = silgi.schemas?.[route]?.[method];
+        if (!schemaWrapper) {
+          silgi.logger.warn(`Schema not found for ${route}`);
+          continue;
+        }
+        addRoute(silgi.router, _method, route, {
+          method: _method,
+          route,
+          setup: methodObject,
+          schema: schemaWrapper
+        });
+      }
+    }
+  }
   silgi.hooks.addHooks(silgi.options.hooks);
   await runSilgiPlugins(silgi);
-  await scanAction(silgi);
   if (!silgi.storage) {
     silgi.storage = await createStorage(silgi);
   }
@@ -569,79 +337,275 @@ async function createSilgi(config) {
   return silgi;
 }
 
-function silgi(event) {
+class _SilgiEvent {
+  static __is_event__ = true;
+  req;
+  url;
+  context;
+  _res;
+  constructor(req, context) {
+    this.context = context || new EmptyObject();
+    this.req = req;
+    const _url = req._url;
+    this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+  }
+  get res() {
+    if (!this._res) {
+      this._res = new SilgiEventResponse();
+    }
+    return this._res;
+  }
+  toString() {
+    return `[${this.req.method}] ${this.req.url}`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+}
+class SilgiEventResponse {
+  status;
+  // statusText?: string;
+  _headers;
+  get headers() {
+    if (!this._headers) {
+      this._headers = new Headers();
+    }
+    return this._headers;
+  }
+}
+
+async function parseRequestInput(req) {
+  const contentType = req.headers.get("content-type") || "";
+  if (contentType.startsWith("application/json")) {
+    const text = await req.text();
+    if (!text)
+      return void 0;
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("text/")) {
+    return await req.text();
+  }
+  if (contentType.startsWith("application/octet-stream")) {
+    return new File([await req.arrayBuffer()], "uploaded.bin", { type: contentType });
+  }
+  return await req.text();
+}
+function wrapBodyAndContentType(options) {
+  let { body, headers } = options;
+  const setContentType = (type) => {
+    if (!headers)
+      headers = {};
+    if (headers instanceof Headers) {
+      if (!headers.has("Content-Type"))
+        headers.set("Content-Type", type);
+    } else if (Array.isArray(headers)) {
+      if (!headers.some(([k]) => k.toLowerCase() === "content-type")) {
+        headers.push(["Content-Type", type]);
+      }
+    } else {
+      if (!("content-type" in headers)) {
+        headers["Content-Type"] = type;
+      }
+    }
+  };
+  if (typeof File !== "undefined" && body instanceof File) {
+    body = new Blob([body], { type: body.type });
+    setContentType(body.type || "application/octet-stream");
+  } else if (body instanceof Blob) {
+    setContentType(body.type || "application/octet-stream");
+  } else if (body && typeof body === "object") {
+    body = new Blob([JSON.stringify(body)], { type: "application/json" });
+    setContentType("application/json");
+  } else if (typeof body === "string") {
+    body = new Blob([body], { type: "text/plain" });
+    setContentType("text/plain");
+  }
+  return { body, headers };
+}
+
+const plusRegex = /\+/g;
+function parseQuery(input) {
+  const params = new EmptyObject();
+  if (!input || input === "?") {
+    return params;
+  }
+  const inputLength = input.length;
+  let key = "";
+  let value = "";
+  let startingIndex = -1;
+  let equalityIndex = -1;
+  let shouldDecodeKey = false;
+  let shouldDecodeValue = false;
+  let keyHasPlus = false;
+  let valueHasPlus = false;
+  let hasBothKeyValuePair = false;
+  let c = 0;
+  for (let i = 0; i < inputLength + 1; i++) {
+    c = i === inputLength ? 38 : input.charCodeAt(i);
+    switch (c) {
+      case 38: {
+        hasBothKeyValuePair = equalityIndex > startingIndex;
+        if (!hasBothKeyValuePair) {
+          equalityIndex = i;
+        }
+        key = input.slice(startingIndex + 1, equalityIndex);
+        if (hasBothKeyValuePair || key.length > 0) {
+          if (keyHasPlus) {
+            key = key.replace(plusRegex, " ");
+          }
+          if (shouldDecodeKey) {
+            try {
+              key = decodeURIComponent(key);
+            } catch {
+            }
+          }
+          if (hasBothKeyValuePair) {
+            value = input.slice(equalityIndex + 1, i);
+            if (valueHasPlus) {
+              value = value.replace(plusRegex, " ");
+            }
+            if (shouldDecodeValue) {
+              try {
+                value = decodeURIComponent(value);
+              } catch {
+              }
+            }
+          }
+          const currentValue = params[key];
+          if (currentValue === void 0) {
+            params[key] = value;
+          } else {
+            if (Array.isArray(currentValue)) {
+              currentValue.push(value);
+            } else {
+              params[key] = [currentValue, value];
+            }
+          }
+        }
+        value = "";
+        startingIndex = i;
+        equalityIndex = i;
+        shouldDecodeKey = false;
+        shouldDecodeValue = false;
+        keyHasPlus = false;
+        valueHasPlus = false;
+        break;
+      }
+      case 61: {
+        if (equalityIndex <= startingIndex) {
+          equalityIndex = i;
+        } else {
+          shouldDecodeValue = true;
+        }
+        break;
+      }
+      case 43: {
+        if (equalityIndex > startingIndex) {
+          valueHasPlus = true;
+        } else {
+          keyHasPlus = true;
+        }
+        break;
+      }
+      case 37: {
+        if (equalityIndex > startingIndex) {
+          shouldDecodeValue = true;
+        } else {
+          shouldDecodeKey = true;
+        }
+        break;
+      }
+    }
+  }
+  return params;
+}
+
+function getQuery(event) {
+  return parseQuery(event.url.search.slice(1));
+}
+function getRouterParams(event, opts = {}) {
+  let params = event.context.params || {};
+  if (opts.decode) {
+    params = { ...params };
+    for (const key in params) {
+      params[key] = decodeURIComponent(params[key]);
+    }
+  }
+  return params;
+}
+
+function createRoute(params) {
   return {
-    execute: (uriString, input, source, queryParams) => {
-      return execute(uriString, input, event, source, queryParams);
+    [params.route]: {
+      ...params
     }
   };
 }
-async function execute(uriString, input, event, source, queryParams) {
-  const silgiCtx = useSilgi();
-  const config = {
-    returnNull: false
+function getUrlPrefix(path, method) {
+  const parse = path.includes("://") ? new FastURL(path) : new URL(path, "http://localhost");
+  const cleanedPath = parse.pathname + parse.search + parse.hash;
+  const segments = cleanedPath.split("/").filter(Boolean);
+  if (segments.length < 2) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid URL format",
+      data: { cleanedPath }
+    });
+  }
+  const prefix = `/${segments[0]}`;
+  const namespace = segments[1];
+  return {
+    namespaceName: namespace,
+    prefixName: prefix,
+    raw: path,
+    path: cleanedPath,
+    methodName: method || "GET"
   };
+}
+
+async function orchestrate(route, event) {
+  const input = await parseRequestInput(event.req);
+  const silgiCtx = useSilgi();
+  const silgiURL = getUrlPrefix(route.route, event.req.method);
   try {
-    const operation = parseURI(uriString, silgiCtx.uris);
-    if (!operation) {
-      throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
-    }
+    const routerParams = getRouterParams(event);
+    const queryParams = getQuery(event);
     let success = false;
     let cached = false;
     let result;
-    const handler = silgiCtx.scannedHandlers.get(operation.uri);
-    if (!handler) {
-      throw ErrorFactory.create({
-        message: "execute not found",
-        httpStatus: HttpStatus.NOT_FOUND,
-        context: {
-          uri: uriString
-        }
-      });
-    }
-    await silgiCtx.callHook("execute:before", {
-      operation,
-      input,
-      event,
-      modules: handler.modules,
-      source,
-      config
-    });
-    if (config.returnNull) {
-      return result;
-    }
-    const cacheData = await cacheExecute(input, operation, handler, event);
+    const setup = route.setup;
+    const cacheData = await cacheExecute(input, route, silgiURL, event);
     if (cacheData?.success) {
       result = cacheData.data;
       success = cacheData.success;
       cached = cacheData.cached;
     } else {
-      let parameters = defu(operation.routerParams, operation.query) || {};
-      if (queryParams) {
-        parameters = defu(queryParams, parameters);
-      }
-      silgiCtx.shared.silgi = silgi(event);
-      result = await handler?.handler(
-        defu(input, { parameters }),
+      silgiCtx.shared.$fetch = silgiFetch;
+      result = await setup?.handler(
+        {
+          args: input,
+          parameters: {
+            query: queryParams,
+            path: routerParams
+          }
+        },
         silgiCtx.shared,
         event,
-        source
+        event.context.source
       );
       success = true;
     }
     await silgiCtx.callHook("execute:after", {
-      operation,
+      url: silgiURL,
       input,
       event,
       result,
       success,
-      source,
-      modules: handler.modules,
-      config
+      modules: setup.modules
     });
     if (!cached) {
-      if (success && cacheData?.cachedKey && handler.storage) {
-        await useSilgiStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
+      if (success && cacheData?.cachedKey && setup.storage) {
+        await useSilgiStorage(setup.storage.base).setItem(cacheData.cachedKey, result, setup.storage.options);
       }
     }
     return result;
@@ -649,30 +613,38 @@ async function execute(uriString, input, event, source, queryParams) {
     await silgiCtx.callHook("execute:error", {
       input,
       event,
-      source,
       error: err instanceof Error ? err : new Error(String(err)),
-      timestamp: Date.now(),
-      config
-    });
-    silgiCtx.captureError(silgiCtx, SilgiError.from(err), {
-      event,
-      tags: ["execute"]
+      url: silgiURL
     });
+    silgiCtx.captureError(
+      silgiCtx,
+      createError({
+        message: err instanceof Error ? err.message : String(err),
+        statusCode: 500,
+        statusMessage: "Internal Server Error",
+        cause: err
+      }),
+      {
+        event,
+        tags: ["execute"]
+      }
+    );
     throw err;
   }
 }
-async function cacheExecute(input, operation, handler, event) {
-  if (!handler.storage)
+async function cacheExecute(input, route, silgiURL, event) {
+  const setup = route.setup;
+  if (!setup.storage)
     return;
-  const cacheKey = handler.storage ? await generateStorageKey({
-    operation,
+  const cacheKey = setup.storage ? await generateStorageKey({
+    url: silgiURL,
     input,
-    keyGenerator: handler.storage.key,
-    storageOptions: handler.storage,
+    keyGenerator: setup.storage.key,
+    storageOptions: setup.storage,
     requestId: event?.requestId
   }) : null;
   if (cacheKey) {
-    const cachedResult = await useSilgiStorage(handler.storage.base).getItem(cacheKey);
+    const cachedResult = await useSilgiStorage(setup.storage.base).getItem(cacheKey);
     if (cachedResult !== null) {
       return {
         success: true,
@@ -690,32 +662,235 @@ async function cacheExecute(input, operation, handler, event) {
   };
 }
 
-function merge(items, maxLevel = 4, currentLevel = 1) {
-  const arrayItems = Array.isArray(items) ? items : [items];
-  return arrayItems.reduce((acc, item) => {
-    if (!item)
-      return acc;
-    Object.keys(item).forEach((key) => {
-      if (typeof item[key] === "object" && item[key] !== null && currentLevel < maxLevel) {
-        if (!acc[key] || typeof acc[key] !== "object") {
-          acc[key] = {};
-        }
-        acc[key] = merge([acc[key], item[key]], maxLevel, currentLevel + 1);
-      } else if (acc[key] === void 0) {
-        acc[key] = item[key];
-      }
+const kNotFound = /* @__PURE__ */ Symbol.for("silgi.notFound");
+const kHandled = /* @__PURE__ */ Symbol.for("silgi.handled");
+function handleResponse(val, event, config) {
+  if (val && val instanceof Promise) {
+    return val.catch((error) => error).then((resolvedVal) => handleResponse(resolvedVal, event, config));
+  }
+  const response = prepareResponse(val, event, config);
+  if (response instanceof Promise) {
+    return handleResponse(response, event, config);
+  }
+  const { onBeforeResponse } = config;
+  return onBeforeResponse ? Promise.resolve(onBeforeResponse(event, response)).then(() => response) : response;
+}
+function prepareResponse(val, event, config, nested) {
+  if (val === kHandled) {
+    return new FastResponse(null);
+  }
+  if (val === kNotFound) {
+    val = createError({
+      statusCode: 404,
+      statusMessage: `Cannot find any route matching [${event.req.method}] ${event.url}`
     });
-    return acc;
-  }, {});
+  }
+  if (val && val instanceof Error) {
+    const error = createError(val);
+    const { onError } = config;
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+  }
+  const eventHeaders = event.res._headers;
+  if (!(val instanceof Response)) {
+    const res = prepareResponseBody(val, event, config);
+    const status = event.res.status;
+    return new FastResponse(
+      nullBody(event.req.method, status) ? null : res.body,
+      {
+        status,
+        statusText: event.res.statusText,
+        headers: res.headers && eventHeaders ? mergeHeaders(res.headers, eventHeaders) : res.headers || eventHeaders
+      }
+    );
+  }
+  if (!eventHeaders) {
+    return val;
+  }
+  return new FastResponse(
+    nullBody(event.req.method, val.status) ? null : val.body,
+    {
+      status: val.status,
+      statusText: val.statusText,
+      headers: mergeHeaders(eventHeaders, val.headers)
+    }
+  );
+}
+function nullBody(method, status) {
+  return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function mergeHeaders(base, merge) {
+  const mergedHeaders = new Headers(base);
+  for (const [name, value] of merge) {
+    if (name === "set-cookie") {
+      mergedHeaders.append(name, value);
+    } else {
+      mergedHeaders.set(name, value);
+    }
+  }
+  return mergedHeaders;
+}
+const emptyHeaders = new Headers({ "content-length": "0" });
+const jsonHeaders = new Headers({
+  "content-type": "application/json;charset=UTF-8"
+});
+function prepareResponseBody(val, event, config) {
+  if (val === null || val === void 0) {
+    return { body: "", headers: emptyHeaders };
+  }
+  const valType = typeof val;
+  if (valType === "string") {
+    return { body: val };
+  }
+  if (val instanceof Uint8Array) {
+    event.res.headers.set("content-length", val.byteLength.toString());
+    return { body: val };
+  }
+  if (isJSONSerializable(val, valType)) {
+    return {
+      body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+      headers: jsonHeaders
+    };
+  }
+  if (valType === "bigint") {
+    return { body: val.toString(), headers: jsonHeaders };
+  }
+  if (val instanceof Blob) {
+    const headers = {
+      "content-type": val.type,
+      "content-length": val.size.toString()
+    };
+    if ("name" in val) {
+      const filename = encodeURIComponent(val.name);
+      headers["content-disposition"] = `filename="${filename}"; filename*=UTF-8''${filename}`;
+    }
+    return { body: val.stream(), headers };
+  }
+  if (valType === "symbol") {
+    return { body: val.toString() };
+  }
+  if (valType === "function") {
+    return { body: `${val.name}()` };
+  }
+  return { body: val };
+}
+function errorResponse(error, debug) {
+  return new FastResponse(
+    JSON.stringify(
+      {
+        statusCode: error.statusCode,
+        statusMessage: error.statusMessage,
+        data: error.data,
+        stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+      },
+      null,
+      2
+    ),
+    {
+      status: error.statusCode,
+      statusText: error.statusMessage,
+      headers: {
+        "content-type": "application/json; charset=utf-8"
+      }
+    }
+  );
+}
+
+function getHeader(name, headers) {
+  if (!headers) {
+    return;
+  }
+  if (headers instanceof Headers) {
+    return headers.get(name);
+  }
+  const lName = name.toLowerCase();
+  if (Array.isArray(headers)) {
+    return headers.find(
+      (h) => h[0] === name || lName === h[0].toLowerCase()
+    )?.[1];
+  }
+  return headers[name] || headers[lName];
+}
+function substitutePathParams(path, pathParams) {
+  if (!pathParams)
+    return path;
+  return path.replace(/:(\w+)/g, (_, key) => {
+    if (key in pathParams) {
+      return encodeURIComponent(pathParams[key]);
+    }
+    return `:${key}`;
+  });
 }
-function mergeSchemas(typesOrArray) {
-  return merge(typesOrArray);
+function createSilgiCore(event) {
+  return {
+    resolve: async (path, method, context) => {
+      const silgiCtx = useSilgi();
+      if (!silgiCtx.router) {
+        return void 0;
+      }
+      const routeStr = substitutePathParams(String(path), context?.pathParams);
+      const methodStr = String(method);
+      const match = findRoute(silgiCtx.router, methodStr, routeStr);
+      return match?.data?.setup.h;
+    }
+  };
 }
-function mergeServices(servicesOrArray) {
-  return merge(servicesOrArray);
+async function silgiFetch(_request, options, context) {
+  let request;
+  if (options) {
+    const wrapped = wrapBodyAndContentType(options);
+    options.body = wrapped.body;
+    options.headers = wrapped.headers;
+  }
+  if (typeof _request === "string") {
+    _request = substitutePathParams(_request, options?.pathParams);
+    let url = _request;
+    if (url[0] === "/") {
+      const host = getHeader("Host", options?.headers) || ".";
+      const proto = getHeader("X-Forwarded-Proto", options?.headers) === "https" ? "https" : "http";
+      url = `${proto}://${host}${url}`;
+    }
+    request = new Request(url, options);
+  } else if (options || _request instanceof URL) {
+    request = new Request(_request, options);
+  } else {
+    request = _request;
+  }
+  const silgiEvent = new _SilgiEvent(request, context);
+  let handlerRes;
+  try {
+    handlerRes = await handler(silgiEvent);
+  } catch (error) {
+    handlerRes = Promise.reject(error);
+  }
+  return handleResponse(handlerRes, silgiEvent, {});
 }
-function mergeShared(sharedOrArray) {
-  return merge(sharedOrArray, 1, 1);
+async function handler(event) {
+  const silgiCtx = useSilgi();
+  const pathname = event.url.pathname;
+  let _chain = void 0;
+  _chain = Promise.resolve(await silgiCtx.callHook("request:on", event));
+  if (silgiCtx.router) {
+    const match = findRoute(silgiCtx.router, event.req.method, pathname);
+    if (match) {
+      if (_chain) {
+        return _chain.then(async (_previous) => {
+          if (_previous !== void 0 && _previous !== kNotFound) {
+            return _previous;
+          }
+          event.context.params = match.params;
+          event.context.matchedRoute = match.data;
+          return orchestrate(match.data, event);
+        });
+      } else {
+        event.context.params = match.params;
+        event.context.matchedRoute = match.data;
+        return orchestrate(match.data, event);
+      }
+    }
+  }
+  return _chain ? _chain.then(
+    (_previous) => _previous === void 0 ? kNotFound : _previous
+  ) : kNotFound;
 }
 
 function getEvent(event) {
@@ -735,12 +910,42 @@ function getEventContext(event) {
   return _event;
 }
 
-function createSchema(silgiType) {
-  return silgiType;
+function createSchema(params) {
+  const { namespace, prefix, path, methods } = params;
+  const routeWithPrefix = `${prefix}${namespace}${path}`;
+  return {
+    [routeWithPrefix]: methods
+  };
+}
+
+function deepMerge(target, source) {
+  if (typeof target !== "object" || target === null)
+    return source;
+  if (typeof source !== "object" || source === null)
+    return source;
+  const result = Array.isArray(target) ? [...target] : { ...target };
+  for (const key of Object.keys(source)) {
+    if (key in target) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+function deepMergeObjects(schemas) {
+  let merged = {};
+  for (const schema of schemas) {
+    merged = deepMerge(merged, schema);
+  }
+  return merged;
 }
 
-function createService(variables) {
-  return variables;
+function createService(params) {
+  const { path, methods } = params;
+  return {
+    [path]: methods
+  };
 }
 
 function createShared(shared) {
@@ -766,4 +971,4 @@ const autoImportTypes = [
   "ExtractQueryParamsFromURI"
 ];
 
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createStorage, getEvent, getEventContext, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, replaceRuntimeValues, silgi, silgiCtx, storageMount, tryUseSilgi, useSilgi, useSilgiStorage };
+export { SilgiError, autoImportTypes, createError, createRoute, createSchema, createService, createShared, createSilgi, createSilgiCore, createStorage, deepMergeObjects, getEvent, getEventContext, handleResponse, isError, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, useSilgi, useSilgiStorage };