silgi 0.24.19 → 0.24.21

package/dist/index.mjs

@@ -1,4165 +1,11 @@
-import consola$1, { consola, createConsola } from 'consola';
-import { getContext, createContext } from 'unctx';
-import defu, { defu as defu$1 } from 'defu';
-import { createHooks, createDebugger } from 'hookable';
-import { withoutTrailingSlash, withLeadingSlash, withTrailingSlash, isRelative } from 'ufo';
-import { Buffer } from 'node:buffer';
-import { klona } from 'klona';
-import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
-import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
-import { genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues } from 'knitwork';
-import { relative, join, resolve, dirname, isAbsolute, basename, extname } from 'pathe';
-import { resolveSilgiPath, relativeWithDot, resolveSilgiModule, writeFile, normalizeTemplate, useLogger, addTemplate, hash, resolveAlias, directoryToURL, hasError, parseServices, genEnsureSafeVar, isDirectory } from 'silgi/kit';
-import { existsSync, promises, lstatSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { readdir, readFile } from 'node:fs/promises';
-import { useSilgi as useSilgi$1, replaceRuntimeValues as replaceRuntimeValues$1, silgiCtx as silgiCtx$1, autoImportTypes as autoImportTypes$1 } from 'silgi';
-import * as dotenv from 'dotenv';
-import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
-import { scanExports, createUnimport, toExports } from 'unimport';
-import { peerDependencies } from 'silgi/meta';
-import { globby } from 'globby';
-import { resolveModuleExportNames, findTypeExports, findExports, resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
-import { createJiti } from 'dev-jiti';
-import { h as hasInstalledModule, r as resolveSilgiPath$1 } from './_chunks/path.mjs';
-import { fileURLToPath } from 'node:url';
-import { resolveModuleURL } from 'exsolve';
-import { generateTypes, resolveSchema } from 'untyped';
-import ignore from 'ignore';
-import { parseSync } from '@oxc-parser/wasm';
-import { p as prepareEnv } from './cli/env.mjs';
-import { watchConfig, loadConfig } from 'c12';
-import { resolveCompatibilityDatesFromEnv, formatDate, resolveCompatibilityDates } from 'compatx';
-import { klona as klona$1 } from 'klona/full';
-import { isDebug, isTest } from 'std-env';
-import { colors } from 'consola/utils';
-import escapeRE from 'escape-string-regexp';
-import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-import 'semver/functions/satisfies.js';
-import 'dot-prop';
-import '@clack/prompts';
-
-const silgiAppCtx = getContext("silgi");
-const silgiCtx = createContext();
-function useSilgiApp() {
-  const instance = silgiAppCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-function normalizeResult(result) {
-  if (Array.isArray(result)) {
-    return [...result];
-  }
-  if (result && typeof result === "object") {
-    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
-      return Object.values(result);
-    }
-    return { ...result };
-  }
-  return result;
-}
-function tryUseSilgiApp() {
-  return silgiAppCtx.tryUse();
-}
-function useSilgi() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-async function silgiClose() {
-  const silgi = silgiCtx.tryUse();
-  if (!silgi) {
-    return;
-  }
-  await silgi.close();
-  await silgi.callHook("close", silgi);
-  consola.withTag("silgi").success("Process terminated");
-}
-function tryUseSilgi() {
-  return silgiCtx.tryUse();
-}
-
-function patternToRegex(pattern) {
-  let regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  regexStr = regexStr.replace(/\*\*/g, ".+");
-  regexStr = regexStr.replace(/\*/g, "[^/]+");
-  regexStr = regexStr.replace(/:([^/]+)/g, "([^/]+)");
-  return new RegExp(`^${regexStr}$`);
-}
-function extractParams(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (!pattern.includes(":"))
-    return null;
-  const paramNames = [];
-  const patternRegex = pattern.replace(/:([^/]+)/g, (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  const regex = new RegExp(`^${patternRegex}$`);
-  const matches = url.match(regex);
-  if (!matches)
-    return null;
-  const params = {};
-  paramNames.forEach((name, i) => {
-    params[name] = matches[i + 1];
-  });
-  return Object.keys(params).length > 0 ? params : null;
-}
-function matchesPattern(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (url === pattern)
-    return true;
-  if (pattern.endsWith("/**")) {
-    const basePath = pattern.slice(0, -3);
-    return url === basePath || url.startsWith(`${basePath}/`);
-  }
-  const urlParts = url.split("/");
-  const patternParts = pattern.split("/");
-  if (!pattern.includes("**") && urlParts.length !== patternParts.length) {
-    return false;
-  }
-  if (pattern.includes("/**/")) {
-    const [prefix, ...suffixParts] = pattern.split("/**/");
-    const suffix = suffixParts.join("/");
-    return url.startsWith(prefix) && (!suffix || url.endsWith(`/${suffix}`));
-  }
-  return patternToRegex(pattern).test(url);
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object")
-    return obj;
-  if (typeof obj === "function")
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(deepClone);
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      cloned[key] = deepClone(obj[key]);
-    }
-  }
-  return cloned;
-}
-function mergeConfigs(...configs) {
-  const result = {};
-  for (const config of configs) {
-    if (!config)
-      continue;
-    for (const key in config) {
-      const value = config[key];
-      if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && typeof result[key] !== "function") {
-        const resultValue = result[key];
-        const valueToMerge = value;
-        result[key] = mergeConfigs(resultValue, valueToMerge);
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function createRouteRules() {
-  let _rules = {};
-  let _mergedRules = {};
-  let _rulesModified = false;
-  function getRules() {
-    return deepClone(_rules);
-  }
-  function importRules(config) {
-    const normalizedConfig = {};
-    for (const pattern in config) {
-      normalizedConfig[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config[pattern]);
-    }
-    _rules = normalizedConfig;
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function exportRules() {
-    return deepClone(_rules);
-  }
-  function addRule(pattern, config) {
-    _rules[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config);
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function updateRule(pattern, config) {
-    const normalizedPattern = withoutTrailingSlash(withLeadingSlash(pattern));
-    if (_rules[normalizedPattern]) {
-      _rules[normalizedPattern] = { ..._rules[normalizedPattern], ...deepClone(config) };
-    } else {
-      _rules[normalizedPattern] = deepClone(config);
-    }
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function removeRule(pattern) {
-    delete _rules[withoutTrailingSlash(withLeadingSlash(pattern))];
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function matchesRule(url, pattern) {
-    return matchesPattern(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function getMatchingPatterns(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    return Object.keys(_rules).filter((pattern) => matchesPattern(normalizedUrl, pattern)).sort((a, b) => {
-      if (a === url)
-        return -1;
-      if (b === url)
-        return 1;
-      const aSegments = a.split("/").filter(Boolean).length;
-      const bSegments = b.split("/").filter(Boolean).length;
-      if (aSegments !== bSegments)
-        return bSegments - aSegments;
-      const aWildcards = (a.match(/\*/g) || []).length;
-      const bWildcards = (b.match(/\*/g) || []).length;
-      if (aWildcards !== bWildcards)
-        return aWildcards - bWildcards;
-      const aDoubleWildcards = (a.match(/\*\*/g) || []).length;
-      const bDoubleWildcards = (b.match(/\*\*/g) || []).length;
-      if (aDoubleWildcards !== bDoubleWildcards)
-        return aDoubleWildcards - bDoubleWildcards;
-      return b.length - a.length;
-    });
-  }
-  function getConfig(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    if (_mergedRules[normalizedUrl]) {
-      return deepClone(_mergedRules[normalizedUrl]);
-    }
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const mergedConfig = {};
-    for (let i = patterns.length - 1; i >= 0; i--) {
-      const pattern = patterns[i];
-      const patternConfig = _mergedRules[pattern] || _rules[pattern];
-      Object.assign(mergedConfig, deepClone(patternConfig));
-    }
-    _mergedRules[normalizedUrl] = deepClone(mergedConfig);
-    return mergedConfig;
-  }
-  function computeMergedConfig(url, patterns) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const matchingPatterns = patterns || getMatchingPatterns(normalizedUrl);
-    if (!matchingPatterns.length)
-      return {};
-    const allPatternsHaveCache = matchingPatterns.every((pattern) => !!_mergedRules[pattern]);
-    if (allPatternsHaveCache) {
-      return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_mergedRules[pattern])), {});
-    }
-    return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_rules[pattern])), {});
-  }
-  function getParams(url, pattern) {
-    return extractParams(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function match(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const bestPattern = patterns[0];
-    return {
-      pattern: bestPattern,
-      config: deepClone(_rules[bestPattern]),
-      params: getParams(normalizedUrl, bestPattern)
-    };
-  }
-  function clear() {
-    _rules = {};
-    clearMergedRules();
-    _rulesModified = false;
-  }
-  function clearMergedRules() {
-    _mergedRules = {};
-    _rulesModified = true;
-  }
-  function precomputeMergedRules(urls) {
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    for (const url of urls) {
-      const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-      if (!_mergedRules[normalizedUrl]) {
-        const patterns = getMatchingPatterns(normalizedUrl);
-        if (patterns.length) {
-          _mergedRules[normalizedUrl] = computeMergedConfig(normalizedUrl, patterns);
-        }
-      }
-    }
-  }
-  function setMergedRule(url, config) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    _mergedRules[normalizedUrl] = deepClone(config);
-    if (url.includes("*") || url.includes(":")) {
-      _rulesModified = false;
-    }
-  }
-  function getMergedRules() {
-    return deepClone(_mergedRules);
-  }
-  function configure(config) {
-    importRules(config);
-  }
-  function updateMergeRules() {
-    if (!_rulesModified) {
-      return _mergedRules;
-    }
-    _mergedRules = {};
-    const rulePatterns = Object.keys(_rules);
-    for (const pattern of rulePatterns) {
-      const patterns = getMatchingPatterns(pattern);
-      _mergedRules[pattern] = computeMergedConfig(pattern, patterns);
-    }
-    for (const pattern of rulePatterns) {
-      if (pattern.includes("/:")) {
-        const segments = pattern.split("/");
-        let partialPath = "";
-        for (const segment of segments) {
-          if (segment) {
-            partialPath += `/${segment}`;
-            if (segment.startsWith(":") && partialPath !== pattern) {
-              const samplePath = partialPath.replace(/:\w+/g, "sample");
-              const patterns = getMatchingPatterns(samplePath);
-              _mergedRules[samplePath] = computeMergedConfig(samplePath, patterns);
-            }
-          }
-        }
-      }
-    }
-    _rulesModified = false;
-    return _mergedRules;
-  }
-  return {
-    // Public getters that return a cloned version to prevent direct modification
-    get rules() {
-      return getRules();
-    },
-    get mergedRules() {
-      return getMergedRules();
-    },
-    // API methods
-    importRules,
-    exportRules,
-    addRule,
-    updateRule,
-    removeRule,
-    matchesRule,
-    getMatchingPatterns,
-    getConfig,
-    getParams,
-    match,
-    clear,
-    clearMergedRules,
-    precomputeMergedRules,
-    setMergedRule,
-    getMergedRules,
-    configure,
-    updateMergeRules
-  };
-}
-
-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
-    };
-  }
-  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
-    });
-  }
-  // Predefined error creators
-  static authenticationError(message, context) {
-    return this.create({
-      message,
-      code: 401,
-      category: "auth" /* AUTHENTICATION */,
-      severity: "ERROR" /* ERROR */,
-      httpStatus: 401 /* UNAUTHORIZED */,
-      context
-    });
-  }
-  static authorizationError(message, context) {
-    return this.create({
-      message,
-      code: 403,
-      category: "authorization" /* AUTHORIZATION */,
-      severity: "ERROR" /* ERROR */,
-      httpStatus: 403 /* FORBIDDEN */,
-      context
-    });
-  }
-  static validationError(message, context) {
-    return this.create({
-      message,
-      code: 400,
-      category: "validation" /* VALIDATION */,
-      severity: "WARNING" /* WARNING */,
-      httpStatus: 400 /* BAD_REQUEST */,
-      context
-    });
-  }
-  static notFoundError(message, context) {
-    return this.create({
-      message,
-      code: 404,
-      category: "business" /* BUSINESS */,
-      severity: "WARNING" /* WARNING */,
-      httpStatus: 404 /* NOT_FOUND */,
-      context
-    });
-  }
-  static internalError(message, cause) {
-    return this.create({
-      message,
-      code: 500,
-      category: "infrastructure" /* INFRASTRUCTURE */,
-      severity: "CRITICAL" /* CRITICAL */,
-      httpStatus: 500 /* INTERNAL_SERVER_ERROR */,
-      cause
-    });
-  }
-}
-class SilgiError extends Error {
-  code;
-  category;
-  severity;
-  httpStatus;
-  metadata;
-  context;
-  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}`;
-    }
-    return str;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      category: this.category,
-      severity: this.severity,
-      httpStatus: this.httpStatus,
-      metadata: this.metadata,
-      context: this.context,
-      stack: this.stack
-    };
-  }
-  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;
-    }
-    return ErrorFactory.internalError(
-      error instanceof Error ? error.message : String(error),
-      error instanceof Error ? error : void 0
-    );
-  }
-}
-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 }
-    });
-  }
-  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
-        }
-      });
-    }
-    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
-            }
-          });
-        }
-      }
-      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);
-  }
-}
-
-function replaceRuntimeValues(obj, runtime) {
-  if (!obj || typeof obj !== "object")
-    return obj;
-  for (const key in obj) {
-    if (typeof obj[key] === "string" && obj[key].startsWith("runtime.")) {
-      const runtimePath = obj[key].substring(8).split(".");
-      let value = runtime;
-      for (const segment of runtimePath) {
-        if (value === void 0 || value === null)
-          break;
-        value = value[segment];
-      }
-      if (value !== void 0)
-        obj[key] = value;
-    } else if (typeof obj[key] === "object" && obj[key] !== null) {
-      obj[key] = replaceRuntimeValues(obj[key], runtime);
-    }
-  }
-  return obj;
-}
-
-async function createStorage(silgi) {
-  const storage = createStorage$1();
-  const runtime = useSilgiRuntimeConfig();
-  const mounts = klona({
-    ...silgi.options.storage,
-    ...silgi.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
-      storage.mount(path, driver(processedOpts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-function useSilgiStorage(base = "/memory:cache") {
-  const silgi = useSilgiApp();
-  return base ? prefixStorage(silgi.storage, base) : silgi.storage;
-}
-async function generateStorageKey(params) {
-  const {
-    operation,
-    input,
-    keyGenerator,
-    requestId,
-    storageOptions
-  } = params;
-  const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
-  const parts = [
-    cacheScopePrefix,
-    // Always include scope prefix first
-    operation.namespaceName,
-    operation.serviceName,
-    operation.methodName
-  ].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: {
-          requestId,
-          operation,
-          input,
-          storageOptions,
-          keyGenerator
-        }
-      });
-    }
-    parts.push(requestId);
-  }
-  if (keyGenerator) {
-    const customKey = await Promise.resolve(keyGenerator(input));
-    parts.push(customKey);
-  } else {
-    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
-  }
-  return Buffer.from(parts.join(":")).toString("base64");
-}
-
-async function runSilgiPlugins(silgi) {
-  for (const plugin of silgi.plugins) {
-    try {
-      await plugin(silgi);
-    } catch (error) {
-      silgi.captureError(error, { tags: ["plugin"] });
-      throw error;
-    }
-  }
-}
-async function createSilgiApp(config) {
-  const hooks = createHooks();
-  const silgi = {
-    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,
-    options: config.options ?? {},
-    hooks,
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    ready: () => {
-      return hooks.callHook("ready", silgi);
-    },
-    envOptions: config.envOptions ?? {},
-    close: () => hooks.callHook("close", silgi),
-    logger: createConsola(defu(config.options?.consolaOptions ?? {}, {
-      tag: "silgi"
-    })).withTag("silgi"),
-    captureError: config.captureError ?? (() => {
-    }),
-    routeRules: void 0
-  };
-  const routeRules = createRouteRules();
-  routeRules.importRules(config.options.routeRules ?? {});
-  silgi.routeRules = routeRules;
-  silgi.hooks.addHooks(silgi.options.hooks);
-  await runSilgiPlugins(silgi);
-  await scanAction(silgi);
-  if (!silgi.storage) {
-    silgi.storage = await createStorage(silgi);
-  }
-  silgi.shared.storage = (...data) => {
-    return useSilgiStorage(...data);
-  };
-  silgi.shared.runtimeConfig = silgi.options.runtimeConfig;
-  if (silgiAppCtx.tryUse()) {
-    silgiAppCtx.unset();
-    silgiAppCtx.set(silgi);
-  } else {
-    silgiAppCtx.set(silgi);
-    silgi.hook("close", () => silgiAppCtx.unset());
-  }
-  silgi.logger.info("Silgi installed");
-  hooks.hookOnce("close", async () => {
-    hooks.removeAllHooks();
-    await silgi.storage.dispose();
-  });
-  return silgi;
-}
-
-function silgi(event) {
-  return {
-    execute: (uriString, input, source, queryParams) => {
-      return execute(uriString, input, event, source, queryParams);
-    }
-  };
-}
-async function execute(uriString, input, event, source, queryParams) {
-  const silgiAppCtx = useSilgiApp();
-  const config = {
-    returnNull: false
-  };
-  try {
-    const operation = parseURI(uriString, silgiAppCtx.uris);
-    if (!operation) {
-      throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
-    }
-    let success = false;
-    let cached = false;
-    let result;
-    const handler = silgiAppCtx.scannedHandlers.get(operation.uri);
-    if (!handler) {
-      throw ErrorFactory.create({
-        message: "execute not found",
-        httpStatus: HttpStatus.NOT_FOUND,
-        context: {
-          uri: uriString
-        }
-      });
-    }
-    await silgiAppCtx.callHook("execute:before", {
-      operation,
-      input,
-      event,
-      modules: handler.modules,
-      source,
-      config
-    });
-    if (config.returnNull) {
-      return result;
-    }
-    const cacheData = await cacheExecute(input, operation, handler, event);
-    if (cacheData?.success) {
-      result = cacheData.data;
-      success = cacheData.success;
-      cached = cacheData.cached;
-    } else {
-      let parameters = defu$1(operation.routerParams, operation.query) || {};
-      if (queryParams) {
-        parameters = defu$1(queryParams, parameters);
-      }
-      silgiAppCtx.shared.silgi = silgi(event);
-      result = await handler?.handler(
-        defu$1(input, { parameters }),
-        silgiAppCtx.shared,
-        event,
-        source
-      );
-      success = true;
-    }
-    await silgiAppCtx.callHook("execute:after", {
-      operation,
-      input,
-      event,
-      result,
-      success,
-      source,
-      modules: handler.modules,
-      config
-    });
-    if (!cached) {
-      if (success && cacheData?.cachedKey && handler.storage) {
-        await useSilgiStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
-      }
-    }
-    return result;
-  } catch (err) {
-    await silgiAppCtx.callHook("execute:error", {
-      input,
-      event,
-      source,
-      error: err instanceof Error ? err : new Error(String(err)),
-      timestamp: Date.now(),
-      config
-    });
-    silgiAppCtx.captureError(SilgiError.from(err), {
-      event,
-      tags: ["execute"]
-    });
-    throw err;
-  }
-}
-async function cacheExecute(input, operation, handler, event) {
-  if (!handler.storage)
-    return;
-  const cacheKey = handler.storage ? await generateStorageKey({
-    operation,
-    input,
-    keyGenerator: handler.storage.key,
-    storageOptions: handler.storage,
-    requestId: event?.requestId
-  }) : null;
-  if (cacheKey) {
-    const cachedResult = await useSilgiStorage(handler.storage.base).getItem(cacheKey);
-    if (cachedResult !== null) {
-      return {
-        success: true,
-        data: normalizeResult(cachedResult),
-        cached: true,
-        cachedKey: cacheKey
-      };
-    }
-  }
-  return {
-    success: false,
-    data: null,
-    cached: false,
-    cachedKey: cacheKey
-  };
-}
-
-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];
-      }
-    });
-    return acc;
-  }, {});
-}
-function mergeSchemas(typesOrArray) {
-  return merge(typesOrArray);
-}
-function mergeServices(servicesOrArray) {
-  return merge(servicesOrArray);
-}
-function mergeShared(sharedOrArray) {
-  return merge(sharedOrArray, 1, 1);
-}
-
-function getEvent(event) {
-  const silgi = useSilgiApp();
-  if (silgi.options.present === "h3" || silgi.options.present === "nitro" || silgi.options.present === "nuxt") {
-    return event.event;
-  }
-  return event;
-}
-function getEventContext(event) {
-  const _event = getEvent(event);
-  return _event.context;
-}
-
-function createSchema(silgiType) {
-  return silgiType;
-}
-
-function createService(variables) {
-  return variables;
-}
-
-function createShared(shared) {
-  return shared;
-}
-
-function storageMount(silgi) {
-  const _silgi = silgi || useSilgiApp();
-  return (base, driver) => {
-    const existingStorage = _silgi.storage.getMount(base);
-    if (existingStorage) {
-      return existingStorage.driver;
-    }
-    const storage = _silgi.storage.mount(base, driver);
-    return storage;
-  };
-}
-
-const SilgiCLIDefaults = {
-  // General
-  debug: isDebug,
-  // timing: isDebug,
-  logLevel: isTest ? 1 : 3,
-  // runtimeConfig: { app: {}, silgi: {} },
-  appConfig: {},
-  appConfigFiles: [],
-  commandType: "prepare",
-  runtimeConfig: {
-    silgi: {
-      version: "0.0.1"
-    }
-  },
-  serviceParseModules: [],
-  storages: [],
-  devServer: {
-    watch: []
-  },
-  // Dirs
-  scanDirs: [],
-  build: {
-    dir: ".silgi",
-    typesDir: "{{ build.dir }}/types",
-    templates: []
-  },
-  output: {
-    dir: "{{ rootDir }}/.output",
-    serverDir: "{{ output.dir }}/server",
-    publicDir: "{{ output.dir }}/public"
-  },
-  serverDir: "{{ rootDir }}/server",
-  clientDir: "{{ rootDir }}/client",
-  silgi: {
-    serverDir: "{{ serverDir }}/silgi",
-    clientDir: "{{ clientDir }}/silgi",
-    publicDir: "{{ silgi.serverDir }}/public",
-    utilsDir: "{{ silgi.serverDir }}/utils",
-    vfsDir: "{{ silgi.serverDir }}/vfs",
-    typesDir: "{{ silgi.serverDir }}/types"
-  },
-  // Modules
-  _modules: [],
-  modules: [],
-  routeRules: {},
-  // Features
-  // experimental: {},
-  future: {},
-  storage: {},
-  devStorage: {},
-  stub: false,
-  // bundledStorage: [],
-  // publicAssets: [],
-  // serverAssets: [],
-  plugins: [],
-  // tasks: {},
-  // scheduledTasks: {},
-  imports: {
-    exclude: [],
-    dirs: [],
-    presets: [],
-    virtualImports: ["#silgiImports"]
-  },
-  // virtual: {},
-  // compressPublicAssets: false,
-  ignore: [],
-  // Dev
-  dev: false,
-  // devServer: { watch: [] },
-  watchOptions: {
-    ignoreInitial: true,
-    ignored: [
-      "**/node_modules/**",
-      "**/.git/**",
-      "**/.silgi/**",
-      "**/.output/**",
-      "**/.vscode/**",
-      "**/.idea/**",
-      "**/.nuxt/**",
-      "**/.next/**",
-      "**/.gitignore",
-      "**/.gitattributes",
-      "**/assets/**",
-      "**/dist/**",
-      "**/build/**",
-      "**/coverage/**",
-      "**/test/**",
-      "**/tests/**",
-      "**/tmp/**"
-    ]
-  },
-  // devProxy: {},
-  // Logging
-  // logging: {
-  //   compressedSizes: true,
-  //   buildSuccess: true,
-  // },
-  // Routing
-  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
-  // handlers: [],
-  // devHandlers: [],
-  // errorHandler: undefined,
-  // Advanced
-  typescript: {
-    strict: false,
-    generateTsConfig: true,
-    // generateRuntimeConfigTypes: true,
-    tsconfigPath: ".silgi/types/silgi.tsconfig.json",
-    tsConfig: {},
-    customConditions: [],
-    generateRuntimeConfigTypes: true,
-    removeFileExtension: false
-  },
-  conditions: [],
-  nodeModulesDirs: [],
-  // hooks: {},
-  commands: {},
-  // Framework
-  framework: {
-    name: "h3",
-    version: ""
-  },
-  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"],
-  ignoreOptions: void 0
-};
-
-const fallbackCompatibilityDate = "2025-02-04";
-async function resolveCompatibilityOptions(options) {
-  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
-    options.compatibilityDate
-  );
-  if (!options.compatibilityDate.default) {
-    options.compatibilityDate.default = await _resolveDefault(options);
-  }
-}
-let _fallbackInfoShown = false;
-let _promptedUserToUpdate = false;
-async function _resolveDefault(options) {
-  const _todayDate = formatDate(/* @__PURE__ */ new Date());
-  const consola = consola$1.withTag("silgi");
-  consola.warn(`No valid compatibility date is specified.`);
-  const onFallback = () => {
-    if (!_fallbackInfoShown) {
-      consola.info(
-        [
-          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
-          `  Please specify compatibility date to avoid unwanted behavior changes:`,
-          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
-          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
-          ``
-        ].join("\n")
-      );
-      _fallbackInfoShown = true;
-    }
-    return fallbackCompatibilityDate;
-  };
-  const shallUpdate = !_promptedUserToUpdate && await consola.prompt(
-    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
-    {
-      type: "confirm",
-      default: true
-    }
-  );
-  _promptedUserToUpdate = true;
-  if (!shallUpdate) {
-    return onFallback();
-  }
-  const { updateConfig } = await import('c12/update');
-  const updateResult = await updateConfig({
-    configFile: "silgi.config",
-    cwd: options.rootDir,
-    async onCreate({ configFile }) {
-      const shallCreate = await consola.prompt(
-        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
-        {
-          type: "confirm",
-          default: true
-        }
-      );
-      if (shallCreate !== true) {
-        return false;
-      }
-      return _getDefaultNitroConfig();
-    },
-    async onUpdate(config) {
-      config.compatibilityDate = _todayDate;
-    }
-  }).catch((error) => {
-    consola.error(`Failed to update config: ${error.message}`);
-    return null;
-  });
-  if (updateResult?.configFile) {
-    consola.success(
-      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
-    );
-    return _todayDate;
-  }
-  return onFallback();
-}
-function _getDefaultNitroConfig() {
-  return (
-    /* js */
-    `
-import { defineSilgiConfig } from 'silgi/config'
-
-export default defineSilgiConfig({})
-  `
-  );
-}
-
-async function resolveImportsOptions(options) {
-  if (options.imports === false) {
-    return;
-  }
-  options.imports.presets ??= [];
-  options.imports.presets.push(...getSilgiImportsPreset());
-  if (options.preset === "h3") {
-    const h3Exports = await resolveModuleExportNames("h3", {
-      url: import.meta.url
-    });
-    options.imports.presets ??= [];
-    options.imports.presets.push({
-      from: "h3",
-      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
-    });
-  }
-  options.imports.dirs ??= [];
-  options.imports.dirs.push(
-    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
-  );
-  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
-    options.imports.exclude.push(/[/\\]\.git[/\\]/);
-    options.imports.exclude.push(options.build.dir);
-    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
-    options.imports.exclude.push(
-      scanDirsInNodeModules.length > 0 ? new RegExp(
-        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
-      ) : /[/\\]node_modules[/\\]/
-    );
-  }
-}
-function getSilgiImportsPreset() {
-  return [
-    // TODO: buraya bizim importlarimiz gelecek.
-    {
-      from: "silgi",
-      imports: [
-        "createShared",
-        "useSilgiApp",
-        "createService",
-        "createSchema"
-      ]
-    },
-    // {
-    //   from: 'nitropack/runtime',
-    //   imports: ['useRuntimeConfig', 'useAppConfig'],
-    // },
-    // {
-    //   from: 'nitropack/runtime',
-    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/cache',
-    //   imports: [
-    //     'defineCachedFunction',
-    //     'defineCachedEventHandler',
-    //     'cachedFunction',
-    //     'cachedEventHandler',
-    //   ],
-    // },
-    {
-      from: "silgi",
-      imports: ["useSilgiStorage"]
-    }
-    // {
-    //   from: 'nitropack/runtime/internal/renderer',
-    //   imports: ['defineRenderHandler'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/meta',
-    //   imports: ['defineRouteMeta'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/route-rules',
-    //   imports: ['getRouteRules'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/context',
-    //   imports: ['useEvent'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/task',
-    //   imports: ['defineTask', 'runTask'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/error/utils',
-    //   imports: ['defineNitroErrorHandler'],
-    // },
-  ];
-}
-
-async function resolvePathOptions(options) {
-  options.rootDir = resolve(options.rootDir || ".");
-  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
-    () => options.rootDir
-  );
-  options.srcDir = resolve(options.srcDir || options.rootDir);
-  for (const key of ["srcDir"]) {
-    options[key] = resolve(options.rootDir, options[key]);
-  }
-  options.build.dir = resolve(options.rootDir, options.build.dir);
-  options.build.typesDir = resolveSilgiPath(
-    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
-    options,
-    options.rootDir
-  );
-  if (options.preset === "npm-package") {
-    const packageJsonPath = resolve(options.rootDir, "package.json");
-    const packageJson = await readPackageJSON(packageJsonPath);
-    if (packageJson.name === void 0) {
-      throw new Error("Package name is undefined");
-    }
-    options.alias ||= {};
-    options.alias[packageJson.name] = join(options.rootDir, "src/module");
-    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime");
-    options.alias[`${packageJson.name}/runtime/*`] = join(options.rootDir, "src/runtime/*");
-    options.alias[`${packageJson.name}/types`] = join(options.rootDir, "src/types");
-  }
-  if (options.stub) {
-    options.alias = {
-      ...options.alias,
-      "silgi/runtime": join(runtimeDir),
-      "#internal/silgi": join(runtimeDir),
-      "silgi/runtime/*": join(runtimeDir, "*"),
-      "#internal/silgi/*": join(runtimeDir, "*")
-    };
-  }
-  options.alias = {
-    ...options.alias,
-    "~/": join(options.srcDir, "/"),
-    "@/": join(options.srcDir, "/"),
-    "~~/": join(options.rootDir, "/"),
-    "@@/": join(options.rootDir, "/")
-  };
-  if (options.preset === "npm-package") {
-    options.alias = {
-      ...options.alias
-      // '#silgi/app/': join(options.build.dir, '/'),
-    };
-  }
-  if (options.alias && typeof options.alias === "object") {
-    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
-    const paths = options.typescript.tsConfig.compilerOptions.paths;
-    for (const [key, value] of Object.entries(options.alias)) {
-      if (typeof paths === "object") {
-        paths[key] = [value];
-      }
-    }
-  }
-  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
-    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
-    const paths = options.typescript.tsConfig.compilerOptions.paths;
-    for (const [key, value] of Object.entries(options.alias)) {
-      if (typeof paths === "object") {
-        paths[key] = [value];
-      }
-    }
-  }
-  options.modulesDir = [resolve(options.rootDir, "node_modules")];
-  options.output.dir = resolveSilgiPath(
-    options.output.dir || SilgiCLIDefaults.output.dir,
-    options,
-    options.rootDir
-  );
-  options.output.publicDir = resolveSilgiPath(
-    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
-    options,
-    options.rootDir
-  );
-  options.output.serverDir = resolveSilgiPath(
-    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
-    options,
-    options.rootDir
-  );
-  options.serverDir = resolveSilgiPath(
-    options.serverDir || SilgiCLIDefaults.serverDir,
-    options,
-    options.rootDir
-  );
-  options.clientDir = resolveSilgiPath(
-    options.clientDir || SilgiCLIDefaults.clientDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.serverDir = resolveSilgiPath(
-    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.clientDir = resolveSilgiPath(
-    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.publicDir = resolveSilgiPath(
-    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.utilsDir = resolveSilgiPath(
-    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.vfsDir = resolveSilgiPath(
-    options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.typesDir = resolveSilgiPath(
-    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
-    options,
-    options.rootDir
-  );
-  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
-  options.nodeModulesDirs = [
-    ...new Set(
-      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
-    )
-  ];
-  options.scanDirs.unshift(options.srcDir);
-  options.scanDirs = options.scanDirs.map(
-    (dir) => resolve(options.srcDir, dir)
-  );
-  options.scanDirs = [...new Set(options.scanDirs)];
-  options.appConfigFiles ??= [];
-  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
-  for (const dir of options.scanDirs) {
-    const configFile = _tryResolve("app.config", dir);
-    if (configFile && !options.appConfigFiles.includes(configFile)) {
-      options.appConfigFiles.push(configFile);
-    }
-  }
-}
-function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
-  path = resolve(base, path);
-  if (existsSync(path)) {
-    return path;
-  }
-  for (const ext of extensions) {
-    const p = path + ext;
-    if (existsSync(p)) {
-      return p;
-    }
-  }
-}
-
-async function resolveStorageOptions(options) {
-  const fsMounts = {
-    root: resolve(options.rootDir),
-    src: resolve(options.srcDir),
-    build: resolve(options.build.dir),
-    cache: resolve(options.build.dir, "cache")
-  };
-  for (const p in fsMounts) {
-    options.devStorage[p] = options.devStorage[p] || {
-      driver: "fs",
-      readOnly: p === "root" || p === "src",
-      base: fsMounts[p]
-    };
-  }
-  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
-    options.devStorage.data = {
-      driver: "fs",
-      base: resolve(options.rootDir, ".data/kv")
-    };
-  }
-}
-
-async function resolveURLOptions(options) {
-  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
-}
-
-const configResolvers = [
-  resolveCompatibilityOptions,
-  resolvePathOptions,
-  resolveImportsOptions,
-  // resolveRouteRulesOptions,
-  // resolveDatabaseOptions,
-  // resolveFetchOptions,
-  // resolveExportConditionsOptions,
-  // resolveRuntimeConfigOptions,
-  // resolveOpenAPIOptions,
-  resolveURLOptions,
-  // resolveAssetsOptions,
-  resolveStorageOptions
-  // resolveErrorOptions,
-];
-async function loadOptions(configOverrides = {}, opts = {}) {
-  const options = await _loadUserConfig(configOverrides, opts);
-  for (const resolver of configResolvers) {
-    await resolver(options);
-  }
-  return options;
-}
-async function _loadUserConfig(configOverrides = {}, opts = {}) {
-  const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
-  if (configOverrides.dev) ;
-  configOverrides = klona$1(configOverrides);
-  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
-  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
-  const { resolvePreset } = await import('silgi/presets');
-  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
-    name: "silgi",
-    cwd: configOverrides.rootDir,
-    dotenv: configOverrides.dev,
-    extend: { extendKey: ["extends", "preset"] },
-    overrides: {
-      ...configOverrides,
-      preset: presetOverride
-    },
-    async defaultConfig({ configs }) {
-      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
-      if (!compatibilityDate) {
-        compatibilityDate = getConf("compatibilityDate");
-      }
-      return {
-        // typescript: {
-        //   generateRuntimeConfigTypes:
-        //     !framework?.name || framework.name === 'nitro',
-        // },
-        preset: presetOverride || (await resolvePreset("", {
-          static: getConf("static"),
-          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
-        }))?._meta?.name
-      };
-    },
-    defaults: SilgiCLIDefaults,
-    jitiOptions: {
-      alias: {
-        "silgi/config": "silgi/config"
-      }
-    },
-    async resolve(id) {
-      const preset = await resolvePreset(id, {
-        static: configOverrides.static,
-        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
-      });
-      if (preset) {
-        return {
-          config: klona$1(preset)
-        };
-      }
-    },
-    ...opts.c12
-  });
-  delete globalThis.defineSilgiConfig;
-  const options = klona$1(loadedConfig.config);
-  options._config = configOverrides;
-  options._c12 = loadedConfig;
-  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
-  options.preset = _presetName;
-  options.compatibilityDate = resolveCompatibilityDates(
-    compatibilityDate,
-    options.compatibilityDate
-  );
-  return options;
-}
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-function renderAttrs(obj) {
-  const attrs = [];
-  for (const key in obj) {
-    attrs.push(renderAttr(key, obj[key]));
-  }
-  return attrs.join(" ");
-}
-function renderAttr(key, value) {
-  return value ? `${key}="${value}"` : "";
-}
-async function silgiGenerateType(silgi) {
-  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
-  const tsConfigPath = resolve(
-    silgi.options.rootDir,
-    silgi.options.typescript.tsconfigPath
-  );
-  const tsconfigDir = dirname(tsConfigPath);
-  const include = /* @__PURE__ */ new Set([
-    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
-      /^(?=[^.])/,
-      "./"
-    ),
-    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
-    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
-  ]);
-  const exclude = /* @__PURE__ */ new Set([
-    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
-    relativeWithDot(tsconfigDir, "node_modules"),
-    relativeWithDot(tsconfigDir, "dist")
-  ]);
-  for (const dir of silgi.options.modulesDir) {
-    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
-  }
-  const moduleEntryPaths = [];
-  for (const m of silgi.scanModules) {
-    if (m.entryPath) {
-      moduleEntryPaths.push(getDirectory(m.entryPath));
-    }
-  }
-  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
-  for (const path of modulePaths) {
-    const relative2 = relativeWithDot(tsconfigDir, path);
-    include.add(join(relative2, "runtime"));
-    exclude.add(join(relative2, "runtime/server"));
-    include.add(join(relative2, "dist/runtime"));
-    exclude.add(join(relative2, "dist/runtime/server"));
-  }
-  const userTsConfig = {
-    compilerOptions: {
-      /* Base options: */
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      skipLibCheck: true,
-      allowImportingTsExtensions: true,
-      /* Target options: */
-      target: "ESNext",
-      allowJs: true,
-      resolveJsonModule: true,
-      moduleDetection: "force",
-      isolatedModules: true,
-      verbatimModuleSyntax: true,
-      /* Strictness */
-      strict: silgi.options.typescript.strict,
-      noUncheckedIndexedAccess: true,
-      noImplicitOverride: true,
-      forceConsistentCasingInFileNames: true,
-      /* If NOT transpiling with TypeScript: */
-      module: "Preserve",
-      customConditions: silgi.options.typescript.customConditions,
-      paths: {
-        // '#silgiImports': [
-        //   relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, 'silgi-imports')),
-        // ],
-        ...silgi.scanModules.reduce((acc, m) => {
-          if (m.entryPath) {
-            acc[m.meta.name] = [relativeWithDot(tsconfigDir, m.entryPath)];
-          }
-          return acc;
-        }, {}),
-        ...silgi.scanModules.reduce((acc, m) => {
-          if (m.entryPath) {
-            const directory = getDirectory(m.entryPath);
-            acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`];
-          }
-          return acc;
-        }, {})
-      }
-    },
-    include: [...include],
-    exclude: [...exclude]
-  };
-  const npmPackageTsConfig = {
-    compilerOptions: {
-      target: "es2022",
-      lib: ["es2022", "webworker", "dom.iterable"],
-      moduleDetection: "force",
-      /* If NOT transpiling with TypeScript: */
-      module: "preserve",
-      paths: {},
-      resolveJsonModule: true,
-      allowJs: true,
-      /* Strictness */
-      strict: true,
-      noImplicitOverride: true,
-      noEmit: true,
-      allowSyntheticDefaultImports: true,
-      /* Base options: */
-      esModuleInterop: false,
-      forceConsistentCasingInFileNames: true,
-      isolatedModules: true,
-      verbatimModuleSyntax: true,
-      skipLibCheck: true
-    },
-    // include: ['src', 'test', './moduleTypes.d.ts'],
-    // exclude: ['dist', 'examples', 'playground', 'test/fixture'],
-    include: [...include],
-    exclude: [...exclude]
-  };
-  const tsConfig = defu$1(
-    silgi.options.typescript?.tsConfig,
-    silgi.options.preset === "npm-package" ? npmPackageTsConfig : userTsConfig
-  );
-  tsConfig.compilerOptions ||= {};
-  tsConfig.compilerOptions.paths ||= {};
-  tsConfig.include ||= [];
-  for (const alias in tsConfig.compilerOptions.paths) {
-    const paths = tsConfig.compilerOptions.paths[alias];
-    tsConfig.compilerOptions.paths[alias] = await Promise.all(
-      paths.map(async (path) => {
-        if (!isAbsolute(path)) {
-          return path;
-        }
-        const stats = await promises.stat(path).catch(
-          () => null
-          /* file does not exist */
-        );
-        return relativeWithDot(
-          tsconfigDir,
-          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
-        );
-      })
-    );
-  }
-  const references = [];
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    if (id === "./src" && silgi.options.preset === "npm-package") {
-      id = resolve(silgi.options.rootDir);
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.rootDir }).catch(() => null);
-    references.push({ types: pkg?.name || id });
-  }));
-  const declarations = [];
-  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
-  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-  const _declarations = [
-    ...references.map((ref) => {
-      if ("path" in ref && isAbsolute(ref.path)) {
-        ref.path = relative(silgi.options.build.dir, ref.path);
-      }
-      return `/// <reference ${renderAttrs(ref)} />`;
-    }),
-    ...declarations,
-    "",
-    "export {}",
-    ""
-  ];
-  return {
-    declarations: _declarations,
-    tsConfig
-  };
-}
-
-async function prepareBuild(silgi) {
-  try {
-    if (!silgi?.routeRules?.exportRules) {
-      throw new Error("Invalid silgi configuration: routeRules or exportRules is undefined");
-    }
-    const exportedRules = silgi.routeRules.exportRules();
-    if (!exportedRules || typeof exportedRules !== "object") {
-      throw new Error("No valid route rules to export");
-    }
-    const content = `/* eslint-disable */
-// @ts-nocheck
-// This file is auto-generated at build time by Silgi
-// Contains route rules with preserved functions
-// DO NOT MODIFY THIS FILE DIRECTLY
-
-export const routeRules = ${genObjectFromRawEntries(
-      Object.entries(exportedRules).map(([key, value]) => {
-        if (typeof value === "function") {
-          return [key, genObjectFromRaw(value)];
-        }
-        return [key, genObjectFromValues(value)];
-      })
-    )}
-`;
-    const serverDir = silgi.options.silgi.serverDir;
-    if (!serverDir) {
-      throw new Error("Server directory not defined in configuration");
-    }
-    const file = join(serverDir, "rules.ts");
-    if (!silgi.errors.length) {
-      await writeFile(file, content);
-    }
-  } catch (error) {
-    console.error("\u274C Failed to prepare build:", error instanceof Error ? error.message : String(error));
-    throw error;
-  }
-}
-
-async function prepare(_silgi) {
-}
-
-async function reloadScan(path, _stats) {
-  const silgi = useSilgi$1();
-  await silgi.callHook("reload:scan", path, _stats);
-}
-
-async function setupDotenv(options) {
-  const targetEnvironment = options.env ?? process.env;
-  const environment = await loadDotenv({
-    cwd: options.cwd,
-    fileName: options.fileName ?? ".env",
-    env: targetEnvironment,
-    interpolate: options.interpolate ?? true
-  });
-  for (const key in environment) {
-    if (!key.startsWith("_") && targetEnvironment[key] === void 0) {
-      targetEnvironment[key] = environment[key];
-    }
-  }
-  return environment;
-}
-async function loadDotenv(options) {
-  const environment = /* @__PURE__ */ Object.create(null);
-  const dotenvFile = resolve(options.cwd, options.fileName);
-  if (existsSync(dotenvFile)) {
-    const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8"));
-    Object.assign(environment, parsed);
-  }
-  if (!options.env?._applied) {
-    Object.assign(environment, options.env);
-    environment._applied = true;
-  }
-  if (options.interpolate) {
-    interpolate(environment);
-  }
-  return environment;
-}
-function interpolate(target, source = {}, parse = (v) => v) {
-  function getValue(key) {
-    return source[key] === void 0 ? target[key] : source[key];
-  }
-  function interpolate2(value, parents = []) {
-    if (typeof value !== "string") {
-      return value;
-    }
-    const matches = value.match(/(.?\$\{?[\w:]*\}?)/g) || [];
-    return parse(
-      matches.reduce((newValue, match) => {
-        const parts = /(.?)\$\{?([\w:]+)?\}?/.exec(match) || [];
-        const prefix = parts[1];
-        let value2, replacePart;
-        if (prefix === "\\") {
-          replacePart = parts[0] || "";
-          value2 = replacePart.replace(String.raw`\$`, "$");
-        } else {
-          const key = parts[2];
-          replacePart = (parts[0] || "").slice(prefix.length);
-          if (parents.includes(key)) {
-            console.warn(
-              `Please avoid recursive environment variables ( loop: ${parents.join(
-                " > "
-              )} > ${key} )`
-            );
-            return "";
-          }
-          value2 = getValue(key);
-          value2 = interpolate2(value2, [...parents, key]);
-        }
-        return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
-      }, value)
-    );
-  }
-  for (const key in target) {
-    target[key] = interpolate2(getValue(key));
-  }
-}
-
-const vueShim = {
-  filename: "delete/testtest.d.ts",
-  where: ".silgi",
-  getContents: ({ app }) => {
-    if (!app.options.typescript.shim) {
-      return "";
-    }
-    return [
-      "declare module '*.vue' {",
-      "  import { DefineComponent } from 'vue'",
-      "  const component: DefineComponent<{}, {}, any>",
-      "  export default component",
-      "}"
-    ].join("\n");
-  }
-};
-const pluginsDeclaration = {
-  filename: "delete/testtest1.d.ts",
-  where: ".silgi",
-  getContents: async () => {
-    return `
-      declare module 'nuxt' {
-        interface NuxtApp {
-          $myPlugin: any;
-        }
-      }
-    `;
-  }
-};
-
-const defaultTemplates = {
-  __proto__: null,
-  pluginsDeclaration: pluginsDeclaration,
-  vueShim: vueShim
-};
-
-const postTemplates = [
-  pluginsDeclaration.filename
-];
-const logger = useLogger("silgi");
-async function generateApp(app, options = {}) {
-  app.templates = Object.values(defaultTemplates).concat(app.options.build.templates);
-  await app.callHook("app:templates", app);
-  app.templates = app.templates.map((tmpl) => {
-    const dir = tmpl.where === ".silgi" ? app.options.build.dir : tmpl.where === "server" ? app.options.silgi.serverDir : tmpl.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
-    return normalizeTemplate(tmpl, dir);
-  });
-  const filteredTemplates = {
-    pre: [],
-    post: []
-  };
-  for (const template of app.templates) {
-    if (options.filter && !options.filter(template)) {
-      continue;
-    }
-    const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
-    filteredTemplates[key].push(template);
-  }
-  const templateContext = { app };
-  const writes = [];
-  const dirs = /* @__PURE__ */ new Set();
-  const changedTemplates = [];
-  async function processTemplate(template) {
-    const dir = template.where === ".silgi" ? app.options.build.dir : template.where === "server" ? app.options.silgi.serverDir : template.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
-    const fullPath = template.dst || resolve(dir, template.filename);
-    const start = performance.now();
-    const contents = await compileTemplate(template, templateContext).catch((e) => {
-      logger.error(`Could not compile template \`${template.filename}\`.`);
-      logger.error(e);
-      throw e;
-    });
-    template.modified = true;
-    if (template.modified) {
-      changedTemplates.push(template);
-    }
-    const perf = performance.now() - start;
-    const setupTime = Math.round(perf * 100) / 100;
-    if (app.options.debug || setupTime > 500) {
-      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
-    }
-    if (template.modified && template.write) {
-      dirs.add(dirname(fullPath));
-      if (template.skipIfExists && existsSync(fullPath)) {
-        return;
-      }
-      writes.push(() => writeFileSync(fullPath, contents, "utf8"));
-    }
-  }
-  await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
-  await Promise.allSettled(filteredTemplates.post.map(processTemplate));
-  for (const dir of dirs) {
-    mkdirSync(dir, { recursive: true });
-  }
-  for (const write of writes) {
-    if (!app.errors.length) {
-      write();
-    }
-  }
-  if (changedTemplates.length) {
-    await app.callHook("app:templatesGenerated", app, changedTemplates, options);
-  }
-}
-async function compileTemplate(template, ctx) {
-  delete ctx.utils;
-  if (template.src) {
-    try {
-      return await promises.readFile(template.src, "utf-8");
-    } catch (err) {
-      logger.error(`[nuxt] Error reading template from \`${template.src}\``);
-      throw err;
-    }
-  }
-  if (template.getContents) {
-    return template.getContents({
-      ...ctx,
-      options: template.options
-    });
-  }
-  throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
-}
-
-async function installPackages(silgi) {
-  const packages = {
-    dependencies: {
-      "@fastify/deepmerge": peerDependencies["@fastify/deepmerge"],
-      "@silgi/ecosystem": peerDependencies["@silgi/ecosystem"],
-      ...silgi.options.installPackages?.dependencies
-    },
-    devDependencies: {
-      ...silgi.options.installPackages?.devDependencies
-    }
-  };
-  await silgi.callHook("prepare:installPackages", packages);
-  if (silgi.options.preset === "npm-package") {
-    packages.devDependencies = {
-      ...packages.devDependencies,
-      ...packages.dependencies
-    };
-    packages.dependencies = {};
-  }
-  addTemplate({
-    filename: "install.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(packages, null, 2)
-  });
-}
-
-function useCLIRuntimeConfig(silgi) {
-  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
-  silgi.hook("prepare:configs.ts", (data) => {
-    data.runtimeConfig = safeRuntimeConfig;
-    silgi.options.envOptions = silgi.options.envOptions;
-  });
-  const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
-  silgi.options.runtimeConfig = _sharedRuntimeConfig;
-  return _sharedRuntimeConfig;
-}
-
-const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-async function scanAndSyncOptions(silgi) {
-  const scannedModules = await scanModules$1(silgi);
-  silgi.options.modules = silgi.options.modules || [];
-  for (const modPath of scannedModules) {
-    if (!silgi.options.modules.includes(modPath)) {
-      silgi.options.modules.push(modPath);
-    }
-  }
-}
-async function scanModules$1(silgi) {
-  const files = await scanFiles(silgi, "silgi/modules");
-  return files.map((f) => f.fullPath);
-}
-async function scanFiles(silgi, name) {
-  const files = await Promise.all(
-    silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))
-  ).then((r) => r.flat());
-  return files;
-}
-async function scanDir(silgi, dir, name) {
-  const fileNames = await globby(join(name, GLOB_SCAN_PATTERN), {
-    cwd: dir,
-    dot: true,
-    ignore: silgi.options.ignore,
-    absolute: true
-  });
-  return fileNames.map((fullPath) => {
-    return {
-      fullPath,
-      path: relative(join(dir, name), fullPath)
-    };
-  }).sort((a, b) => a.path.localeCompare(b.path));
-}
-
-async function emptyFramework(silgi) {
-  if (silgi.options.preset === "npm-package" || !silgi.options.preset) {
-    silgi.hook("after:prepare:schema.ts", (data) => {
-      data.unshift("type FrameworkContextExtends = {}");
-    });
-  }
-}
-
-async function h3Framework(silgi, skip = false) {
-  if (silgi.options.preset !== "h3" && skip === false)
-    return;
-  if (silgi.options.preset === "h3") {
-    silgi.hook("after:prepare:schema.ts", (data) => {
-      data.unshift("type FrameworkContextExtends = NitroApp");
-    });
-  }
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.importItems.h3 = {
-      import: [
-        {
-          name: "H3Event",
-          type: true,
-          key: "H3Event"
-        }
-      ],
-      from: "h3"
-    };
-    data.events.push({
-      key: "H3Event",
-      value: "H3Event",
-      extends: true,
-      isSilgiContext: false
-    });
-  });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["silgi/types"] = {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "h3" {',
-      "  interface H3EventContext extends SilgiRuntimeContext {}",
-      "}",
-      ""
-    );
-  });
-  silgi.hook("prepare:core.ts", (data) => {
-    data._silgiConfigs.push(`captureError: (error, context = {}) => {
-        const promise = silgi.hooks
-          .callHookParallel('error', error, context)
-          .catch((error_) => {
-            console.error('Error while capturing another error', error_)
-          })
-  
-        if (context.event && isEvent(context.event)) {
-          const errors = context.event.context.nitro?.errors
-          if (errors) {
-            errors.push({ error, context })
-          }
-          if (context.event.waitUntil) {
-            context.event.waitUntil(promise)
-          }
-        }
-      }`);
-  });
-  if (silgi.options.imports !== false) {
-    const h3Exports = await resolveModuleExportNames("h3", {
-      url: import.meta.url
-    });
-    silgi.options.imports.presets ??= [];
-    silgi.options.imports.presets.push({
-      from: "h3",
-      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
-    });
-  }
-}
-
-async function nitroFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nitro" && skip === false)
-    return;
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
-        }
-      ],
-      from: "nitropack/types"
-    };
-  });
-  silgi.hook("after:prepare:schema.ts", (data) => {
-    data.unshift("type FrameworkContextExtends = NitroApp");
-  });
-  silgi.options.plugins.push({
-    packageImport: "silgi/runtime/internal/nitro",
-    path: join(runtimeDir, "internal/nitro")
-  });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["nitropack/types"] = {
-      import: [
-        {
-          name: "NitroRuntimeConfig",
-          type: true,
-          key: "NitroRuntimeConfig"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "silgi/types" {',
-      "  interface SilgiRuntimeConfig extends NitroRuntimeConfig {}",
-      "}",
-      ""
-    );
-  });
-  if (silgi.options.imports !== false) {
-    silgi.options.imports.presets ??= [];
-    silgi.options.imports.presets.push(...getNitroImportsPreset());
-  }
-  await h3Framework(silgi, true);
-}
-function getNitroImportsPreset() {
-  return [
-    {
-      from: "nitropack/runtime/internal/app",
-      imports: ["useNitroApp"]
-    },
-    {
-      from: "nitropack/runtime/internal/config",
-      imports: ["useRuntimeConfig", "useAppConfig"]
-    },
-    {
-      from: "nitropack/runtime/internal/plugin",
-      imports: ["defineNitroPlugin", "nitroPlugin"]
-    },
-    {
-      from: "nitropack/runtime/internal/cache",
-      imports: [
-        "defineCachedFunction",
-        "defineCachedEventHandler",
-        "cachedFunction",
-        "cachedEventHandler"
-      ]
-    },
-    {
-      from: "nitropack/runtime/internal/storage",
-      imports: ["useStorage"]
-    },
-    {
-      from: "nitropack/runtime/internal/renderer",
-      imports: ["defineRenderHandler"]
-    },
-    {
-      from: "nitropack/runtime/internal/meta",
-      imports: ["defineRouteMeta"]
-    },
-    {
-      from: "nitropack/runtime/internal/route-rules",
-      imports: ["getRouteRules"]
-    },
-    {
-      from: "nitropack/runtime/internal/context",
-      imports: ["useEvent"]
-    },
-    {
-      from: "nitropack/runtime/internal/task",
-      imports: ["defineTask", "runTask"]
-    },
-    {
-      from: "nitropack/runtime/internal/error/utils",
-      imports: ["defineNitroErrorHandler"]
-    }
-  ];
-}
-
-async function nuxtFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nuxt" && skip === false)
-    return;
-  await nitroFramework(silgi, true);
-}
-
-const frameworkSetup = [emptyFramework, h3Framework, nitroFramework, nuxtFramework];
-
-async function registerModuleExportScan(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
-    for (const module of silgi.scanModules) {
-      const moduleReExports = [];
-      if (!module.entryPath) {
-        continue;
-      }
-      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
-      const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
-      for (const e of findTypeExports(normalisedModuleTypes)) {
-        moduleReExports.push(e);
-      }
-      for (const e of findExports(normalisedModuleTypes)) {
-        moduleReExports.push(e);
-      }
-      const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
-      const configKey = module.meta.configKey;
-      const moduleName = module.meta.name || module.meta._packageName;
-      options.importItems[configKey] = {
-        import: [],
-        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
-      };
-      if (hasTypeExport("ModuleOptions")) {
-        const importName = `_${hash(`${configKey}ModuleOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleOptions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.options.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeOptions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeOptions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.runtimeOptions.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeShareds")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeShareds`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeShareds as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.shareds.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleEvents")) {
-        const importName = `_${hash(`${configKey}ModuleEvents`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleEvents as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.events.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeContexts")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeContexts`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeContexts as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.contexts.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleHooks")) {
-        const importName = `_${hash(`${configKey}ModuleHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleHooks as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.hooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeHooks")) {
-        const importName = `_${hash(`${configKey}RuntimeHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeHooks as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.runtimeHooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeActions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeActions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeActions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.actions.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeMethods")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeMethods`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeMethods as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.methods.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeRouteRules")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRules`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRules as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.routeRules.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRulesConfig`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRulesConfig as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.routeRulesConfig.push({ key: configKey, value: importName });
-      }
-    }
-  });
-}
-
-async function loadSilgiModuleInstance(silgiModule) {
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-  }
-  return { silgiModule };
-}
-async function installModules(silgi, prepare = false) {
-  silgi.options.isPreparingModules = prepare;
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias,
-    fsCache: true,
-    moduleCache: true
-  });
-  for (const module of silgi.scanModules) {
-    if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) {
-      silgi.logger.info(`Module ${module.meta.configKey} installed`);
-    }
-    try {
-      const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
-        default: true,
-        conditions: silgi.options.conditions
-      }) : module.module;
-      if (silgiModule.name !== "silgiNormalizedModule") {
-        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
-        continue;
-      }
-      await installModule(silgiModule, silgi, prepare);
-    } catch (err) {
-      silgi.logger.error(err);
-    }
-  }
-  silgi.options.isPreparingModules = false;
-}
-async function installModule(moduleToInstall, silgi = useSilgi$1(), inlineOptions, prepare = false) {
-  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-  const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
-  if (res === false) {
-    return false;
-  }
-  const metaData = await silgiModule.getMeta?.();
-  if (prepare) {
-    return metaData;
-  }
-  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
-  if (installedModule) {
-    installedModule.installed = true;
-  } else {
-    throw new Error(`Module ${metaData?.name} not found`);
-  }
-}
-
-const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
-async function _resolveSilgiModule(silgiModule, silgi) {
-  let resolvedModulePath;
-  let buildTimeModuleMeta = {};
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias,
-    fsCache: true,
-    moduleCache: true
-  });
-  if (typeof silgiModule === "string") {
-    silgiModule = resolveAlias(silgiModule, silgi.options.alias);
-    if (isRelative(silgiModule)) {
-      silgiModule = resolve(silgi.options.rootDir, silgiModule);
-    }
-    try {
-      const src = resolveModuleURL(silgiModule, {
-        from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
-        suffixes: ["silgi", "silgi/index", "module", "module/index", "", "index"],
-        extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
-        // Maybe add https://github.com/unjs/exsolve/blob/dfff3e9bbc4a3a173a2d56b9b9ff731ab15598be/src/resolve.ts#L7
-        // conditions: silgi.options.conditions,
-      });
-      resolvedModulePath = fileURLToPath(src);
-      const resolvedSilgiModule = await jiti.import(src, { default: true });
-      if (typeof resolvedSilgiModule !== "function") {
-        throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
-      }
-      silgiModule = await jiti.import(src, {
-        default: true,
-        conditions: silgi.options.conditions
-      });
-      const moduleMetadataPath = new URL("module.json", src);
-      if (existsSync(moduleMetadataPath)) {
-        buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-      } else {
-        if (typeof silgiModule === "function") {
-          const meta = await silgiModule.getMeta?.();
-          const _exports = await scanExports(resolvedModulePath, true);
-          buildTimeModuleMeta = {
-            ...meta,
-            exports: _exports.map(({ from, ...rest }) => rest)
-          };
-        }
-      }
-    } catch (error) {
-      const code = error.code;
-      if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
-        throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-      }
-      if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-        const module = MissingModuleMatcher.exec(error.message)?.[1];
-        if (module && !module.includes(silgiModule)) {
-          throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
-        }
-      }
-    }
-  }
-  if (!buildTimeModuleMeta) {
-    throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
-  }
-  if (typeof silgiModule === "function") {
-    if (!buildTimeModuleMeta.configKey) {
-      const meta = await silgiModule.getMeta?.();
-      buildTimeModuleMeta = {
-        ...meta,
-        exports: []
-      };
-    }
-    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
-      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
-    }
-    const options = await silgiModule.getOptions?.() || {};
-    if (options) {
-      silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(
-        silgi.options._c12.config[buildTimeModuleMeta.configKey] || {},
-        options || {}
-      );
-    } else {
-      throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-    }
-    silgi.scanModules.push({
-      meta: buildTimeModuleMeta,
-      entryPath: resolvedModulePath || void 0,
-      installed: false,
-      options,
-      module: silgiModule
-    });
-  }
-}
-async function scanModules(silgi) {
-  const _modules = [
-    ...silgi.options._modules,
-    ...silgi.options.modules
-  ];
-  for await (const mod of _modules) {
-    await _resolveSilgiModule(mod, silgi);
-  }
-  const moduleMap = new Map(
-    silgi.scanModules.map((m) => [m.meta?.configKey, m])
-  );
-  const graphData = createDependencyGraph(silgi.scanModules);
-  const sortedKeys = topologicalSort(graphData);
-  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
-  silgi.scanModules = modules;
-}
-function createDependencyGraph(modules) {
-  const graph = /* @__PURE__ */ new Map();
-  const inDegree = /* @__PURE__ */ new Map();
-  modules.forEach((module) => {
-    const key = module.meta?.configKey;
-    if (key) {
-      graph.set(key, /* @__PURE__ */ new Set());
-      inDegree.set(key, 0);
-    }
-  });
-  modules.forEach((module) => {
-    const key = module.meta?.configKey;
-    if (!key) {
-      return;
-    }
-    const requiredDeps = module.meta?.requiredDependencies || [];
-    const beforeDeps = module.meta?.beforeDependencies || [];
-    const afterDeps = module.meta?.afterDependencies || [];
-    const processedDeps = /* @__PURE__ */ new Set();
-    requiredDeps.forEach((dep) => {
-      if (!graph.has(dep)) {
-        throw new Error(`Required dependency "${dep}" for module "${key}" is missing`);
-      }
-      graph.get(dep)?.add(key);
-      inDegree.set(key, (inDegree.get(key) || 0) + 1);
-      processedDeps.add(dep);
-    });
-    beforeDeps.forEach((dep) => {
-      if (!graph.has(dep)) {
-        return;
-      }
-      graph.get(key)?.add(dep);
-      inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
-    });
-    afterDeps.forEach((dep) => {
-      if (processedDeps.has(dep)) {
-        return;
-      }
-      if (!graph.has(dep)) {
-        return;
-      }
-      graph.get(dep)?.add(key);
-      inDegree.set(key, (inDegree.get(key) || 0) + 1);
-    });
-  });
-  return { graph, inDegree };
-}
-function findCyclicDependencies(graph) {
-  const visited = /* @__PURE__ */ new Set();
-  const recursionStack = /* @__PURE__ */ new Set();
-  const cycles = [];
-  function dfs(node, path = []) {
-    visited.add(node);
-    recursionStack.add(node);
-    path.push(node);
-    for (const neighbor of graph.get(node) || []) {
-      if (recursionStack.has(neighbor)) {
-        const cycleStart = path.indexOf(neighbor);
-        if (cycleStart !== -1) {
-          cycles.push([...path.slice(cycleStart), neighbor]);
-        }
-      } else if (!visited.has(neighbor)) {
-        dfs(neighbor, [...path]);
-      }
-    }
-    recursionStack.delete(node);
-    path.pop();
-  }
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      dfs(node, []);
-    }
-  }
-  return cycles;
-}
-function topologicalSort(graphData) {
-  const { graph, inDegree } = graphData;
-  const order = [];
-  const queue = [];
-  for (const [node, degree] of inDegree.entries()) {
-    if (degree === 0) {
-      queue.push(node);
-    }
-  }
-  while (queue.length > 0) {
-    const node = queue.shift();
-    order.push(node);
-    const neighbors = Array.from(graph.get(node) || []);
-    for (const neighbor of neighbors) {
-      const newDegree = (inDegree.get(neighbor) || 0) - 1;
-      inDegree.set(neighbor, newDegree);
-      if (newDegree === 0) {
-        queue.push(neighbor);
-      }
-    }
-  }
-  if (order.length !== graph.size) {
-    const cycles = findCyclicDependencies(graph);
-    if (cycles.length > 0) {
-      const cycleStr = cycles.map((cycle) => `  ${cycle.join(" -> ")}`).join("\n");
-      throw new Error(`Circular dependencies detected:
-${cycleStr}`);
-    } else {
-      const unresolvedModules = Array.from(graph.keys()).filter((key) => !order.includes(key));
-      throw new Error(`Unable to resolve dependencies for modules: ${unresolvedModules.join(", ")}`);
-    }
-  }
-  return order;
-}
-
-async function commands(silgi) {
-  const commands2 = {
-    ...silgi.options.commands
-  };
-  await silgi.callHook("prepare:commands", commands2);
-  addTemplate({
-    filename: "cli.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(commands2, null, 2)
-  });
-  silgi.commands = commands2;
-  silgi.hook("prepare:schema.ts", async (object) => {
-    const allTags = Object.values(commands2).reduce((acc, commandGroup) => {
-      Object.values(commandGroup).forEach((command) => {
-        if (command.tags) {
-          command.tags.forEach((tag) => acc.add(tag));
-        }
-      });
-      return acc;
-    }, /* @__PURE__ */ new Set());
-    const data = [
-      "",
-      generateTypes(
-        await resolveSchema(
-          {
-            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
-          }
-        ),
-        {
-          interfaceName: "SilgiCommandsExtended",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 0
-        }
-      ),
-      ""
-    ];
-    object.customImports?.push(...data);
-  });
-}
-
-function resolveIgnorePatterns(silgi, relativePath) {
-  if (!silgi) {
-    return [];
-  }
-  const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
-  const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
-  if (existsSync(nuxtignoreFile)) {
-    const contents = readFileSync(nuxtignoreFile, "utf-8");
-    ignorePatterns.push(...contents.trim().split(/\r?\n/));
-  }
-  return ignorePatterns;
-}
-function isIgnored(pathname, silgi, _stats) {
-  if (!silgi) {
-    return false;
-  }
-  if (!silgi._ignore) {
-    silgi._ignore = ignore(silgi.options.ignoreOptions);
-    silgi._ignore.add(resolveIgnorePatterns(silgi));
-  }
-  const relativePath = relative(silgi.options.rootDir, pathname);
-  if (relativePath[0] === "." && relativePath[1] === ".") {
-    return false;
-  }
-  return !!(relativePath && silgi._ignore.ignores(relativePath));
-}
-function resolveGroupSyntax(group) {
-  let groups = [group];
-  while (groups.some((group2) => group2.includes("{"))) {
-    groups = groups.flatMap((group2) => {
-      const [head, ...tail] = group2.split("{");
-      if (tail.length) {
-        const [body = "", ...rest] = tail.join("{").split("}");
-        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
-      }
-      return group2;
-    });
-  }
-  return groups;
-}
-
-const safeFiles = [
-  "silgi/configs",
-  "silgi",
-  "silgi/rules",
-  "silgi/scan",
-  "silgi/vfs"
-];
-class SchemaParser {
-  options = {
-    debug: false
-  };
-  /**
-   *
-   */
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  parseExports(content, filePath) {
-    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
-    if (this.options.debug)
-      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
-    return {
-      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
-      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
-      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
-    };
-  }
-  parseVariableDeclaration(ast, path) {
-    const silgi = useSilgi$1();
-    if (ast.program.body.length === 0) {
-      if (safeFiles.find((i) => path.includes(i)))
-        return [];
-      silgi.errors.push({
-        type: "Parser",
-        path
-      });
-      consola$1.warn("This file has a problem:", path);
-    }
-    const variableDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
-    return variableDeclarations;
-  }
-  parseTSInterfaceDeclaration(ast, path = "") {
-    const silgi = useSilgi$1();
-    if (ast.program.body.length === 0) {
-      if (safeFiles.find((i) => path.includes(i)))
-        return [];
-      silgi.errors.push({
-        type: "Parser",
-        path
-      });
-      consola$1.warn("This file has a problem:", path);
-    }
-    const interfaceDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
-    return interfaceDeclarations;
-  }
-  parseTypeDeclarations(ast, find = "", path = "") {
-    const data = [];
-    const variableDeclarations = this.parseVariableDeclaration(ast, path);
-    for (const item of variableDeclarations) {
-      for (const declaration of item.declaration.declarations) {
-        if (declaration.init?.callee?.name === find) {
-          const options = {};
-          if (declaration.init.arguments) {
-            for (const argument of declaration.init.arguments) {
-              for (const propertie of argument.properties) {
-                if (propertie.key.name === "name")
-                  options.pluginName = propertie.value.value;
-              }
-            }
-          }
-          for (const key in declaration.init.properties) {
-            const property = declaration.init.properties[key];
-            if (property.type === "ObjectProperty") {
-              if (property.key.name === "options") {
-                for (const key2 in property.value.properties) {
-                  const option = property.value.properties[key2];
-                  if (option.type === "ObjectProperty") {
-                    options[option.key.name] = option.value.value;
-                  }
-                }
-              }
-            }
-          }
-          options.type = false;
-          data.push({
-            exportName: declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  parseInterfaceDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseTSInterfaceDeclaration(ast, path)) {
-      if (!item?.declaration?.extends)
-        continue;
-      for (const declaration of item?.declaration?.extends) {
-        if (declaration.expression.name === find) {
-          const options = {};
-          options.type = true;
-          data.push({
-            exportName: item.declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  // private parsePlugin(ast: any, path: string = '') {
-  //   const data = {
-  //     export: [],
-  //     name: '',
-  //     path: '',
-  //   } as DataTypePlugin
-  //   for (const item of this.parseVariableDeclaration(ast)) {
-  //     for (const declaration of item.declaration.declarations) {
-  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
-  //         if (declaration.init.arguments) {
-  //           for (const argument of declaration.init.arguments) {
-  //             for (const propertie of argument.properties) {
-  //               if (propertie.key.name === 'name')
-  //                 data.name = propertie.value.value
-  //             }
-  //           }
-  //         }
-  //         data.export.push({
-  //           name: data.name,
-  //           as: camelCase(`${data.name}DefineSilgiModule`),
-  //           type: false,
-  //         })
-  //       }
-  //     }
-  //   }
-  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
-  //     if (!item?.declaration?.extends)
-  //       continue
-  //     for (const declaration of item?.declaration?.extends) {
-  //       if (declaration.expression.name === 'ModuleOptions') {
-  //         data.export.push({
-  //           name: item.declaration.id.name,
-  //           as: camelCase(`${data.name}ModuleOptions`),
-  //           type: true,
-  //         })
-  //       }
-  //       // TODO add other plugins
-  //     }
-  //   }
-  //   data.path = path
-  //   return data
-  // }
-}
-
-async function scanExportFile(silgi) {
-  const filePaths = /* @__PURE__ */ new Set();
-  const scannedPaths = [];
-  const dir = silgi.options.serverDir;
-  const files = (await globby(dir, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
-  if (files.length) {
-    const siblings = await readdir(dirname(dir)).catch(() => []);
-    const directory = basename(dir);
-    if (!siblings.includes(directory)) {
-      const directoryLowerCase = directory.toLowerCase();
-      const caseCorrected = siblings.find((sibling) => sibling.toLowerCase() === directoryLowerCase);
-      if (caseCorrected) {
-        const original = relative(silgi.options.serverDir, dir);
-        const corrected = relative(silgi.options.serverDir, join(dirname(dir), caseCorrected));
-        consola.warn(`Components not scanned from \`~/${corrected}\`. Did you mean to name the directory \`~/${original}\` instead?`);
-      }
-    }
-  }
-  for (const _file of files) {
-    const filePath = resolve(dir, _file);
-    if (scannedPaths.find((d) => filePath.startsWith(withTrailingSlash(d))) || isIgnored(filePath, silgi)) {
-      continue;
-    }
-    if (filePaths.has(filePath)) {
-      continue;
-    }
-    filePaths.add(filePath);
-    if (silgi.options.extensions.includes(extname(filePath))) {
-      const parser = new SchemaParser({
-        debug: false
-      });
-      const readfile = await readFile(filePath, "utf-8");
-      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
-      const createServices = exportVariables("createService", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      const scanTS = [];
-      const schemaTS = [];
-      if (createServices.length > 0) {
-        scanTS.push(...createServices.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "service" };
-        }));
-      }
-      const createSchemas = exportVariables("createSchema", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (createSchemas.length > 0) {
-        scanTS.push(...createSchemas.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "schema" };
-        }));
-      }
-      const createShareds = exportVariables("createShared", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (createShareds.length > 0) {
-        scanTS.push(...createShareds.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "shared" };
-        }));
-      }
-      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (sharedsTypes.length > 0) {
-        schemaTS.push(...sharedsTypes.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "shared" };
-        }));
-      }
-      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (contextTypes.length > 0) {
-        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "context" };
-        }));
-      }
-      silgi.hook("prepare:scan.ts", (options) => {
-        for (const { exportName, path, _name, type } of scanTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "service") {
-            options.services.push(_name);
-          }
-          if (type === "shared") {
-            options.shareds.push(_name);
-          }
-          if (type === "schema") {
-            options.schemas.push(_name);
-          }
-          options.importItems[path] ??= {
-            import: [],
-            from: relativeWithDot(silgi.options.silgi.serverDir, path)
-          };
-          options.importItems[path].import.push({
-            name: `${exportName} as ${_name}`,
-            key: _name
-          });
-        }
-      });
-      silgi.hook("prepare:schema.ts", (options) => {
-        for (const { exportName, path, _name, type } of schemaTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "shared") {
-            options.shareds.push({
-              key: _name,
-              value: _name
-            });
-          }
-          if (type === "context") {
-            options.contexts.push({
-              key: _name,
-              value: _name
-            });
-          }
-          options.importItems[path] ??= {
-            import: [],
-            from: relativeWithDot(silgi.options.build.typesDir, path)
-          };
-          options.importItems[path].import.push({
-            name: `${exportName} as ${_name}`,
-            key: _name
-          });
-        }
-      });
-    }
-  }
-}
-
-function buildUriMap(silgi, currentPath = []) {
-  const uriMap = /* @__PURE__ */ new Map();
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let pathString = "";
-      if (node.pathParams) {
-        let paths = null;
-        if (node.pathParams?._def?.typeName !== void 0) {
-          try {
-            const shape = node.pathParams?.shape;
-            paths = shape ? Object.keys(shape) : null;
-          } catch {
-            paths = null;
-          }
-        }
-        if (paths?.length) {
-          pathString = paths.map((p) => `:${p}`).join("/");
-        }
-      }
-      uriMap.set(basePath, pathString);
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(silgi.schemas, currentPath);
-  silgi.uris = defu$1(silgi.uris, Object.fromEntries(uriMap));
-  return uriMap;
-}
-
-async function readScanFile(silgi) {
-  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  silgi.unimport = createUnimport(silgi.options.imports || {});
-  await silgi.unimport.init();
-  const injectedResult = await silgi.unimport.injectImports(context, path);
-  if (!injectedResult) {
-    throw new Error("Failed to inject imports");
-  }
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: true,
-    moduleCache: false,
-    debug: silgi.options.debug,
-    alias: silgi.options.alias
-  });
-  try {
-    if (silgi.options.commandType === "prepare") {
-      globalThis.$silgiSharedRuntimeConfig = silgi.options.runtimeConfig;
-      injectedResult.code = `globalThis.$silgiSharedRuntimeConfig = ${JSON.stringify(silgi.options.runtimeConfig)};
-${injectedResult.code}`;
-      injectedResult.code = injectedResult.code.replace(/runtimeConfig: \{\}/, `runtimeConfig: ${JSON.stringify(silgi.options.runtimeConfig)}`);
-    }
-    const scanFile = await jiti.evalModule(
-      injectedResult.code,
-      {
-        filename: path,
-        async: true,
-        conditions: silgi.options.conditions
-      },
-      async (data, name) => {
-        return (await silgi.unimport.injectImports(data, name)).code;
-      }
-    );
-    silgi.uris = defu$1(silgi.uris, scanFile.uris) || {};
-    silgi.schemas = defu$1(scanFile.schemas, scanFile.uris) || {};
-    silgi.services = defu$1(scanFile.services, scanFile.uris) || {};
-    silgi.shareds = defu$1(scanFile.shareds, scanFile.shareds) || {};
-    silgi.modulesURIs = defu$1(scanFile.modulesURIs, scanFile.modulesURIs) || {};
-    return {
-      context,
-      object: {
-        schemas: scanFile.schemas,
-        uris: scanFile.uris,
-        services: scanFile.services,
-        shareds: scanFile.shareds,
-        modulesURIs: scanFile.modulesURIs
-      },
-      path
-    };
-  } catch (error) {
-    if (silgi.options.debug) {
-      console.error("Failed to read scan.ts file:", error);
-    } else {
-      if (error instanceof Error) {
-        consola.withTag("silgi").info(error.message);
-      }
-    }
-    return {
-      context,
-      object: {
-        schemas: {},
-        uris: {},
-        services: {},
-        shareds: {},
-        modulesURIs: {}
-      },
-      path
-    };
-  }
-}
-
-async function prepareServerFiles(silgi) {
-  const importItems = {
-    "silgi": {
-      import: [
-        { name: "createSilgi", key: "createSilgi" },
-        { name: "createShared", key: "createShared" }
-      ],
-      from: "silgi"
-    },
-    "silgi/types": {
-      import: [
-        { name: "SilgiRuntimeOptions", type: true, key: "SilgiRuntimeOptions" },
-        { name: "FrameworkContext", type: true, key: "FrameworkContext" }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "configs.ts": {
-      import: [
-        {
-          name: "cliConfigs",
-          type: false,
-          key: "cliConfigs"
-        }
-      ],
-      from: "./configs.ts"
-    }
-  };
-  const scanned = {
-    uris: {},
-    services: [],
-    shareds: [
-      `createShared({
-        modulesURIs,
-      })`
-    ],
-    schemas: [],
-    modulesURIs: {},
-    customImports: [],
-    importItems
-  };
-  if (silgi.uris) {
-    defu$1(scanned.uris, silgi.uris);
-  }
-  if (silgi.modulesURIs) {
-    defu$1(scanned.modulesURIs, silgi.modulesURIs);
-  }
-  await silgi.callHook("prepare:scan.ts", scanned);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
-  if (scanned.services.length > 0) {
-    importItems.silgi.import.push({ name: "mergeServices", key: "mergeServices" });
-  }
-  if (scanned.shareds.length > 0) {
-    importItems.silgi.import.push({ name: "mergeShared", key: "mergeShared" });
-  }
-  if (scanned.schemas.length > 0) {
-    importItems.silgi.import.push({ name: "mergeSchemas", key: "mergeSchemas" });
-  }
-  for (const key in importItems) {
-    importItems[key].import = deduplicateImportsByKey(importItems[key].import);
-  }
-  const importsContent = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
-    }),
-    "",
-    ...scanned.customImports,
-    ""
-  ];
-  const importData = [
-    `export const uris = ${JSON.stringify(scanned.uris, null, 2)}`,
-    "",
-    `export const modulesURIs = ${JSON.stringify(scanned.modulesURIs, null, 2)}`,
-    "",
-    scanned.schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
-    ...scanned.schemas.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.schemas.length > 0 ? "])" : "}",
-    "",
-    scanned.services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
-    ...scanned.services.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.services.length > 0 ? "])" : "}",
-    "",
-    scanned.shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
-    ...scanned.shareds.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.shareds.length > 0 ? "])" : "}",
-    ""
-  ];
-  await silgi.callHook("after:prepare:scan.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-function deduplicateImportsByKey(imports) {
-  const seenKeys = /* @__PURE__ */ new Map();
-  return imports.filter((item) => {
-    if (seenKeys.has(item.key)) {
-      return false;
-    }
-    seenKeys.set(item.key, true);
-    return true;
-  });
-}
-
-async function writeScanFiles(silgi) {
-  const data = await prepareServerFiles(silgi);
-  if (!silgi.errors.length) {
-    await writeFile(
-      resolve(silgi.options.silgi.serverDir, "scan.ts"),
-      data.join("\n")
-    );
-  }
-  await readScanFile(silgi);
-  buildUriMap(silgi);
-  parseServices(silgi);
-  silgi.hook("prepare:scan.ts", (file) => {
-    file.uris = {
-      ...file.uris,
-      ...silgi.uris
-    };
-    file.modulesURIs = {
-      ...file.modulesURIs,
-      ...silgi.modulesURIs
-    };
-  });
-}
-
-async function createStorageCLI(silgi) {
-  const storage = createStorage$1();
-  const runtime = useSilgiRuntimeConfig();
-  const mounts = klona({
-    ...silgi.options.storage,
-    ...silgi.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      const processedOpts = replaceRuntimeValues$1({ ...opts }, runtime);
-      storage.mount(path, driver(processedOpts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-
-async function createSilgi(config = {}, opts = {}) {
-  const options = await loadOptions(config, opts);
-  const hooks = createHooks();
-  const silgi = {
-    modulesURIs: {},
-    scannedURIs: /* @__PURE__ */ new Map(),
-    services: {},
-    uris: {},
-    shareds: {},
-    schemas: {},
-    unimport: void 0,
-    options,
-    hooks,
-    errors: [],
-    commands: {},
-    _requiredModules: {},
-    logger: consola.withTag("silgi"),
-    close: () => silgi.hooks.callHook("close", silgi),
-    storage: void 0,
-    scanModules: [],
-    templates: [],
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    async updateConfig(_config) {
-    },
-    routeRules: void 0
-  };
-  await prepareEnv(options);
-  const routeRules = createRouteRules();
-  routeRules.importRules(options.routeRules ?? {});
-  silgi.routeRules = routeRules;
-  if (silgiCtx$1.tryUse()) {
-    silgiCtx$1.unset();
-    silgiCtx$1.set(silgi);
-  } else {
-    silgiCtx$1.set(silgi);
-    silgi.hook("close", () => silgiCtx$1.unset());
-  }
-  if (silgi.options.debug) {
-    createDebugger(silgi.hooks, { tag: "silgi" });
-    silgi.options.plugins.push({
-      path: join(runtimeDir, "internal/debug"),
-      packageImport: "silgi/runtime/internal/debug"
-    });
-  }
-  for (const framework of frameworkSetup) {
-    await framework(silgi);
-  }
-  await scanAndSyncOptions(silgi);
-  await scanModules(silgi);
-  await scanExportFile(silgi);
-  await installModules(silgi, true);
-  useCLIRuntimeConfig(silgi);
-  await writeScanFiles(silgi);
-  silgi.storage = await createStorageCLI(silgi);
-  silgi.hooks.hook("close", async () => {
-    await silgi.storage.dispose();
-  });
-  if (silgi.options.logLevel !== void 0) {
-    silgi.logger.level = silgi.options.logLevel;
-  }
-  silgi.hooks.addHooks(silgi.options.hooks);
-  await installModules(silgi);
-  await silgi.hooks.callHook("scanFiles:done", silgi);
-  await commands(silgi);
-  await installPackages(silgi);
-  await generateApp(silgi);
-  if (silgi.options.imports) {
-    silgi.options.imports.dirs ??= [];
-    silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
-      if (typeof dir === "string") {
-        if (dir.startsWith("!")) {
-          return `!${resolveSilgiPath$1(dir.slice(1), options, silgi.options.rootDir)}`;
-        }
-        return resolveSilgiPath$1(dir, options, silgi.options.rootDir);
-      }
-      return dir;
-    });
-    silgi.options.imports.presets.push({
-      from: "silgi/types",
-      imports: autoImportTypes$1.map((type) => type),
-      type: true
-    });
-    silgi.options.imports.presets.push({
-      from: "silgi/types",
-      imports: autoImportTypes$1.map((type) => type),
-      type: true
-    });
-    silgi.options.imports.presets.push({
-      from: "silgi/runtime/internal/ofetch",
-      imports: ["createSilgiFetch", "silgi$fetch"]
-    });
-    silgi.unimport = createUnimport(silgi.options.imports);
-    await silgi.unimport.init();
-  }
-  await registerModuleExportScan(silgi);
-  await writeScanFiles(silgi);
-  return silgi;
-}
-
-async function prepareConfigs(silgi) {
-  const _data = {
-    runtimeConfig: {}
-  };
-  for (const module of silgi.scanModules) {
-    if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) {
-      for (const key of module.meta.cliToRuntimeOptionsKeys) {
-        _data[module.meta.configKey] = {
-          ..._data[module.meta.configKey],
-          [key]: module.options[key]
-        };
-      }
-    } else {
-      _data[module.meta.configKey] = {};
-    }
-  }
-  await silgi.callHook("prepare:configs.ts", _data);
-  const importData = [
-    "import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
-    "import { useSilgiRuntimeConfig } from 'silgi/runtime'",
-    "",
-    `export const runtimeConfig: Partial<SilgiRuntimeConfig> = ${genObjectFromRawEntries(
-      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
-      ""
-    )}`,
-    "",
-    "const runtime = useSilgiRuntimeConfig(undefined, runtimeConfig)",
-    ""
-  ];
-  delete _data.runtimeConfig;
-  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
-    Object.entries(_data).map(
-      ([key, value]) => [key, genEnsureSafeVar(value)]
-    ).concat(
-      [
-        ["runtimeConfig", "runtime"]
-      ]
-    )
-  )}`);
-  return importData;
-}
-
-async function prepareCoreFile(data, frameworkContext, silgi) {
-  let importItems = {
-    "silgi": {
-      import: [
-        {
-          name: "createSilgi",
-          key: "createSilgi"
-        }
-      ],
-      from: "silgi"
-    },
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeOptions",
-          type: true,
-          key: "SilgiRuntimeOptions"
-        },
-        {
-          name: "FrameworkContext",
-          type: true,
-          key: "FrameworkContext"
-        },
-        {
-          name: "SilgiOptions",
-          type: true,
-          key: "SilgiOptions"
-        }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "scan.ts": {
-      import: [
-        {
-          name: "uris",
-          type: false,
-          key: "uris"
-        },
-        {
-          name: "services",
-          type: false,
-          key: "services"
-        },
-        {
-          name: "shareds",
-          type: false,
-          key: "shareds"
-        },
-        {
-          name: "schemas",
-          type: false,
-          key: "schemas"
-        },
-        {
-          name: "modulesURIs",
-          type: false,
-          key: "modulesURIs"
-        }
-      ],
-      from: "./scan.ts"
-    },
-    "configs.ts": {
-      import: [
-        {
-          name: "cliConfigs",
-          type: false,
-          key: "cliConfigs"
-        }
-      ],
-      from: "./configs.ts"
-    },
-    "rules.ts": {
-      import: [
-        {
-          name: "routeRules",
-          key: "routeRules"
-        }
-      ],
-      from: "./rules.ts"
-    }
-  };
-  importItems = { ...data._importItems, ...importItems };
-  const _data = {
-    customImports: data._customImports || [],
-    buildSilgiExtraContent: [],
-    beforeBuildSilgiExtraContent: [],
-    afterCliOptions: [],
-    _silgiConfigs: [],
-    customContent: [],
-    importItems
-  };
-  await silgi.callHook("prepare:core.ts", _data);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
-  const plugins = [];
-  for (const plugin of silgi.options.plugins) {
-    const pluginImportName = `_${hash(plugin.packageImport)}`;
-    _data.customImports.push(`import ${pluginImportName} from '${plugin.packageImport}'`);
-    plugins.push(pluginImportName);
-  }
-  const importsContent = [
-    'import deepmerge from "@fastify/deepmerge"',
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
-    }),
-    "",
-    ..._data.customImports,
-    ""
-  ];
-  const importData = [
-    "",
-    "const mergeDeep = deepmerge({all: true})",
-    "",
-    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<SilgiRuntimeOptions>,buildOptions?: Partial<SilgiOptions>) {",
-    "",
-    _data.beforeBuildSilgiExtraContent.length > 0 ? _data.beforeBuildSilgiExtraContent.map(({ value, type }) => {
-      return type === "function" ? value : `const ${value}`;
-    }) : "",
-    "",
-    "  const silgi = await createSilgi({",
-    "      framework,",
-    "      shared: shareds as any,",
-    "      services: services as any,",
-    "      schemas: schemas as any,",
-    "      uris,",
-    "      modulesURIs,",
-    `      plugins: [${plugins.join(", ")}],`,
-    _data._silgiConfigs.length > 0 ? `      ${_data._silgiConfigs.map((config) => typeof config === "string" ? config : typeof config === "object" ? Object.entries(config).map(([key, value]) => `${key}: ${value}`).join(",\n      ") : "").join(",\n      ")},` : "",
-    "      options: mergeDeep(",
-    "        {",
-    "        runtimeConfig: {} as SilgiRuntimeOptions,",
-    "        routeRules: routeRules as any,",
-    "        },",
-    "        moduleOptions || {},",
-    "        {",
-    `          present: '${silgi.options.preset}',`,
-    "          ...cliConfigs,",
-    "        },",
-    "        buildOptions,",
-    "      ) as any,",
-    "    })",
-    "",
-    ...frameworkContext,
-    "",
-    ..._data.buildSilgiExtraContent,
-    "",
-    "  return silgi",
-    "}",
-    ""
-  ];
-  await silgi.callHook("after:prepare:core.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-
-async function prepareFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const functions = [];
-  await silgi.callHook("prepare:createCoreFramework", {
-    importItems,
-    customImports,
-    functions
-  });
-  const content = [
-    ...functions.map((f) => f.params?.length ? ` await ${f.name}(framework, ${f.params.join(",")})` : ` await ${f.name}(framework)`)
-  ];
-  return {
-    content,
-    importItems,
-    customImports
-  };
-}
-async function createDTSFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const customContent = [];
-  await silgi.callHook("prepare:createDTSFramework", {
-    importItems,
-    customImports,
-    customContent
-  });
-  const content = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
-async function writeCoreFile(silgi) {
-  const data = await prepareFramework(silgi);
-  const coreContent = await prepareCoreFile({
-    _importItems: data?.importItems ?? {},
-    _customImports: data?.customImports ?? []
-  }, data?.content ?? [], silgi);
-  const configs = await prepareConfigs(silgi);
-  const silgiDir = resolve(silgi.options.silgi.serverDir);
-  const buildFiles = [];
-  buildFiles.push({
-    path: join(silgiDir, "core.ts"),
-    contents: coreContent.join("\n")
-  });
-  buildFiles.push({
-    path: join(silgiDir, "configs.ts"),
-    contents: configs.join("\n")
-  });
-  for await (const file of buildFiles) {
-    if (!silgi.errors.length) {
-      await writeFile(
-        resolve(silgi.options.build.dir, file.path),
-        file.contents
-      );
-    }
-  }
-}
-
-async function generateRouterDTS(silgi) {
-  const uris = silgi.uris;
-  const subPath = "srn";
-  const groupedPaths = /* @__PURE__ */ new Map();
-  Object.entries(uris || {}).forEach(([key, params]) => {
-    const [service, resource, method, action] = key.split("/");
-    const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
-    const fullPath = `${subPath}/${service}/${resource}/${action}`;
-    if (!groupedPaths.has(basePath)) {
-      groupedPaths.set(basePath, /* @__PURE__ */ new Map());
-    }
-    groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
-  });
-  const keys = [
-    "  keys: {",
-    Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
-      return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
-      ${method}: '/${path}'`).join(",")}
-    }`;
-    }).join(",\n"),
-    "  }",
-    ""
-  ].join("\n");
-  const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
-    const [service, resource, method, action] = key.split("/");
-    const routePath = `${subPath}/${service}/${resource}/${action}`;
-    if (!acc[routePath]) {
-      acc[routePath] = {};
-    }
-    acc[routePath][method] = {
-      input: `ExtractInputFromURI<'${key}'>`,
-      output: `ExtractOutputFromURI<'${key}'>`,
-      queryParams: `ExtractQueryParamsFromURI<'${key}'>`,
-      pathParams: `ExtractPathParamsFromURI<'${key}'>`
-    };
-    return acc;
-  }, {});
-  const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
-    const methodEntries = Object.entries(methods).map(([method, { input, output, queryParams, pathParams }]) => {
-      return `    '${method}': {
-      input: ${input},
-      output: ${output},
-      queryParams: ${queryParams},
-      pathParams: ${pathParams}
-    }`;
-    }).join(",\n");
-    return `  '/${path}': {
-${methodEntries}
-  }`;
-  });
-  const nitro = [
-    "declare module 'nitropack/types' {",
-    "  interface InternalApi extends RouterTypes {}",
-    "}"
-  ];
-  const content = [
-    keys.slice(0, -1),
-    // son satırdaki boş satırı kaldır
-    ...routerTypes
-  ].join(",\n");
-  const context = [
-    "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractQueryParamsFromURI, ExtractPathParamsFromURI } from 'silgi/types'",
-    "",
-    "export interface RouterTypes {",
-    content,
-    "}",
-    "",
-    "declare module 'silgi/types' {",
-    "  interface SilgiRouterTypes extends RouterTypes {",
-    "  }",
-    "}",
-    "",
-    silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
-    "",
-    "export {}"
-  ];
-  return context;
-}
-
-async function prepareSchema(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "URIsTypes",
-          type: true,
-          key: "URIsTypes"
-        },
-        {
-          name: "Namespaces",
-          type: true,
-          key: "Namespaces"
-        },
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    },
-    "silgi/scan": {
-      import: [{
-        key: "modulesURIs",
-        name: "modulesURIs",
-        type: false
-      }],
-      from: relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`)
-    }
-  };
-  const data = {
-    importItems,
-    customImports: [],
-    options: [],
-    contexts: [],
-    actions: [],
-    shareds: [
-      {
-        key: "modulesURIs",
-        value: "{ modulesURIs: typeof modulesURIs }"
-      }
-    ],
-    events: [],
-    hooks: [],
-    runtimeHooks: [],
-    runtimeOptions: [],
-    methods: [],
-    routeRules: [],
-    routeRulesConfig: []
-  };
-  await silgi.callHook("prepare:schema.ts", data);
-  relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
-  const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`);
-  let addSilgiContext = false;
-  const importsContent = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...data.customImports,
-    ""
-  ];
-  const importData = [
-    "interface InferredNamespaces {",
-    ...(silgi.options.namespaces || []).map((key) => `  ${key}: string,`),
-    "}",
-    "",
-    `type SchemaExtends = Namespaces<typeof import('${silgiScanTS}')['schemas']>`,
-    "",
-    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiScanTS}')['uris']>`,
-    "",
-    `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
-    "",
-    data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
-      ${data.events.map((item) => {
-      if (item.isSilgiContext) {
-        addSilgiContext = true;
-      }
-      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiRuntimeContext" : "";
-    }).join(",\n")}
-}` : "interface SilgiModuleEventsExtends {}",
-    "",
-    `type RuntimeActionExtends = ${data.actions?.length ? data.actions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type RuntimeRouteRulesExtends = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type RuntimeRouteRulesConfigExtends = ${data.routeRulesConfig?.length ? data.routeRulesConfig.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type SilgiModuleSharedExtends = ${data.shareds.length ? data.shareds.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type SilgiModuleOptionExtend = ${data.options?.length ? data.options.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(
-      await resolveSchema(
-        {
-          ...Object.fromEntries(
-            Object.entries(silgi.options.runtimeConfig).filter(
-              ([key]) => !["app", "nitro", "nuxt"].includes(key)
-            )
-          )
-        }
-      ),
-      {
-        interfaceName: "SilgiRuntimeConfigExtends",
-        addExport: false,
-        addDefaults: false,
-        allowExtraKeys: false,
-        indentation: 0
-      }
-    ) : "",
-    "",
-    generateTypes(
-      await resolveSchema(
-        {
-          ...silgi.options.storages?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {},
-          // 'redis': {} -> 'redis': string
-          ...Object.entries(silgi.options.storage).map(([key]) => ({
-            [key]: ""
-          })).reduce((acc, obj) => ({ ...acc, ...obj }), {})
-        }
-      ),
-      {
-        interfaceName: "SilgiStorageBaseExtends",
-        addExport: false,
-        addDefaults: false,
-        allowExtraKeys: false,
-        indentation: 0
-      }
-    ),
-    "",
-    `type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    "declare module 'silgi/types' {",
-    " interface FrameworkContext extends FrameworkContextExtends {}",
-    " interface SilgiSchema extends SchemaExtends {}",
-    " interface SilgiNamespaces extends InferredNamespaces {}",
-    " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
-    " interface SilgiURIs extends SilgiURIsMerge {}",
-    " interface SilgiRuntimeContext extends SilgiModuleContextExtends {}",
-    " interface SilgiEvents extends SilgiModuleEventsExtends {}",
-    " interface SilgiRuntimeSharedsExtend extends SilgiModuleSharedExtends {}",
-    " interface SilgiRuntimeActions extends RuntimeActionExtends {}",
-    " interface SilgiModuleOptions extends SilgiModuleOptionExtend {}",
-    " interface SilgiRuntimeOptions extends SilgiRuntimeOptionExtends {}",
-    " interface SilgiRuntimeHooks extends SilgiRuntimeHooksExtends {}",
-    " interface SilgiRuntimeConfig extends SilgiRuntimeConfigExtends {}",
-    " interface SilgiHooks extends ModuleHooksExtend {}",
-    " interface SilgiRuntimeMethods extends RuntimeMethodExtends {}",
-    " interface SilgiRuntimeRouteRules extends RuntimeRouteRulesExtends {}",
-    " interface SilgiRuntimeRouteRulesConfig extends RuntimeRouteRulesConfigExtends {}",
-    " interface SilgiCommands extends SilgiCommandsExtended {}",
-    "",
-    "}",
-    "",
-    "export {}"
-  ];
-  await silgi.callHook("after:prepare:schema.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-
-async function writeTypesAndFiles(silgi) {
-  const routerDTS = await generateRouterDTS(silgi);
-  silgi.hook("prepare:types", (opts) => {
-    opts.references.push({ path: "./schema.d.ts" });
-    opts.references.push({ path: "./silgi-routes.d.ts" });
-    opts.references.push({ path: "./framework.d.ts" });
-  });
-  const schemaContent = await prepareSchema(silgi);
-  const frameworkDTS = await createDTSFramework(silgi);
-  const { declarations, tsConfig } = await silgiGenerateType(silgi);
-  const tsConfigPath = resolve(
-    silgi.options.rootDir,
-    silgi.options.typescript.tsconfigPath
-  );
-  const typesDir = resolve(silgi.options.build.typesDir);
-  let autoImportedTypes = [];
-  let autoImportExports = "";
-  if (silgi.unimport) {
-    await silgi.unimport.init();
-    const allImports = await silgi.unimport.getImports();
-    autoImportExports = toExports(allImports).replace(
-      /#internal\/nitro/g,
-      relative(typesDir, runtimeDir)
-    );
-    const resolvedImportPathMap = /* @__PURE__ */ new Map();
-    for (const i of allImports.filter((i2) => !i2.type)) {
-      if (resolvedImportPathMap.has(i.from)) {
-        continue;
-      }
-      let path = resolveAlias$1(i.from, silgi.options.alias);
-      if (isAbsolute(path)) {
-        const resolvedPath = await resolvePath(i.from, {
-          url: silgi.options.nodeModulesDirs
-        }).catch(() => null);
-        if (resolvedPath) {
-          const { dir, name } = parseNodeModulePath(resolvedPath);
-          if (!dir || !name) {
-            path = resolvedPath;
-          } else {
-            const subpath = await lookupNodeModuleSubpath(resolvedPath);
-            path = join(dir, name, subpath || "");
-          }
-        }
-      }
-      if (existsSync(path) && !await isDirectory(path)) {
-        path = path.replace(/\.[a-z]+$/, "");
-      }
-      if (isAbsolute(path)) {
-        path = relative(typesDir, path);
-      }
-      resolvedImportPathMap.set(i.from, path);
-    }
-    autoImportedTypes = [
-      silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
-        exportHelper: false,
-        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
-      })).trim() : ""
-    ];
-  }
-  const buildFiles = [];
-  buildFiles.push({
-    path: join(typesDir, "silgi-routes.d.ts"),
-    contents: routerDTS.join("\n")
-  });
-  buildFiles.push({
-    path: join(typesDir, "silgi-imports.d.ts"),
-    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
-      "\n"
-    )
-  });
-  buildFiles.push({
-    path: join(typesDir, "schema.d.ts"),
-    contents: schemaContent.join("\n")
-  });
-  buildFiles.push({
-    path: join(typesDir, "silgi.d.ts"),
-    contents: declarations.join("\n")
-  });
-  buildFiles.push({
-    path: tsConfigPath,
-    contents: JSON.stringify(tsConfig, null, 2)
-  });
-  buildFiles.push({
-    path: join(typesDir, "framework.d.ts"),
-    contents: frameworkDTS.content.join("\n")
-  });
-  for await (const file of buildFiles) {
-    if (!silgi.errors.length) {
-      await writeFile(
-        resolve(silgi.options.build.dir, file.path),
-        file.contents
-      );
-    }
-  }
-}
-
-const autoImportTypes = [
-  "ExtractInputFromURI",
-  "ExtractOutputFromURI",
-  "ExtractPathParamsFromURI",
-  "ExtractQueryParamsFromURI"
-];
-
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, autoImportTypes, createSchema, createService, createShared, createSilgi, createSilgiApp, createStorage, getEvent, getEventContext, isBaseError, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, prepare, prepareBuild, reloadScan, replaceRuntimeValues, setupDotenv, silgi, silgiAppCtx, silgiClose, silgiCtx, storageMount, tryUseSilgi, tryUseSilgiApp, useSilgi, useSilgiApp, useSilgiStorage, writeCoreFile, writeTypesAndFiles };
+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 } from './core/index.mjs';
+export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from './_chunks/silgiApp.mjs';
+import 'consola';
+import 'defu';
+import 'hookable';
+import 'unctx';
+import 'node:buffer';
+import 'klona';
+import 'silgi/runtime';
+import 'unstorage';
+import 'ufo';