silgi 0.42.5 → 0.43.0

package/dist/cli/build.mjs

@@ -1,2190 +0,0 @@
-import { consola } from 'consola';
-import { createHooks, createDebugger } from 'hookable';
-import { resolve, join, relative, extname, basename, dirname as dirname$1, isAbsolute } from 'pathe';
-import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
-import { isPresents, addTemplate, addCoreFile, genEnsureSafeVar, getServicePath, writeFile, relativeWithDot, hash, removeExtension, resolveAlias, directoryToURL, baseHeaderBannerComment, addImports, resolveSilgiPath, hasSilgiModule, normalizeTemplate, useLogger, toArray, isDirectory } from 'silgi/kit';
-import { initRuntimeConfig, useRuntimeConfig, sharedRuntimeConfig } from 'silgi/runtime';
-import { runtimeDir } from 'silgi/runtime/meta';
-import { scanExports, createUnimport, toExports } from 'unimport';
-import * as p from '@clack/prompts';
-import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import * as dotenv from 'dotenv';
-import { genImport, genTypeImport, genObjectFromRawEntries, genAugmentation } from 'knitwork';
-import { join as join$1, dirname } from 'node:path';
-import { findTypeExports, findExports, resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
-import { createJiti } from 'dev-jiti';
-import { h as hasInstalledModule } from './compatibility.mjs';
-import { fileURLToPath } from 'node:url';
-import { defu } from 'defu';
-import { resolveModuleURL } from 'exsolve';
-import { withTrailingSlash, isRelative } from 'ufo';
-import { readdir, readFile } from 'node:fs/promises';
-import micromatch from 'micromatch';
-import { parseAsync } from 'oxc-parser';
-import { glob } from 'tinyglobby';
-import ignore from 'ignore';
-import { snakeCase } from 'scule';
-import { klona } from 'klona';
-import { createStorage, builtinDrivers } from 'unstorage';
-import { l as loadOptions } from './loader.mjs';
-import { generateDTS } from 'apiful/openapi';
-import { u as useSilgiCLI$1 } from '../_chunks/silgiApp.mjs';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-import { generateTypes, resolveSchema } from 'untyped';
-import { s as silgiGenerateType } from './types.mjs';
-
-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));
-  }
-}
-
-let initialized = false;
-async function prepareEnv(silgiConfig) {
-  if (initialized)
-    return;
-  initialized = true;
-  const customEnvironments = silgiConfig.environments;
-  const environment = silgiConfig.activeEnvironment ? silgiConfig.activeEnvironment : await p.select({
-    message: "Select an environment",
-    options: customEnvironments?.length > 0 ? customEnvironments.map((env) => ({
-      label: env.fileName,
-      value: env.fileName
-    })) : [
-      { label: "Development (.env)", value: ".env" },
-      { label: "Docker (.env.docker)", value: "docker" },
-      { label: "Staging (.env.staging)", value: "staging" },
-      { label: "Testing (.env.testing)", value: "testing" },
-      { label: "Production (.env.prod)", value: "prod" }
-    ]
-  });
-  const findEnv = customEnvironments?.find((env) => env.fileName === environment);
-  if (findEnv) {
-    await setupDotenv({
-      cwd: findEnv.cwd || silgiConfig.rootDir,
-      interpolate: findEnv.interpolate,
-      fileName: findEnv.fileName,
-      env: findEnv.env
-    });
-  } else {
-    await setupDotenv({
-      cwd: silgiConfig.rootDir,
-      interpolate: true,
-      fileName: environment === ".env" ? ".env" : `.env.${environment}`
-    });
-  }
-}
-
-async function emptyFramework(silgi) {
-  if (silgi.options.preset === "npm-package" || !silgi.options.preset) ;
-}
-
-async function h3Framework(silgi, skip = false) {
-  if (!isPresents(["h3"]) && skip === false)
-    return;
-  silgi.hook("before:schema.ts", (data) => {
-    data.addImportItemType([
-      {
-        imports: [
-          {
-            name: "H3Event"
-          }
-        ],
-        specifier: "h3"
-      },
-      {
-        imports: [
-          {
-            name: "NitroApp"
-          }
-        ],
-        specifier: "nitropack/types"
-      }
-    ]);
-  });
-  silgi.hook("prepare:types", (opts) => {
-    addTemplate({
-      filename: "types/h3.d.ts",
-      where: ".silgi",
-      getContents: () => {
-        return [
-          "import type { SilgiRuntimeContext } from 'silgi/types'",
-          "",
-          'declare module "h3" {',
-          "  interface H3EventContext extends SilgiRuntimeContext {}",
-          "}",
-          ""
-        ].join("\n");
-      }
-    });
-    opts.references.push({ path: "./h3.d.ts" });
-  });
-  addCoreFile({
-    before: ({ silgiConfigs }) => {
-      silgiConfigs.push({
-        captureError: `(silgi, error, context = {}) => {
-          const promise = silgi.hooks
-            .callHookParallel('error', silgi, 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) {
-    silgi.options.imports.presets ??= [];
-  }
-}
-
-async function nextJS(silgi, skip = false) {
-  if (!isPresents(["next"]) && skip === false)
-    return;
-  const defaultConfig = {
-    serverExternalPackages: [
-      "mlly",
-      "silgi",
-      "h3",
-      "@silgi/openapi",
-      "@silgi/scalar",
-      "@silgi/ecosystem"
-    ],
-    eslint: {
-      ignoreDuringBuilds: true
-    },
-    typescript: {
-      tsconfigPath: "./.silgi/types/silgi.tsconfig.json"
-    },
-    output: "standalone"
-  };
-  await silgi.callHook("nextjs:prepare", {
-    config: defaultConfig
-  });
-  const template = [
-    genImport("defu", ["defu"]),
-    genTypeImport("next", ["NextConfig"]),
-    "export function withNextConfig(config: NextConfig) {",
-    "return defu(config,",
-    // TODO: make the output code more properly intend.
-    genObjectFromRawEntries(
-      Object.entries(defaultConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
-      ""
-    ),
-    ")}",
-    ""
-  ];
-  addTemplate({
-    filename: "next.config.ts",
-    where: ".silgi",
-    write: true,
-    getContents: () => template.join("\n")
-  });
-  silgi.hook("ready", async (silgi2) => {
-    const routerPrefixs = [];
-    for (const _route in silgi2.services) {
-      const { route } = getServicePath(_route);
-      const routeParts = route.split("/").filter(Boolean);
-      if (routeParts.length > 0) {
-        const prefix = `/${routeParts[0]}`;
-        if (!routerPrefixs.includes(prefix)) {
-          routerPrefixs.push(prefix);
-        }
-      }
-    }
-    for (const prefix of routerPrefixs) {
-      const file = join(silgi2.options.srcDir, "app", prefix, "[...all]", "route.ts");
-      const fileExists = existsSync(file);
-      if (!fileExists) {
-        const serverDirName = `@/${silgi2.options.silgi.serverDir.split("/src/")[1]}/core`;
-        const template2 = `import { toNextJsHandler } from 'silgi/runtime/internal/next'
-  import { buildSilgi } from '${serverDirName}'
-  
-  
-  const silgi = await buildSilgi()
-  
-  export const { GET, POST, PUT, DELETE, PATCH } = toNextJsHandler()`;
-        await writeFile(file, template2, true);
-      }
-    }
-  });
-}
-
-async function nitroFramework(silgi, skip = false) {
-  if (!isPresents(["nitro"]) && skip === false)
-    return;
-  silgi.hook("before:schema.ts", (data) => {
-    data.addImportItemType({
-      imports: [
-        {
-          name: "NitroApp"
-        }
-      ],
-      specifier: "nitropack/types"
-    });
-  });
-  silgi.options.plugins.push({
-    packageImport: "silgi/runtime/internal/nitro",
-    path: join(runtimeDir, "internal/nitro")
-  });
-  if (silgi.options.imports !== false) {
-    silgi.options.imports.presets ??= [];
-  }
-  await h3Framework(silgi, true);
-}
-
-async function nuxtFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nuxt" && skip === false)
-    return;
-  await nitroFramework(silgi, true);
-}
-
-const frameworkSetup = [
-  emptyFramework,
-  h3Framework,
-  nitroFramework,
-  nuxtFramework,
-  nextJS
-];
-
-async function registerModuleExportScan(silgi) {
-  silgi.hook("before:schema.ts", async (options) => {
-    for (const module of silgi.scanModules) {
-      const moduleReExports = [];
-      if (!module.entryPath) {
-        continue;
-      }
-      const path = module.meta._packageName ? join$1(dirname(module.entryPath), "types/index.d.mts") : join$1(dirname(module.entryPath), "types/index.ts");
-      const moduleTypes = await promises.readFile(path, "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;
-      const specifier = module.meta._packageName ? moduleName : relativeWithDot(
-        silgi.options.build.typesDir,
-        join$1(dirname(module.entryPath), "types/index")
-      );
-      if (hasTypeExport("ModuleOptions")) {
-        const importName = hash(`${configKey}ModuleOptions`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleOptions"
-            }
-          ],
-          specifier
-        });
-        options.options.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeOptions")) {
-        const importName = hash(`${configKey}ModuleRuntimeOptions`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeOptions"
-            }
-          ],
-          specifier
-        });
-        options.runtimeOptions.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeShareds")) {
-        const importName = hash(`${configKey}ModuleRuntimeShareds`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeShareds"
-            }
-          ],
-          specifier
-        });
-        options.shareds.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleEvents")) {
-        const importName = hash(`${configKey}ModuleEvents`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleEvents"
-            }
-          ],
-          specifier
-        });
-        options.events.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeContexts")) {
-        const importName = hash(`${configKey}ModuleRuntimeContexts`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeContexts"
-            }
-          ],
-          specifier
-        });
-        options.contexts.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleHooks")) {
-        const importName = hash(`${configKey}ModuleHooks`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleHooks"
-            }
-          ],
-          specifier
-        });
-        options.hooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeHooks")) {
-        const importName = hash(`${configKey}RuntimeHooks`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeHooks"
-            }
-          ],
-          specifier
-        });
-        options.runtimeHooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("SetupModuleOption")) {
-        const importName = hash(`${configKey}SetupModuleOption`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "SetupModuleOption"
-            }
-          ],
-          specifier
-        });
-        options.setupModuleOption.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeMethods")) {
-        const importName = hash(`${configKey}ModuleRuntimeMethods`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "ModuleRuntimeMethods"
-            }
-          ],
-          specifier
-        });
-        options.methods.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("RouteRules")) {
-        const importName = hash(`${configKey}RouteRules`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "RouteRules"
-            }
-          ],
-          specifier
-        });
-        options.routeRules.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("MetaData")) {
-        const importName = hash(`${configKey}MetaData`);
-        options.addImportItemType({
-          imports: [
-            {
-              as: importName,
-              name: "MetaData"
-            }
-          ],
-          specifier
-        });
-        options.metaDatas.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 = useSilgiCLI(), 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`);
-  }
-}
-
-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 DEFAULT_FUNCTION_EXPORT_NAMES = [
-  "createSchema",
-  "createService",
-  "createWebSocket",
-  // Added
-  "createResolver",
-  "createShared",
-  "createMiddleware"
-];
-const DEFAULT_INTERFACE_EXTENDS_NAMES = ["ExtendShared", "ExtendContext"];
-function generateUniqueIdentifier(filePath, exportName) {
-  const fileBaseName = basename(filePath);
-  const uniqueString = `${fileBaseName}${exportName}`;
-  return hash(uniqueString);
-}
-function categorizeExports(exportedEntities, filePath, functionExportCategories = {
-  createService: "service",
-  createWebSocket: "websocket",
-  // Added
-  createSchema: "schema",
-  createShared: "shared",
-  createResolver: "resolver",
-  createMiddleware: "middleware"
-}, interfaceExportCategories = {
-  ExtendShared: "shared",
-  ExtendContext: "context"
-}) {
-  const runtimeExports = [];
-  const typeExports = [];
-  for (const [functionName, category] of Object.entries(functionExportCategories)) {
-    const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
-    for (const exportEntity of matchingExports) {
-      if (!exportEntity.name)
-        continue;
-      runtimeExports.push({
-        exportName: exportEntity.name,
-        path: filePath,
-        uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
-        category
-      });
-    }
-  }
-  for (const [extensionName, category] of Object.entries(interfaceExportCategories)) {
-    const matchingExports = exportedEntities.filter(
-      (entity) => entity.declaration === "interface" && entity.extends?.includes(extensionName)
-    );
-    for (const exportEntity of matchingExports) {
-      if (!exportEntity.name)
-        continue;
-      typeExports.push({
-        exportName: exportEntity.name,
-        path: filePath,
-        uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
-        category
-      });
-    }
-  }
-  return { runtimeExports, typeExports };
-}
-function transformImportPath(path, packageName, relativeTo) {
-  let importPath = path;
-  if (packageName) {
-    const distMatch = importPath.match(/.*?(\/dist\/.*)/);
-    if (distMatch && distMatch[1]) {
-      importPath = packageName + distMatch[1].substring("/dist".length);
-      importPath = removeExtension(importPath, true);
-    }
-  } else if (relativeTo) {
-    importPath = removeExtension(relativeWithDot(relativeTo, path));
-  }
-  return importPath;
-}
-function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName) {
-  silgiInstance.hook("before:scan.ts", (options) => {
-    const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
-    for (const { exportName, path, uniqueId, category } of runtimeExports) {
-      if (!isWatchedPath(path, ignored)) {
-        silgiInstance.options.devServer.watch.push(path);
-      }
-      switch (category) {
-        case "service":
-          options.services.push(uniqueId);
-          break;
-        case "websocket":
-          options.services?.push?.(uniqueId);
-          break;
-        case "shared":
-          options.shareds.push(uniqueId);
-          break;
-        case "schema":
-          options.schemas.push(uniqueId);
-          break;
-        case "resolver":
-          options.resolvers.push(uniqueId);
-          break;
-        case "middleware":
-          options.middlewares?.push?.(uniqueId);
-          break;
-      }
-      options.addImportItem({
-        specifier: transformImportPath(path, packageName, silgiInstance.options.silgi.serverDir),
-        imports: [{ name: exportName, as: uniqueId }]
-      });
-    }
-  });
-  silgiInstance.hook("before:schema.ts", (options) => {
-    const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
-    for (const { exportName, path, uniqueId, category } of typeExports) {
-      if (!isWatchedPath(path, ignored)) {
-        silgiInstance.options.devServer.watch.push(path);
-      }
-      if (category === "shared" || category === "context") {
-        const targetCollection = category === "shared" ? options.shareds : options.contexts;
-        targetCollection.push({ key: uniqueId, value: uniqueId });
-      }
-      options.addImportItem({
-        imports: [{ name: exportName, as: uniqueId }],
-        specifier: transformImportPath(path, packageName, silgiInstance.options.build.typesDir)
-      });
-    }
-  });
-}
-async function verifyDirectoryCaseSensitivity(directoryPath, rootDirectory) {
-  const directoryName = basename(directoryPath);
-  const parentDirectory = dirname$1(directoryPath);
-  try {
-    const siblingEntries = await readdir(parentDirectory);
-    if (!siblingEntries.includes(directoryName)) {
-      const directoryNameLowerCase = directoryName.toLowerCase();
-      const caseInsensitiveMatch = siblingEntries.find(
-        (sibling) => sibling.toLowerCase() === directoryNameLowerCase
-      );
-      if (caseInsensitiveMatch) {
-        const originalRelative = relative(rootDirectory, directoryPath);
-        const correctedRelative = relative(
-          rootDirectory,
-          join(parentDirectory, caseInsensitiveMatch)
-        );
-        consola.warn(
-          `Components not scanned from \`~/${correctedRelative}\`. Did you mean to name the directory \`~/${originalRelative}\` instead?`
-        );
-      }
-    }
-  } catch {
-  }
-}
-async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNames = DEFAULT_FUNCTION_EXPORT_NAMES, interfaceExtendsNames = DEFAULT_INTERFACE_EXTENDS_NAMES) {
-  const exportEntities = [];
-  const fileContent = await readFile(absoluteFilePath, "utf-8");
-  const parsed = await parseAsync(absoluteFilePath, fileContent);
-  for (const node of parsed.program.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "TSInterfaceDeclaration") {
-      const decl = node.declaration;
-      if (Array.isArray(decl.extends) && decl.extends.some(
-        (dec) => dec.type === "TSInterfaceHeritage" && dec.expression.type === "Identifier" && interfaceExtendsNames.includes(dec.expression.name)
-      )) {
-        exportEntities.push({
-          name: decl.id?.name,
-          type: "interface",
-          declaration: "interface",
-          extends: decl.extends.filter((e) => e.type === "TSInterfaceHeritage" && e.expression.type === "Identifier").map((e) => e.expression.type === "Identifier" ? e.expression.name : false).filter((name) => Boolean(name))
-        });
-      }
-    }
-  }
-  for (const node of parsed.program.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
-      const decls = node.declaration.declarations;
-      if (Array.isArray(decls)) {
-        for (const decl of decls) {
-          if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier" && decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier" && functionExportNames.includes(decl.init.callee.name)) {
-            let servicePath;
-            let serviceMethod;
-            if (decl.init.callee.name === "createService" || decl.init.callee.name === "createWebSocket") {
-              const firstArg = decl.init.arguments?.[0];
-              if (firstArg && firstArg.type === "ObjectExpression" && Array.isArray(firstArg.properties)) {
-                for (const prop of firstArg.properties) {
-                  if (prop.type === "Property" && prop.key.type === "Identifier") {
-                    if (prop.key.name === "path" && prop.value.type === "Literal" && typeof prop.value.value === "string") {
-                      servicePath = prop.value.value;
-                    }
-                    if (prop.key.name === "method" && prop.value.type === "Literal" && typeof prop.value.value === "string") {
-                      serviceMethod = prop.value.value;
-                    }
-                  }
-                }
-              }
-            }
-            exportEntities.push({
-              name: decl.id.name,
-              type: "function",
-              funcName: decl.init.callee.name,
-              servicePath,
-              serviceMethod
-            });
-          }
-        }
-      }
-    }
-  }
-  return exportEntities;
-}
-async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
-  const processedFilePaths = /* @__PURE__ */ new Set();
-  const alreadyScannedPaths = [];
-  const serverDirectory = path || silgiInstance.options.serverDir;
-  const functionExportNames = scanOptions.functionExportNames ?? DEFAULT_FUNCTION_EXPORT_NAMES;
-  const interfaceExtendsNames = scanOptions.interfaceExtendsNames ?? DEFAULT_INTERFACE_EXTENDS_NAMES;
-  const functionExportCategories = {};
-  functionExportNames.forEach((name) => {
-    if (name === "createService")
-      functionExportCategories[name] = "service";
-    else if (name === "createWebSocket")
-      functionExportCategories[name] = "websocket";
-    else if (name === "createSchema")
-      functionExportCategories[name] = "schema";
-    else if (name === "createShared")
-      functionExportCategories[name] = "shared";
-    else if (name === "createResolver")
-      functionExportCategories[name] = "resolver";
-    else if (name === "createMiddleware")
-      functionExportCategories[name] = "middleware";
-    else functionExportCategories[name] = name;
-  });
-  const interfaceExportCategories = {};
-  interfaceExtendsNames.forEach((name) => {
-    if (name === "ExtendShared")
-      interfaceExportCategories[name] = "shared";
-    else if (name === "ExtendContext")
-      interfaceExportCategories[name] = "context";
-    else interfaceExportCategories[name] = name;
-  });
-  if (!serverDirectory) {
-    consola.warn("No server directory specified for scanning");
-    return;
-  }
-  try {
-    const matchedFiles = await glob(serverDirectory, {
-      cwd: silgiInstance.options.rootDir,
-      ignore: silgiInstance.options.ignore
-    });
-    if (matchedFiles.length) {
-      await verifyDirectoryCaseSensitivity(
-        serverDirectory,
-        silgiInstance.options.rootDir
-      );
-    }
-    for (const relativeFilePath of matchedFiles.sort()) {
-      const absoluteFilePath = resolve(silgiInstance.options.rootDir, relativeFilePath);
-      if (alreadyScannedPaths.find((path2) => absoluteFilePath.startsWith(withTrailingSlash(path2))) || isIgnored(absoluteFilePath, silgiInstance) || processedFilePaths.has(absoluteFilePath)) {
-        continue;
-      }
-      processedFilePaths.add(absoluteFilePath);
-      const fileExtension = extname(absoluteFilePath);
-      if (!silgiInstance.options.extensions?.includes(fileExtension)) {
-        continue;
-      }
-      try {
-        const exportEntities = await extractExportEntitiesFromFile(
-          absoluteFilePath,
-          functionExportNames,
-          interfaceExtendsNames
-        );
-        const seenServiceSignatures = /* @__PURE__ */ new Map();
-        for (const entity of exportEntities) {
-          if ((entity.funcName === "createService" || entity.funcName === "createWebSocket") && entity.servicePath && entity.serviceMethod) {
-            const key = `${entity.serviceMethod}:${entity.servicePath}`;
-            if (seenServiceSignatures.has(key)) {
-              throw new Error(
-                `Duplicate ${entity.funcName} detected for path "${entity.servicePath}" and method "${entity.serviceMethod}".
-First found in: ${seenServiceSignatures.get(key)}
-Duplicate in: ${absoluteFilePath}
-Please ensure each service path/method combination is unique.`
-              );
-            }
-            seenServiceSignatures.set(key, absoluteFilePath);
-          }
-        }
-        const allExportedEntities = exportEntities;
-        const { runtimeExports, typeExports } = categorizeExports(
-          allExportedEntities,
-          absoluteFilePath,
-          functionExportCategories,
-          interfaceExportCategories
-        );
-        registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName);
-      } catch (error) {
-        consola.error(`Error processing file ${absoluteFilePath}:`, error);
-      }
-    }
-  } catch (error) {
-    consola.error("Error scanning export files:", error);
-  }
-}
-function isWatchedPath(path, ignoredPatterns) {
-  return micromatch.isMatch(path, ignoredPatterns);
-}
-
-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)
-          };
-        }
-      }
-      if (!isPresents(["npm-package"])) {
-        const runtimeFolder = new URL("runtime", src);
-        await scanSilgiExports(runtimeFolder.pathname, buildTimeModuleMeta._packageName);
-      }
-    } 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$1(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;
-}
-
-function useCLIRuntimeConfig(silgi = useSilgiCLI()) {
-  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
-  silgi.hook("prepare:configs.ts", (data) => {
-    data.runtimeConfig = safeRuntimeConfig;
-    silgi.options.envOptions = silgi.options.envOptions;
-  });
-  addTemplate({
-    filename: "env.example",
-    write: true,
-    where: ".silgi",
-    getContents() {
-      const flattenedConfig = flattenObject(safeRuntimeConfig);
-      const groupedVars = {};
-      Object.entries(flattenedConfig).forEach(([key, { value, originalPath }]) => {
-        const shouldExclude = silgi.options.codegen.env.safeList.some((safePath) => {
-          if (safePath.length !== originalPath.length)
-            return false;
-          return safePath.every((segment, index) => segment.toLowerCase() === originalPath[index].toLowerCase());
-        });
-        if (shouldExclude)
-          return;
-        if (originalPath.length > 0) {
-          const firstKey = originalPath[0];
-          const categoryName = extractCategoryFromCamel(firstKey);
-          if (!groupedVars[categoryName]) {
-            groupedVars[categoryName] = {};
-          }
-          groupedVars[categoryName][key] = value;
-        } else {
-          if (!groupedVars.OTHER) {
-            groupedVars.OTHER = {};
-          }
-          groupedVars.OTHER[key] = value;
-        }
-      });
-      return Object.entries(groupedVars).map(([category, vars]) => {
-        const varsContent = Object.entries(vars).map(([key, value]) => `${key}=${value}`).join("\n");
-        return `# ${category}
-${varsContent}`;
-      }).join("\n\n");
-    }
-  });
-  const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
-  silgi.options.runtimeConfig = safeRuntimeConfig;
-  return _sharedRuntimeConfig;
-}
-function extractCategoryFromCamel(str) {
-  if (/^[a-z]+[A-Z]/.test(str)) {
-    const matches = str.match(/^([a-z]+)([A-Z][a-z0-9]*)?/);
-    if (matches && matches[2]) {
-      return `${matches[1].toUpperCase()}_${matches[2].toUpperCase()}`;
-    }
-  }
-  return str.toUpperCase();
-}
-function flattenObject(obj, prefix = "SILGI", originalPath = []) {
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const formattedKey = snakeCase(key).toUpperCase();
-    const newKey = `${prefix}_${formattedKey}`;
-    const newPath = [...originalPath, key];
-    if (typeof value === "object" && value !== null) {
-      Object.assign(acc, flattenObject(value, newKey, newPath));
-    } else {
-      acc[newKey] = { value, originalPath: newPath };
-    }
-    return acc;
-  }, {});
-}
-
-async function prepareConfigs(silgi = useSilgiCLI()) {
-  useCLIRuntimeConfig();
-  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 { useRuntimeConfig } from 'silgi/runtime'",
-    "",
-    `export const runtimeConfig: SilgiRuntimeConfig = ${genObjectFromRawEntries(
-      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
-      ""
-    )}`,
-    "",
-    "export const localConfig = useRuntimeConfig(undefined, runtimeConfig)",
-    ""
-  ];
-  delete _data.runtimeConfig;
-  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
-    Object.entries(_data).map(
-      ([key, value]) => [key, genEnsureSafeVar(value)]
-    )
-  )}`);
-  importData.unshift(...baseHeaderBannerComment);
-  await writeFile(
-    resolve(silgi.options.silgi.serverDir, "configs.ts"),
-    importData.join("\n")
-  );
-}
-
-async function prepareScanFile(silgi) {
-  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-    // typeImports: [
-    //   {
-    //     specifier: 'silgi/types',
-    //     imports: [
-    //       {
-    //         name: 'SilgiRuntimeOptions',
-    //       },
-    //     ],
-    //   },
-    // ],
-  });
-  const scanned = {
-    services: [],
-    shareds: [],
-    resolvers: [],
-    schemas: [],
-    middlewares: [],
-    addImportItem,
-    addImportItemType
-  };
-  await silgi.callHook("before:scan.ts", scanned);
-  const importsContent = [
-    ...genImports.map(({ specifier, imports, options }) => {
-      return genImport(specifier, imports, options);
-    }),
-    ...genTypeImports.map(({ specifier, imports }) => {
-      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-    }),
-    ""
-  ];
-  const generateExport = (name, items, defaultEmpty = "{}", asArray = false) => {
-    const hasItems = items.length > 0;
-    if (asArray) {
-      return [
-        `export const ${name} = [`,
-        ...items.map((item) => `  ${item},`),
-        "]",
-        ""
-      ];
-    }
-    if (hasItems) {
-      return [
-        `export const ${name} = {`,
-        ...items.map((item) => `  ...${item},`),
-        "}",
-        ""
-      ];
-    } else {
-      return [
-        `export const ${name} = ${defaultEmpty}`,
-        ""
-      ];
-    }
-  };
-  const importData = [
-    "",
-    ...generateExport("schemas", scanned.schemas),
-    ...generateExport("services", scanned.services),
-    ...generateExport("shareds", scanned.shareds, "undefined"),
-    ...generateExport("resolvers", scanned.resolvers, "[]", true),
-    // array olarak export
-    ...generateExport("middlewares", scanned.middlewares)
-  ];
-  await silgi.callHook("after:scan.ts", importData);
-  importData.unshift(...importsContent);
-  importData.unshift(...baseHeaderBannerComment);
-  await writeFile(
-    resolve(silgi.options.silgi.serverDir, "scan.ts"),
-    importData.join("\n")
-  );
-  return importData;
-}
-
-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 === true,
-    alias: silgi.options.alias
-  });
-  try {
-    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.schemas = scanFile.schemas || {};
-    silgi.services = scanFile.services || {};
-    silgi.shareds = scanFile.shareds || {};
-    silgi.resolvers = scanFile.resolvers || {};
-    return {
-      context,
-      object: {
-        schemas: scanFile.schemas,
-        services: scanFile.services,
-        shareds: scanFile.shareds
-      },
-      path
-    };
-  } catch (error) {
-    if (silgi.options.debug) {
-      console.error("Failed to read scan.ts file:", error);
-    } else {
-      consola.withTag("silgi").error(error);
-    }
-    return {
-      context,
-      object: {
-        schemas: {},
-        services: {},
-        shareds: {}
-      },
-      path
-    };
-  }
-}
-
-async function createStorageCLI(silgi) {
-  const storage = createStorage();
-  const runtime = useRuntimeConfig();
-  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;
-}
-
-const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-async function scanAndSyncOptions(silgi) {
-  const scannedModules = await scanModules(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(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 glob(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 createSilgiCLI(config = {}, opts = {}) {
-  const options = await loadOptions(config, opts);
-  await prepareEnv(options);
-  const hooks = createHooks();
-  const silgi = {
-    services: {},
-    middleware: [],
-    shareds: {},
-    schemas: {},
-    resolvers: [],
-    unimport: void 0,
-    options,
-    hooks,
-    errors: [],
-    _requiredModules: {},
-    logger: opts.consola || consola.withTag("silgi"),
-    close: () => silgi.hooks.callHook("close", silgi),
-    storage: void 0,
-    scanModules: [],
-    templates: [],
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    adapters: {},
-    useLocalConfig: () => useRuntimeConfig(void 0, options.runtimeConfig),
-    meta: {}
-  };
-  if (silgiCLICtx.tryUse()) {
-    silgiCLICtx.unset();
-    silgiCLICtx.set(silgi);
-  } else {
-    silgiCLICtx.set(silgi);
-    silgi.hook("close", () => silgiCLICtx.unset());
-  }
-  if (silgi.options.debug) {
-    createDebugger(silgi.hooks, { tag: "silgi" });
-    silgi.options.plugins.push({
-      path: join(runtimeDir, "internal/debug"),
-      packageImport: "silgi/runtime/internal/debug"
-    });
-  }
-  await scanAndSyncOptions(silgi);
-  await scanSilgiExports();
-  await scanModules$1(silgi);
-  await installModules(silgi, true);
-  await prepareConfigs();
-  sharedRuntimeConfig(silgi.options.runtimeConfig, silgi.options.dev);
-  if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) {
-    for (const [key, value] of Object.entries(silgi.options.adapters)) {
-      if (typeof value === "function") {
-        const resolved = value(silgi);
-        silgi.adapters[key] = resolved instanceof Promise ? await resolved : resolved;
-      } else {
-        silgi.adapters[key] = value;
-      }
-    }
-  }
-  await prepareScanFile(silgi);
-  await readScanFile(silgi);
-  await installModules(silgi);
-  for (const framework of frameworkSetup) {
-    await framework(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);
-  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(dir.slice(1), options, silgi.options.rootDir)}`;
-        }
-        return resolveSilgiPath(dir, options, silgi.options.rootDir);
-      }
-      return dir;
-    });
-    silgi.options.imports.presets.push({
-      from: "silgi/types",
-      imports: autoImportTypes.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 silgi.hooks.callHook("ready", silgi);
-  return silgi;
-}
-
-async function generateApiFul(silgi) {
-  const config = silgi.options.apiFul;
-  if (!hasSilgiModule("openapi")) {
-    silgi.options.dev || silgi.logger.info("Silgi OpenAPI module not found, if you want to use it, please install it @silgi/openapi");
-    return;
-  }
-  if (!config.services || hasSilgiModule("openapi")) {
-    config.services ??= {};
-    config.services = {
-      silgi: {
-        schema: join(silgi.options.build.dir, "openapi.json")
-      }
-    };
-  }
-  const resolvedOpenAPIServices = Object.fromEntries(
-    Object.entries(config?.services ?? {}).filter(([, service]) => Boolean(service.schema))
-  );
-  if (Object.keys(resolvedOpenAPIServices).length === 0) {
-    consola.info("No OpenAPI schemas found, skipping generation");
-    return;
-  }
-  for (const service of Object.values(resolvedOpenAPIServices)) {
-    if (typeof service.schema === "string" && !service.schema.startsWith("http")) {
-      service.schema = resolve(silgi.options.rootDir, service.schema);
-    }
-  }
-  const types = await generateDTS(resolvedOpenAPIServices);
-  silgi.hook("prepare:types", (opts) => {
-    opts.references.push({ path: "./apiful.d.ts" });
-  });
-  addTemplate({
-    filename: "types/apiful.d.ts",
-    where: ".silgi",
-    write: true,
-    getContents: () => types
-  });
-}
-
-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) => {
-    let dir;
-    switch (tmpl.where) {
-      case ".silgi":
-        dir = app.options.build.dir;
-        break;
-      case "server":
-        dir = app.options.silgi.serverDir;
-        break;
-      case "client":
-        dir = app.options.silgi.clientDir;
-        break;
-      case "root":
-        dir = app.options.rootDir;
-        break;
-      default:
-        dir = app.options.silgi.vfsDir;
-    }
-    return normalizeTemplate(tmpl, dir);
-  });
-  const filteredTemplates = {
-    pre: [],
-    post: []
-  };
-  for (const template of app.templates) {
-    if (template.watch === false) {
-      if (Array.isArray(app.options.watchOptions.ignored)) {
-        app.options.watchOptions.ignored.push(`${template.dst || template.src}`);
-      }
-    }
-    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) {
-    let dir;
-    switch (template.where) {
-      case ".silgi":
-        dir = app.options.build.dir;
-        break;
-      case "server":
-        dir = app.options.silgi.serverDir;
-        break;
-      case "client":
-        dir = app.options.silgi.clientDir;
-        break;
-      case "root":
-        dir = app.options.rootDir;
-        break;
-      default:
-        dir = 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$1(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)}`);
-}
-
-function debugMode(name) {
-  const silgi = useSilgiCLI$1();
-  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
-    return true;
-  }
-  return false;
-}
-
-async function prepareCommands(silgi = useSilgiCLI$1()) {
-  const commands = [];
-  await silgi.callHook("prepare:commands", commands);
-  if (debugMode("command")) {
-    addTemplate({
-      filename: "cli.json",
-      where: ".silgi",
-      write: true,
-      getContents: () => JSON.stringify(commands, null, 2)
-    });
-  }
-  silgi.hook("prepare:types", async ({ references }) => {
-    const allTags = commands.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 = [
-      genAugmentation("silgi/types", {
-        SilgiCommands: {
-          ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
-        }
-      }),
-      "",
-      "export {}"
-    ];
-    addTemplate({
-      filename: "types/commands.d.ts",
-      write: true,
-      where: ".silgi",
-      getContents: () => data.join("\n")
-    });
-    references.push({
-      path: "./commands.d.ts"
-    });
-  });
-  silgi.options.commands = commands;
-}
-
-async function prepareCoreFile(silgi) {
-  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-    imports: [
-      {
-        specifier: "silgi/runtime",
-        imports: [
-          {
-            name: "mergeDeep"
-          }
-        ]
-      },
-      {
-        specifier: "silgi",
-        imports: [
-          {
-            name: "createSilgi"
-          }
-        ]
-      },
-      {
-        specifier: "./scan",
-        imports: [
-          {
-            name: "services"
-          },
-          {
-            name: "shareds"
-          },
-          {
-            name: "schemas"
-          },
-          {
-            name: "middlewares"
-          },
-          {
-            name: "resolvers"
-          }
-        ]
-      },
-      {
-        specifier: "./configs",
-        imports: [
-          {
-            name: "cliConfigs"
-          }
-        ]
-      },
-      {
-        specifier: "./meta",
-        imports: [
-          {
-            name: "meta"
-          }
-        ]
-      }
-    ],
-    typeImports: [
-      {
-        specifier: "silgi/types",
-        imports: [
-          {
-            name: "SilgiRuntimeOptions"
-          },
-          {
-            name: "BuildSilgi"
-          }
-        ]
-      }
-    ]
-  });
-  const before = [];
-  const after = [];
-  const _data = {
-    silgiConfigs: [],
-    addImportItem,
-    addImportItemType,
-    addBuildFunction: (data) => {
-      for (const item of toArray(data)) {
-        if (item.where === "after") {
-          if (item.custom) {
-            after.push(item.custom);
-          } else {
-            after.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
-          }
-        }
-        if (item.where === "before") {
-          if (item.custom) {
-            before.push(item.custom);
-          } else {
-            before.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
-          }
-        }
-      }
-    }
-  };
-  await silgi.callHook("before:core.ts", _data);
-  const plugins = [];
-  for (const plugin of silgi.options.plugins) {
-    const pluginImportName = hash(plugin.packageImport);
-    addImportItem({
-      specifier: plugin.packageImport,
-      imports: pluginImportName
-    });
-    plugins.push(pluginImportName);
-  }
-  const importsContent = [
-    ...genImports.map(({ specifier, imports, options }) => {
-      return genImport(specifier, imports, options);
-    }),
-    ...genTypeImports.map(({ specifier, imports }) => {
-      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-    }),
-    ""
-  ];
-  const importData = [
-    "",
-    "export async function buildSilgi(option?: BuildSilgi) {",
-    "",
-    "// buildSilgiBefore",
-    ...before,
-    "",
-    "const silgi = await createSilgi({",
-    " framework: option?.framework,",
-    " shared: shareds,",
-    " services: services,",
-    " middlewares: middlewares,",
-    " schemas: schemas,",
-    " resolvers: resolvers,",
-    ` plugins: [${plugins.join(", ")}],`,
-    "",
-    _data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
-      const code = genObjectFromRawEntries(Object.entries(item));
-      return ` ${code.slice(1, -1).trim()},`;
-    }).filter(Boolean).join("\n") : "",
-    "",
-    " options: mergeDeep(cliConfigs, {",
-    "   runtimeConfig: {} as SilgiRuntimeOptions,",
-    "   meta: meta,",
-    `   present: '${silgi.options.preset}',`,
-    "   ...option?.modules,",
-    "   ...option?.options,",
-    "   }) as any,",
-    " })",
-    "",
-    "// buildSilgiAfter",
-    ...after,
-    "",
-    "  return silgi",
-    "}",
-    ""
-  ];
-  await silgi.callHook("after:core.ts", importData);
-  importData.unshift(...importsContent);
-  importData.unshift(...baseHeaderBannerComment);
-  return importData;
-}
-
-async function writeCoreFile(silgi) {
-  const coreContent = await prepareCoreFile(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, "meta.ts"),
-    contents: `export const meta = ${JSON.stringify(silgi.meta, null, 2)}`
-  });
-  for await (const file of buildFiles) {
-    if (!silgi.errors.length) {
-      await writeFile(
-        resolve(silgi.options.build.dir, file.path),
-        file.contents
-      );
-    }
-  }
-}
-
-async function prepareSchema(silgi) {
-  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
-    imports: [],
-    typeImports: [
-      {
-        specifier: "silgi/types",
-        imports: [
-          {
-            name: "URIsTypes"
-          },
-          {
-            name: "SilgiRuntimeContext"
-          }
-        ]
-      }
-    ]
-  });
-  const data = {
-    addImportItem,
-    addImportItemType,
-    options: [],
-    contexts: [],
-    setupModuleOption: [],
-    shareds: [],
-    resolvers: [],
-    events: [],
-    hooks: [],
-    runtimeHooks: [],
-    runtimeOptions: [],
-    methods: [],
-    routeRules: [],
-    metaDatas: []
-  };
-  await silgi.callHook("before:schema.ts", data);
-  const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
-  let addSilgiContext = false;
-  const importsContent = [
-    ...genImports.map(({ specifier, imports, options }) => {
-      return genImport(specifier, imports, options);
-    }),
-    ...genTypeImports.map(({ specifier, imports }) => {
-      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
-    }),
-    ""
-  ];
-  const importData = [
-    "",
-    `type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
-    `type BaseServices = typeof import('${silgiScanTS}')['services']`,
-    `type ResolversExtend = ${data.resolvers?.length ? data.resolvers.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    "",
-    `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 SetupModuleOptionExtend = ${data.setupModuleOption?.length ? data.setupModuleOption.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type RuntimeMethodExtends = ${data.methods?.length ? data.methods.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(" & ") : "{}"}`,
-    "",
-    `type RouteRulesExtend = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
-    "",
-    `type MetaDataExtend = ${data.metaDatas?.length ? data.metaDatas.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(
-        {
-          ...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.services ? Object.values(silgi.services).reduce((acc, service) => {
-            const { route } = getServicePath(service.path);
-            if (route) {
-              acc[route] = "";
-            }
-            return acc;
-          }, {}) : {}
-        }
-      ),
-      {
-        interfaceName: "RoutersExtend",
-        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(" & ") : "{}"}`,
-    "",
-    genAugmentation("silgi/types", {
-      SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
-      ServicesObject: [{}, { extends: ["BaseServices"] }],
-      SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
-      SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
-      SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
-      SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
-      SetupModuleOption: [{}, { extends: ["SetupModuleOptionExtend"] }],
-      SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
-      SilgiRuntimeHooks: [{}, { extends: ["SilgiRuntimeHooksExtends"] }],
-      SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
-      SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
-      SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
-      Resolvers: [{}, { extends: ["ResolversExtend"] }],
-      SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
-      // TODO: bunu kontrol et.
-      RouteRules: [{}, { extends: ["RouteRulesExtend"] }],
-      MetaData: [{}, { extends: ["MetaDataExtend"] }],
-      Routers: [{}, { extends: ["RoutersExtend"] }]
-    }).replace(/,\s*/g, "\n"),
-    "",
-    "export {}"
-  ];
-  await silgi.callHook("after:schema.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-
-async function writeTypesAndFiles(silgi) {
-  silgi.hook("prepare:types", (opts) => {
-    opts.references.push({ path: "./schema.d.ts" });
-    opts.references.push({ path: "./silgi-routes.d.ts" });
-  });
-  const schemaContent = await prepareSchema(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-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-config.d.ts"),
-    contents: declarations.join("\n")
-  });
-  buildFiles.push({
-    path: tsConfigPath,
-    contents: JSON.stringify(tsConfig, null, 2)
-  });
-  for await (const file of buildFiles) {
-    if (!silgi.errors.length) {
-      await writeFile(
-        resolve(silgi.options.build.dir, file.path),
-        file.contents
-      );
-    }
-  }
-}
-
-async function build(silgi) {
-  await generateApiFul(silgi);
-  await prepareCommands(silgi);
-  await writeCoreFile(silgi);
-  await writeTypesAndFiles(silgi);
-  await generateApp(silgi);
-}
-
-export { build as b, createSilgiCLI as c, prepareEnv as p };