silgi 0.9.35 → 0.10.1

package/dist/cli/prepare.mjs

@@ -1,1928 +1,43 @@
 import { defineCommand } from 'citty';
-import consola, { consola as consola$1 } from 'consola';
-import { resolve, isAbsolute, relative, join, dirname, basename, extname } from 'pathe';
-import { peerDependencies, version } from 'silgi/meta';
-import { promises, existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolveModuleExportNames, resolve as resolve$1 } from 'mlly';
-import { resolveAlias } from 'pathe/utils';
-import { relativeWithDot, hash, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1, normalizeTemplate, useLogger, addTemplate, applyEnv } from 'silgi/kit';
-import { runtimeDir } from 'silgi/runtime/meta';
-import { toExports, scanExports, createUnimport } from 'unimport';
-import { createJiti } from 'dev-jiti';
-import { readPackageJSON } from 'pkg-types';
-import { s as silgiGenerateType } from './types.mjs';
+import consola from 'consola';
+import { resolve } from 'pathe';
+import { version } from 'silgi/meta';
+import { c as createSilgiCLI, p as prepare$1, w as writeTypesAndFiles, a as writeCoreFile } from './writeTypesAndFiles.mjs';
 import { c as commonArgs } from './common.mjs';
-import { createHooks, createDebugger } from 'hookable';
-import { useSilgiCLI, silgiCLICtx } from 'silgi/core';
-import { autoImportTypes } from 'silgi/types';
-import { p as prepareEnv } from './env.mjs';
-import { pascalCase } from 'scule';
-import { h as hasInstalledModule } from './compatibility.mjs';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import defu from 'defu';
-import { isRelative, withTrailingSlash } from 'ufo';
-import { globby } from 'globby';
-import ignore from 'ignore';
-import { parseSync } from '@oxc-parser/wasm';
-import { klona } from 'klona';
-import { createStorage, builtinDrivers } from 'unstorage';
-import { l as loadOptions } from './loader.mjs';
+import 'node:fs';
+import 'node:fs/promises';
+import 'hookable';
+import 'silgi/core';
+import 'silgi/kit';
+import 'silgi/runtime/meta';
+import 'silgi/types';
+import 'unimport';
+import './env.mjs';
 import '@clack/prompts';
 import 'dotenv';
+import 'mlly';
+import 'scule';
+import 'dev-jiti';
+import './compatibility.mjs';
 import 'semver/functions/satisfies.js';
+import 'node:url';
+import 'defu';
+import 'ufo';
+import 'globby';
+import 'ignore';
+import '@oxc-parser/wasm';
+import 'klona';
+import 'unstorage';
+import './loader.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';
 import 'std-env';
 import 'consola/utils';
 import 'escape-string-regexp';
-
-async function prepare$1(_silgi) {
-}
-
-async function generateSilgiStorageBaseType(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
-    if (silgi.options.storage) {
-      for (const [key, _value] of Object.entries(silgi.options.storage)) {
-        options.storeBase.push(key);
-      }
-    }
-  });
-}
-
-async function generateRouterDTS(silgi) {
-  silgi.hook("finish:types", async (data) => {
-    const uris = data.object.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}'>`,
-        params: `ExtractRouterParamsFromURI<'${key}'>['params']`
-      };
-      return acc;
-    }, {});
-    const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
-      const methodEntries = Object.entries(methods).map(([method, { input, output, params }]) => {
-        return `    '${method}': {
-      input: ${input},
-      output: ${output}
-      params: ${params}
-    }`;
-      }).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, ExtractRouterParamsFromURI } 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 {}"
-    ].join("\n");
-    const outputPath = resolve(silgi.options.build.typesDir, "silgi-routes.d.ts");
-    await promises.writeFile(outputPath, context);
-  });
-}
-
-async function readCoreFile(silgi) {
-  const path = resolve(silgi.options.silgi.serverDir, "core.ts");
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  const injectedResult = await silgi.unimport.injectImports(context, path);
-  if (!injectedResult) {
-    throw new Error("Failed to inject imports");
-  }
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: false,
-    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 coreFile = 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 = coreFile.uris;
-    silgi.schemas = coreFile.schemas;
-    silgi.services = coreFile.services;
-    silgi.shareds = coreFile.shareds;
-    silgi.modulesURIs = coreFile.modulesURIs;
-    return {
-      context,
-      object: {
-        schemas: coreFile.schemas,
-        uris: coreFile.uris,
-        services: coreFile.services,
-        shareds: coreFile.shareds,
-        modulesURIs: coreFile.modulesURIs
-      },
-      path
-    };
-  } catch (error) {
-    if (silgi.options.debug) {
-      console.error("Failed to read core.ts file:", error);
-    } else {
-      if (error instanceof Error) {
-        consola.withTag("silgi").error(error.message);
-      }
-    }
-    return {
-      context,
-      object: {
-        schemas: {},
-        uris: {},
-        services: {},
-        shareds: {},
-        modulesURIs: {}
-      },
-      path
-    };
-  }
-}
-
-function traverseObject(silgi, obj, 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 paramString = "";
-      if (node.router) {
-        let params = null;
-        if (node.router?._def?.typeName !== void 0) {
-          try {
-            const shape = node.router?.shape?.params?.shape;
-            params = shape ? Object.keys(shape) : null;
-          } catch {
-            params = null;
-          }
-        }
-        if (params?.length) {
-          paramString = params.map((p) => `:${p}`).join("/");
-        }
-      }
-      uriMap.set(basePath, paramString);
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(obj, currentPath);
-  return uriMap;
-}
-function scanActionModulesUris(silgi, obj, currentPath = []) {
-  const uriMap = {};
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let moduleName = "";
-      if (node.modules?.graphql) {
-        let field = null;
-        if (node.modules?.graphql?.field) {
-          moduleName = "graphql";
-          field = node.modules?.graphql?.field;
-        }
-        if (!field) {
-          return;
-        }
-        uriMap[moduleName] ??= {};
-        if (typeof uriMap[moduleName].field === "object" && uriMap[moduleName].field[field]) {
-          silgi.logger.withTag("scanActionModulesUris").error(`Hata ${moduleName} ${field} ${basePath} bu zaten burada kullanilmis.`);
-        }
-        uriMap[moduleName].field ??= {};
-        uriMap[moduleName].field[field] = basePath;
-      }
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(obj, currentPath);
-  return uriMap;
-}
-
-async function scanUris(silgi) {
-  const { context, object, path } = await readCoreFile(silgi);
-  const uriMap = traverseObject(silgi, object.schemas, []);
-  const modulesURIs = scanActionModulesUris(silgi, object.services, []);
-  const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
-  let newContext = "";
-  if (uriMap.size > 0) {
-    newContext = context.replace(
-      /export const uris = \{[^}]*\}/,
-      `export const uris = {
-${uriContent}
-}`
-    ).replace(
-      /export const modulesURIs = \{[^}]*\}/,
-      `export const modulesURIs = ${JSON.stringify(modulesURIs, null, 2)}`
-    );
-  } else {
-    newContext = context;
-  }
-  await promises.writeFile(path, newContext);
-}
-
-async function createCoreFramework(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importItems = {
-    "silgi/types": {
-      import: [
-        { name: "SilgiRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    }
-  };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  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 relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importItems = {
-    "silgi/types": {
-      import: [
-        { name: "SilgiRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    }
-  };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  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;
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
-async function schemaTemplate(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importItems = {
-    "silgi/types": {
-      import: [
-        { name: "URIsTypes", type: true },
-        { name: "Namespaces", type: true },
-        { name: "SilgiRuntimeContext", type: true }
-      ],
-      from: "silgi/types"
-    }
-  };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  const data = {
-    importItems,
-    customImports: [],
-    options: [],
-    contexts: [],
-    actions: [],
-    shareds: [],
-    events: [],
-    storeBase: [],
-    hooks: [],
-    runtimeHooks: [],
-    runtimeOptions: [],
-    methods: []
-  };
-  const storeBase = [];
-  await silgi.callHook("prepare:schema.ts", data);
-  const silgiExport = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.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;
-      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('${silgiExport}')['schemas']>`,
-    "",
-    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiExport}')['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 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(" & ") : "{}"}`,
-    "",
-    "interface SilgiStorageBaseExtends {",
-    ...(storeBase || []).map((value) => `  ${value}: ''`),
-    "}",
-    "",
-    `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 SilgiRuntimeShareds extends SilgiModuleSharedExtends {}",
-    " interface SilgiRuntimeActions extends RuntimeActionExtends {}",
-    " interface SilgiModuleOptions extends SilgiModuleOptionExtend {}",
-    " interface SilgiRuntimeOptions extends SilgiRuntimeOptionExtends {}",
-    " interface SilgiRuntimeHooks extends SilgiRuntimeHooksExtends {}",
-    " interface SilgiHooks extends ModuleHooksExtend {}",
-    " interface SilgiRuntimeMethods extends RuntimeMethodExtends {}",
-    "}",
-    "",
-    "export {}"
-  ];
-  await silgi.callHook("after:prepare:schema.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-
-async function silgiCoreFile(data, frameworkContext, silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  let importItems = {
-    "silgi/core": {
-      import: [
-        { name: "createSilgi" },
-        { name: "createShared" }
-      ],
-      from: "silgi/core"
-    },
-    "silgi/types": {
-      import: [
-        { name: "SilgiRuntimeOptions", type: true },
-        { name: "FrameworkContext", type: true },
-        { name: "BuildConfig", type: true }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "silgi/runtime/internal/defu": {
-      import: [
-        {
-          name: "mergeDeep"
-        }
-      ],
-      from: "silgi/runtime/internal/defu"
-    }
-  };
-  importItems = { ...data._importItems, ...importItems };
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    if (!pkg?.name) {
-      return;
-    }
-    if (importItems[pkg.name]) {
-      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  const _data = {
-    customImports: data._customImports || [],
-    uris: [],
-    services: [],
-    shareds: [],
-    schemas: [],
-    buildSilgiExtraContent: [],
-    beforeBuildSilgiExtraContent: [],
-    cliOptions: {},
-    afterCliOptions: [],
-    _silgiConfigs: [],
-    customContent: [],
-    importItems
-  };
-  for (const module of silgi.scanModules) {
-    if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) {
-      for (const key of module.meta.cliToRuntimeOptionsKeys) {
-        _data.cliOptions[module.meta.configKey] = {
-          ..._data.cliOptions[module.meta.configKey],
-          [key]: module.options[key]
-        };
-      }
-    } else {
-      _data.cliOptions[module.meta.configKey] = {};
-    }
-  }
-  await silgi.callHook("prepare:core.ts", _data);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
-  if (_data.services.length > 0) {
-    importItems["silgi/core"].import.push({ name: "mergeServices" });
-  }
-  if (_data.shareds.length > 0) {
-    importItems["silgi/core"].import.push({ name: "mergeShared" });
-  }
-  if (_data.schemas.length > 0) {
-    importItems["silgi/core"].import.push({ name: "mergeSchemas" });
-  }
-  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 = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
-    }),
-    "",
-    ..._data.customImports,
-    ""
-  ];
-  const importData = [
-    `export const cliOptions: SilgiRuntimeOptions = ${JSON.stringify(_data.cliOptions, null, 2)}`,
-    "",
-    ..._data.afterCliOptions,
-    "",
-    "export const uris = {}",
-    "",
-    "export const modulesURIs = {}",
-    "",
-    _data.schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
-    ..._data.schemas.map((name) => {
-      return `  ${name},`;
-    }),
-    _data.schemas.length > 0 ? "])" : "}",
-    "",
-    _data.services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
-    ..._data.services.map((name) => {
-      return `  ${name},`;
-    }),
-    _data.services.length > 0 ? "])" : "}",
-    "",
-    _data.shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
-    ..._data.shareds.map((name) => {
-      return `  ${name},`;
-    }),
-    _data.shareds.length > 0 ? "])" : "}",
-    "",
-    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<SilgiRuntimeOptions>,buildOptions?: Partial<BuildConfig>) {",
-    "",
-    _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      ")},` : "",
-    "      runtimeConfig: {},",
-    "      ...buildOptions,",
-    "      options: mergeDeep(",
-    "        moduleOptions || {},",
-    "        {",
-    `          present: '${silgi.options.preset}',`,
-    "          ...cliOptions,",
-    "        },",
-    "      ) as any,",
-    "    })",
-    "",
-    ...frameworkContext,
-    "",
-    ..._data.buildSilgiExtraContent,
-    "",
-    "  return silgi",
-    "}",
-    ""
-  ];
-  await silgi.callHook("after:prepare:core.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-
-async function writeTypesAndFiles(silgi) {
-  const data = await createCoreFramework(silgi);
-  await generateSilgiStorageBaseType(silgi);
-  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 schemaTemplate(silgi);
-  const coreContent = await silgiCoreFile({
-    _importItems: data?.importItems ?? {},
-    _customImports: data?.customImports ?? []
-  }, data?.content ?? [], 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);
-  const silgiDir = resolve(silgi.options.silgi.serverDir);
-  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(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: uris.join('\n'),
-    contents: ""
-  });
-  buildFiles.push({
-    path: join(silgiDir, "core.ts"),
-    contents: coreContent.join("\n")
-  });
-  buildFiles.push({
-    path: join(typesDir, "schema.d.ts"),
-    contents: schemaContent.join("\n")
-  });
-  buildFiles.push({
-    path: join(typesDir, "silgi-imports.d.ts"),
-    contents: [...autoImportedTypes, autoImportExports || "export {}"].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) {
-    await writeFile(
-      resolve(silgi.options.build.dir, file.path),
-      file.contents
-    );
-  }
-  await scanUris(silgi);
-  const readCore = await readCoreFile(silgi);
-  silgi.uris = readCore.object.uris;
-  silgi.modulesURIs = readCore.object.modulesURIs;
-  silgi.schemas = readCore.object.schemas;
-  silgi.shareds = readCore.object.shareds;
-  await silgi.hooks.callHook("finish:types", readCore);
-}
-
-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 }
-      ],
-      from: "nitropack/types"
-    };
-    data.importItems.h3 = {
-      import: [
-        { name: "H3Event", type: true }
-      ],
-      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 }
-      ],
-      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 }
-      ],
-      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 }
-      ],
-      from: "nitropack/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "silgi/types" {',
-      "  interface SilgiRuntimeOptions 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) {
-      if (module.meta._packageName || silgi.options.preset === "npm-package") {
-        continue;
-      }
-      const exports = module.meta.exports;
-      if (!exports?.length)
-        continue;
-      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)
-      };
-      const exportedTypes = exports.filter((exp) => exp.type).map((exp) => exp.name);
-      if (exportedTypes.includes("ModuleOptions")) {
-        const importName = pascalCase(`${configKey}Config`);
-        options.importItems[configKey].import.push({
-          name: `ModuleOptions as ${importName}`,
-          type: true
-        });
-        options.options.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("SilgiRuntimeOptions")) {
-        const importName = pascalCase(`${configKey}RuntimeConfig`);
-        options.importItems[configKey].import.push({
-          name: `SilgiRuntimeOptions as ${importName}`,
-          type: true
-        });
-        options.runtimeOptions.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeContext")) {
-        const importName = pascalCase(`${configKey}RuntimeContext`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeContext as ${importName}`,
-          type: true
-        });
-        options.contexts.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeAction")) {
-        const importName = pascalCase(`${configKey}Action`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeAction as ${importName}`,
-          type: true
-        });
-        options.actions.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeShareds")) {
-        const importName = pascalCase(`${configKey}Shared`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeShareds as ${importName}`,
-          type: true
-        });
-        options.shareds.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleHooks")) {
-        const importName = pascalCase(`${configKey}Hooks`);
-        options.importItems[configKey].import.push({
-          name: `ModuleHooks as ${importName}`,
-          type: true
-        });
-        options.hooks.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeHooks")) {
-        const importName = pascalCase(`${configKey}RuntimeHooks`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeHooks as ${importName}`,
-          type: true
-        });
-        options.runtimeHooks.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeOptions")) {
-        const importName = pascalCase(`${configKey}RuntimeOptions`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeOptions as ${importName}`,
-          type: true
-        });
-        options.runtimeOptions.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("SilgiRuntimeMethods")) {
-        const importName = pascalCase(`${configKey}RuntimeMethods`);
-        options.importItems[configKey].import.push({
-          name: `SilgiRuntimeMethods as ${importName}`,
-          type: true
-        });
-        options.methods.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) {
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias
-  });
-  for (const module of silgi.scanModules) {
-    if (hasInstalledModule(module.meta.configKey)) {
-      silgi.logger.info(`Module ${module.meta.configKey} installed`);
-    }
-    try {
-      const silgiModule = await jiti.import(module.entryPath, {
-        default: true,
-        conditions: silgi.options.conditions
-      });
-      if (silgiModule.name !== "silgiNormalizedModule") {
-        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
-        continue;
-      }
-      await installModule(silgiModule, silgi);
-    } catch (err) {
-      silgi.logger.error(err);
-    }
-  }
-}
-async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions) {
-  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-  const res = await silgiModule({}, silgi) ?? {};
-  if (res === false) {
-    return false;
-  }
-  const metaData = await silgiModule.getMeta?.();
-  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 logger$1 = consola$1;
-async function _resolveSilgiModule(mod, silgi) {
-  let _url;
-  let buildTimeModuleMeta = {};
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias
-  });
-  if (typeof mod === "string") {
-    const paths = /* @__PURE__ */ new Set();
-    mod = resolveAlias$1(mod, silgi.options.alias);
-    if (isRelative(mod)) {
-      mod = resolve(silgi.options.rootDir, mod);
-    }
-    paths.add(join(mod, "module"));
-    paths.add(mod);
-    for (const path of paths) {
-      try {
-        const src = isAbsolute(path) ? pathToFileURL(await resolvePath$1(path, { fallbackToOriginal: false, extensions: silgi.options.extensions })).href : await resolve$1(path, { url: silgi.options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: silgi.options.extensions });
-        mod = await jiti.import(src, {
-          default: true,
-          conditions: silgi.options.conditions
-        });
-        _url = fileURLToPath(new URL(src));
-        const moduleMetadataPath = new URL("module.json", src);
-        if (existsSync(moduleMetadataPath)) {
-          buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-        } else {
-          if (typeof mod === "function") {
-            const meta = await mod.getMeta?.();
-            const _exports = await scanExports(_url, true);
-            buildTimeModuleMeta = {
-              ...meta,
-              exports: _exports.map(({ from, ...rest }) => rest)
-            };
-          }
-        }
-        break;
-      } 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") {
-          continue;
-        }
-        logger$1.error(`Error while importing module \`${mod}\`: ${error}`);
-        throw error;
-      }
-    }
-  }
-  if (!buildTimeModuleMeta) {
-    throw new Error(`Module ${mod} is not a valid Silgi module`);
-  }
-  if (typeof mod === "function") {
-    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
-      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
-    }
-    const options = await mod.getOptions?.() || {};
-    if (options) {
-      silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(
-        silgi.options._c12.config[buildTimeModuleMeta.configKey] || {},
-        options || {}
-      );
-    }
-    silgi.scanModules.push({
-      meta: buildTimeModuleMeta,
-      entryPath: _url,
-      installed: false,
-      options
-    });
-  }
-}
-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 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;
-}
-
-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) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
-  }
-  parseTSInterfaceDeclaration(ast) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
-  }
-  parseTypeDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseVariableDeclaration(ast)) {
-      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)) {
-      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 scanFiles$1(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$1.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 = readFileSync(filePath, "utf-8");
-      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
-      const createServices = exportVariables("createService", filePath);
-      if (createServices.length > 0) {
-        for (const createService of createServices) {
-          const { exportName, path } = createService;
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.services.push(_name);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`
-            });
-          });
-        }
-      }
-      const createSchemas = exportVariables("createSchema", filePath);
-      if (createSchemas.length > 0) {
-        for (const createSchema of createSchemas) {
-          const { exportName, path } = createSchema;
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.schemas.push(_name);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`
-            });
-          });
-        }
-      }
-      const createShareds = exportVariables("createShared", filePath);
-      if (createShareds.length > 0) {
-        for (const createShared of createShareds) {
-          const { exportName, path } = createShared;
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.shareds.push(_name);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              // Relative path kaldirmamiz gerekiyor bunlar hooklarin bittigi yerde karar verilmeli.
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`
-            });
-          });
-        }
-      }
-      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
-      if (sharedsTypes.length > 0) {
-        for (const sharedType of sharedsTypes) {
-          const { exportName, path } = sharedType;
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.shareds.push({
-              key: _name,
-              value: _name
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              type: true
-            });
-          });
-        }
-      }
-      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
-      if (contextTypes.length > 0) {
-        for (const contextType of contextTypes) {
-          const { exportName, path } = contextType;
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.contexts.push({
-              key: _name,
-              value: _name
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              type: true
-            });
-          });
-        }
-      }
-    }
-  }
-}
-
-async function createStorageCLI(silgi) {
-  const storage = createStorage();
-  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);
-      storage.mount(path, driver(opts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-
-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));
-      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) {
-    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 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)
-  });
-}
-
-async function installPackages(silgi) {
-  const packages = {
-    dependencies: {
-      "@fastify/deepmerge": peerDependencies["@fastify/deepmerge"],
-      ...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 _deepFreeze(object) {
-  const propNames = Object.getOwnPropertyNames(object);
-  for (const name of propNames) {
-    const value = object[name];
-    if (value && typeof value === "object") {
-      _deepFreeze(value);
-    }
-  }
-  return Object.freeze(object);
-}
-function useCLIRuntimeConfig(silgi) {
-  const _inlineRuntimeConfig = silgi.options.runtimeConfig;
-  const envOptions = {
-    prefix: "NITRO_",
-    altPrefix: process.env.NITRO_ENV_PREFIX ?? process.env.SILGI_ENV_PREFIX ?? "_",
-    silgiPrefix: "SILGI_",
-    envExpansion: process.env.NITRO_ENV_EXPANSION ?? process.env.SILGI_ENV_EXPANSION ?? false,
-    ...silgi.options.envOptions
-  };
-  silgi.hook("prepare:core.ts", (data) => {
-    data.cliOptions.envOptions = envOptions;
-  });
-  const _sharedRuntimeConfig = _deepFreeze(
-    applyEnv(klona(_inlineRuntimeConfig), envOptions)
-  );
-  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(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 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 createSilgiCLI(config = {}, opts = {}) {
-  const options = await loadOptions(config, opts);
-  await prepareEnv(options);
-  const hooks = createHooks();
-  const silgi = {
-    modulesURIs: {},
-    scannedURIs: /* @__PURE__ */ new Map(),
-    services: {},
-    uris: {},
-    shareds: {},
-    schemas: {},
-    unimport: void 0,
-    options,
-    hooks,
-    // vfs: {}
-    _requiredModules: {},
-    logger: consola$1.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) {
-    }
-  };
-  useCLIRuntimeConfig(silgi);
-  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"
-    });
-  }
-  for (const framework of frameworkSetup) {
-    await framework(silgi);
-  }
-  await scanAndSyncOptions(silgi);
-  await scanModules$1(silgi);
-  await scanFiles$1(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.push(
-      join(silgi.options.serverDir, "**/*")
-    );
-    silgi.options.imports.presets.push({
-      from: "silgi/types",
-      imports: autoImportTypes.map((type) => type),
-      type: true
-    });
-    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);
-  return silgi;
-}
+import 'pkg-types';
+import 'pathe/utils';
+import './types.mjs';
 
 const prepare = defineCommand({
   meta: {
@@ -1942,27 +57,25 @@ const prepare = defineCommand({
     }
   },
   async run({ args }) {
-    async function generate() {
-      const rootDir = resolve(args.dir || args._dir || ".");
-      const silgi = await createSilgiCLI({
-        rootDir,
-        dev: args.stub,
-        stub: args.stub,
-        preset: args.preset,
-        commandType: "prepare"
-      });
-      await prepare$1();
-      await writeTypesAndFiles(silgi);
-      await silgi.callHook("read:core.ts", async () => {
-        const data = await readCoreFile(silgi);
-        return data;
-      });
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const silgi = await createSilgiCLI({
+      rootDir,
+      dev: args.stub,
+      stub: args.stub,
+      preset: args.preset,
+      commandType: "prepare"
+    });
+    await prepare$1();
+    await writeTypesAndFiles(silgi);
+    await writeCoreFile(silgi);
+    const close = async () => {
       await silgi.close();
-    }
-    await generate();
-    await generate();
+      await silgi.callHook("close", silgi);
+      consola.withTag("silgi").success("Process terminated");
+    };
+    await silgi.callHook("close", silgi);
     consola.withTag("silgi").success("Prepare completed");
-    process.exit(0);
+    await close();
   }
 });