silgi 0.30.0 → 0.30.2

package/dist/cli/prepare.mjs

@@ -1,15 +1,2379 @@
 import { defineCommand, runCommand } from 'citty';
-import { resolve } from 'pathe';
+import { join, resolve, dirname, relative, isAbsolute, basename, extname } from 'pathe';
 import { version } from 'silgi/meta';
-import { p as prepareEnv, c as createSilgiCLI, b as build } from './silgi.mjs';
-import { execSync } from 'node:child_process';
+import { generateDTS } from 'apiful/openapi';
+import consola$1, { consola } from 'consola';
+import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, writeFile, genEnsureSafeVar, baseHeaderBannerComment, addImports, hash, toArray, relativeWithDot, isDirectory, isPresents, addCoreFile, resolveAlias as resolveAlias$1, directoryToURL, hasError, removeExtension, parseServices, resolveSilgiPath } from 'silgi/kit';
+import { mkdirSync, existsSync, writeFileSync, promises, readFileSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues, genAugmentation, genImport, genTypeImport } from 'knitwork';
+import { u as useSilgiCLI, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, findTypeExports, findExports } from 'mlly';
+import { resolveAlias } from 'pathe/utils';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { toExports, scanExports, createUnimport } from 'unimport';
+import { generateTypes, resolveSchema } from 'untyped';
+import { s as silgiGenerateType, l as loadOptions } from './types.mjs';
+import { createHooks, createDebugger } from 'hookable';
+import { useSilgiCLI as useSilgiCLI$1, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
+import { c as createRouteRules } from '../_chunks/routeRules.mjs';
 import * as p from '@clack/prompts';
 import { isCancel, cancel } from '@clack/prompts';
-import { consola } from 'consola';
+import * as dotenv from 'dotenv';
 import { createJiti } from 'dev-jiti';
-import { useSilgiCLI } from 'silgi';
-import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { l as loadOptions } from './types.mjs';
+import { h as hasInstalledModule } from './compatibility.mjs';
+import { fileURLToPath } from 'node:url';
+import { defu } from 'defu';
+import { resolveModuleURL } from 'exsolve';
+import { isRelative, withTrailingSlash } from 'ufo';
+import { globby } from 'globby';
+import ignore from 'ignore';
+import { parseSync } from '@oxc-parser/wasm';
+import { klona } from 'klona';
+import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
+import { createStorage, builtinDrivers } from 'unstorage';
+import { snakeCase } from 'scule';
+import { execSync } from 'node:child_process';
+
+async function generateApiFul(silgi) {
+  const config = silgi.options.apiFul;
+  if (!hasSilgiModule("openapi")) {
+    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) => {
+    const dir = tmpl.where === ".silgi" ? app.options.build.dir : tmpl.where === "server" ? app.options.silgi.serverDir : tmpl.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
+    return normalizeTemplate(tmpl, dir);
+  });
+  const filteredTemplates = {
+    pre: [],
+    post: []
+  };
+  for (const template of app.templates) {
+    if (options.filter && !options.filter(template)) {
+      continue;
+    }
+    const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
+    filteredTemplates[key].push(template);
+  }
+  const templateContext = { app };
+  const writes = [];
+  const dirs = /* @__PURE__ */ new Set();
+  const changedTemplates = [];
+  async function processTemplate(template) {
+    const dir = template.where === ".silgi" ? app.options.build.dir : template.where === "server" ? app.options.silgi.serverDir : template.where === "client" ? app.options.silgi.clientDir : app.options.silgi.vfsDir;
+    const fullPath = template.dst || resolve(dir, template.filename);
+    const start = performance.now();
+    const contents = await compileTemplate(template, templateContext).catch((e) => {
+      logger.error(`Could not compile template \`${template.filename}\`.`);
+      logger.error(e);
+      throw e;
+    });
+    template.modified = true;
+    if (template.modified) {
+      changedTemplates.push(template);
+    }
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (app.options.debug || setupTime > 500) {
+      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+    }
+    if (template.modified && template.write) {
+      dirs.add(dirname(fullPath));
+      if (template.skipIfExists && existsSync(fullPath)) {
+        return;
+      }
+      writes.push(() => writeFileSync(fullPath, contents, "utf8"));
+    }
+  }
+  await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
+  await Promise.allSettled(filteredTemplates.post.map(processTemplate));
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const write of writes) {
+    if (!app.errors.length) {
+      write();
+    }
+  }
+  if (changedTemplates.length) {
+    await app.callHook("app:templatesGenerated", app, changedTemplates, options);
+  }
+}
+async function compileTemplate(template, ctx) {
+  delete ctx.utils;
+  if (template.src) {
+    try {
+      return await promises.readFile(template.src, "utf-8");
+    } catch (err) {
+      logger.error(`[nuxt] Error reading template from \`${template.src}\``);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents({
+      ...ctx,
+      options: template.options
+    });
+  }
+  throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
+}
+
+async function prepare$1(_silgi) {
+}
+
+async function exportRules(silgi) {
+  try {
+    if (!silgi?.routeRules?.exportRules) {
+      throw new Error("Invalid silgi configuration: routeRules or exportRules is undefined");
+    }
+    const exportedRules = silgi.routeRules.exportRules();
+    if (!exportedRules || typeof exportedRules !== "object") {
+      throw new Error("No valid route rules to export");
+    }
+    const content = `/* eslint-disable */
+// @ts-nocheck
+// This file is auto-generated at build time by Silgi
+// Contains route rules with preserved functions
+// DO NOT MODIFY THIS FILE DIRECTLY
+
+export const routeRules = ${genObjectFromRawEntries(
+      Object.entries(exportedRules).map(([key, value]) => {
+        if (typeof value === "function") {
+          return [key, genObjectFromRaw(value)];
+        }
+        return [key, genObjectFromValues(value)];
+      })
+    )}
+`;
+    const serverDir = silgi.options.silgi.serverDir;
+    if (!serverDir) {
+      throw new Error("Server directory not defined in configuration");
+    }
+    const file = join(serverDir, "rules.ts");
+    if (!silgi.errors.length) {
+      await writeFile(file, content);
+    }
+  } catch (error) {
+    console.error("\u274C Failed to prepare build:", error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+function debugMode(name) {
+  const silgi = useSilgiCLI();
+  if (silgi.options.debug === true || typeof silgi.options.debug === "object" && silgi.options.debug[name]) {
+    return true;
+  }
+  return false;
+}
+
+async function prepareCommands(silgi = useSilgiCLI()) {
+  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 prepareConfigs(silgi) {
+  const _data = {
+    runtimeConfig: {}
+  };
+  for (const module of silgi.scanModules) {
+    if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) {
+      for (const key of module.meta.cliToRuntimeOptionsKeys) {
+        _data[module.meta.configKey] = {
+          ..._data[module.meta.configKey],
+          [key]: module.options[key]
+        };
+      }
+    } else {
+      _data[module.meta.configKey] = {};
+    }
+  }
+  await silgi.callHook("prepare:configs.ts", _data);
+  const importData = [
+    "import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
+    "import { useSilgiRuntimeConfig } from 'silgi/runtime'",
+    "",
+    `export const runtimeConfig: Partial<SilgiRuntimeConfig> = ${genObjectFromRawEntries(
+      Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]),
+      ""
+    )}`,
+    "",
+    "const runtime = useSilgiRuntimeConfig(undefined, runtimeConfig)",
+    ""
+  ];
+  delete _data.runtimeConfig;
+  importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(
+    Object.entries(_data).map(
+      ([key, value]) => [key, genEnsureSafeVar(value)]
+    ).concat(
+      [
+        ["runtimeConfig", "runtime"]
+      ]
+    )
+  )}`);
+  importData.unshift(...baseHeaderBannerComment);
+  return importData;
+}
+
+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: "uris"
+          },
+          {
+            name: "services"
+          },
+          {
+            name: "shareds"
+          },
+          {
+            name: "schemas"
+          },
+          {
+            name: "modulesURIs"
+          }
+        ]
+      },
+      {
+        specifier: "./configs",
+        imports: [
+          {
+            name: "cliConfigs"
+          }
+        ]
+      },
+      {
+        specifier: "./rules",
+        imports: [
+          {
+            name: "routeRules"
+          }
+        ]
+      }
+    ],
+    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,",
+    " schemas: schemas,",
+    " uris,",
+    " modulesURIs,",
+    ` 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,",
+    "   routeRules: routeRules as any,",
+    `   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 configs = await prepareConfigs(silgi);
+  const silgiDir = resolve(silgi.options.silgi.serverDir);
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(silgiDir, "core.ts"),
+    contents: coreContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(silgiDir, "configs.ts"),
+    contents: configs.join("\n")
+  });
+  for await (const file of buildFiles) {
+    if (!silgi.errors.length) {
+      await writeFile(
+        resolve(silgi.options.build.dir, file.path),
+        file.contents
+      );
+    }
+  }
+}
+
+async function generateRouterDTS(silgi) {
+  const uris = silgi.uris;
+  const subPath = "srn";
+  const groupedPaths = /* @__PURE__ */ new Map();
+  Object.entries(uris || {}).forEach(([key, params]) => {
+    const [service, resource, method, action] = key.split("/");
+    const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
+    const fullPath = `${subPath}/${service}/${resource}/${action}`;
+    if (!groupedPaths.has(basePath)) {
+      groupedPaths.set(basePath, /* @__PURE__ */ new Map());
+    }
+    groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
+  });
+  const keys = [
+    "  keys: {",
+    Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
+      return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
+      ${method}: '/${path}'`).join(",")}
+    }`;
+    }).join(",\n"),
+    "  }",
+    ""
+  ].join("\n");
+  const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
+    const [service, resource, method, action] = key.split("/");
+    const routePath = `${subPath}/${service}/${resource}/${action}`;
+    if (!acc[routePath]) {
+      acc[routePath] = {};
+    }
+    acc[routePath][method] = {
+      input: `ExtractInputFromURI<'${key}'>`,
+      output: `ExtractOutputFromURI<'${key}'>`,
+      queryParams: `ExtractQueryParamsFromURI<'${key}'>`,
+      pathParams: `ExtractPathParamsFromURI<'${key}'>`
+    };
+    return acc;
+  }, {});
+  const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
+    const methodEntries = Object.entries(methods).map(([method, { input, output, queryParams, pathParams }]) => {
+      return `    '${method}': {
+      input: ${input},
+      output: ${output},
+      queryParams: ${queryParams},
+      pathParams: ${pathParams}
+    }`;
+    }).join(",\n");
+    return `  '/${path}': {
+${methodEntries}
+  }`;
+  });
+  const nitro = [
+    "declare module 'nitropack/types' {",
+    "  interface InternalApi extends RouterTypes {}",
+    "}"
+  ];
+  const content = [
+    keys.slice(0, -1),
+    // son satırdaki boş satırı kaldır
+    ...routerTypes
+  ].join(",\n");
+  const context = [
+    "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractQueryParamsFromURI, ExtractPathParamsFromURI } from 'silgi/types'",
+    "",
+    "export interface RouterTypes {",
+    content,
+    "}",
+    "",
+    "declare module 'silgi/types' {",
+    "  interface SilgiRouterTypes extends RouterTypes {",
+    "  }",
+    "}",
+    "",
+    silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
+    "",
+    "export {}"
+  ];
+  return context;
+}
+
+async function prepareSchema(silgi) {
+  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
+    imports: [
+      {
+        specifier: relativeWithDot(
+          silgi.options.build.typesDir,
+          `${silgi.options.silgi.serverDir}/scan`
+        ),
+        imports: [
+          {
+            name: "modulesURIs"
+          }
+        ]
+      }
+    ],
+    typeImports: [
+      {
+        specifier: "silgi/types",
+        imports: [
+          {
+            name: "URIsTypes"
+          },
+          {
+            name: "Namespaces"
+          },
+          {
+            name: "SilgiRuntimeContext"
+          }
+        ]
+      }
+    ]
+  });
+  const data = {
+    addImportItem,
+    addImportItemType,
+    options: [],
+    contexts: [],
+    actions: [],
+    shareds: [
+      {
+        key: "modulesURIs",
+        value: "{ modulesURIs: typeof modulesURIs }"
+      }
+    ],
+    events: [],
+    hooks: [],
+    runtimeHooks: [],
+    runtimeOptions: [],
+    methods: [],
+    routeRules: [],
+    routeRulesConfig: []
+  };
+  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 = [
+    generateTypes(
+      await resolveSchema(
+        {
+          ...silgi.options.namespaces?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {}
+        }
+      ),
+      {
+        interfaceName: "InferredNamespaces",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ),
+    "",
+    `type SchemaExtends = Namespaces<typeof import('${silgiScanTS}')['schemas']>`,
+    "",
+    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiScanTS}')['uris']>`,
+    "",
+    `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
+    "",
+    data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${data.events.map((item) => {
+      if (item.isSilgiContext) {
+        addSilgiContext = true;
+      }
+      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiRuntimeContext" : "";
+    }).join(",\n")}
+}` : "interface SilgiModuleEventsExtends {}",
+    "",
+    `type RuntimeActionExtends = ${data.actions?.length ? data.actions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeRouteRulesExtends = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type RuntimeRouteRulesConfigExtends = ${data.routeRulesConfig?.length ? data.routeRulesConfig.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiModuleSharedExtends = ${data.shareds.length ? data.shareds.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiModuleOptionExtend = ${data.options?.length ? data.options.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(
+      await resolveSchema(
+        {
+          ...Object.fromEntries(
+            Object.entries(silgi.options.runtimeConfig).filter(
+              ([key]) => !["app", "nitro", "nuxt"].includes(key)
+            )
+          )
+        }
+      ),
+      {
+        interfaceName: "SilgiRuntimeConfigExtends",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ) : "",
+    "",
+    generateTypes(
+      await resolveSchema(
+        {
+          ...silgi.options.storages?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {},
+          // 'redis': {} -> 'redis': string
+          ...Object.entries(silgi.options.storage).map(([key]) => ({
+            [key]: ""
+          })).reduce((acc, obj) => ({ ...acc, ...obj }), {})
+        }
+      ),
+      {
+        interfaceName: "SilgiStorageBaseExtends",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ),
+    "",
+    `type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    genAugmentation("silgi/types", {
+      FrameworkContext: [{}, { extends: ["FrameworkContextExtends"] }],
+      SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
+      SilgiNamespaces: [{}, { extends: ["InferredNamespaces"] }],
+      SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
+      SilgiURIs: [{}, { extends: ["SilgiURIsMerge"] }],
+      SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
+      SilgiEvents: [{}, { extends: ["SilgiModuleEventsExtends"] }],
+      SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
+      SilgiRuntimeActions: [{}, { extends: ["RuntimeActionExtends"] }],
+      SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
+      SilgiRuntimeHooks: [{}, { extends: ["SilgiRuntimeHooksExtends"] }],
+      SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
+      SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
+      SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
+      SilgiRuntimeRouteRules: [{}, { extends: ["RuntimeRouteRulesExtends"] }],
+      SilgiRuntimeRouteRulesConfig: [{}, { extends: ["RuntimeRouteRulesConfigExtends"] }],
+      SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }]
+    }).replace(/,\s*/g, "\n"),
+    "",
+    "export {}"
+  ];
+  await silgi.callHook("after:schema.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+async function writeTypesAndFiles(silgi) {
+  const routerDTS = await generateRouterDTS(silgi);
+  silgi.hook("prepare:types", (opts) => {
+    opts.references.push({ path: "./schema.d.ts" });
+    opts.references.push({ path: "./silgi-routes.d.ts" });
+  });
+  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(i.from, silgi.options.alias);
+      if (isAbsolute(path)) {
+        const resolvedPath = await resolvePath(i.from, {
+          url: silgi.options.nodeModulesDirs
+        }).catch(() => null);
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(i.from, path);
+    }
+    autoImportedTypes = [
+      silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
+      })).trim() : ""
+    ];
+  }
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "silgi-routes.d.ts"),
+    contents: routerDTS.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "schema.d.ts"),
+    contents: schemaContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi.d.ts"),
+    contents: declarations.join("\n")
+  });
+  buildFiles.push({
+    path: tsConfigPath,
+    contents: JSON.stringify(tsConfig, null, 2)
+  });
+  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 prepare$1();
+  await generateApiFul(silgi);
+  await prepareCommands(silgi);
+  await writeCoreFile(silgi);
+  await exportRules(silgi);
+  await writeTypesAndFiles(silgi);
+  await generateApp(silgi);
+}
+
+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) {
+    silgi.hook("after:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = {}");
+    });
+  }
+}
+
+async function h3Framework(silgi, skip = false) {
+  if (!isPresents(["h3"]) && skip === false)
+    return;
+  if (isPresents(["h3"])) {
+    silgi.hook("after:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = NitroApp");
+    });
+  }
+  silgi.hook("before:schema.ts", (data) => {
+    data.addImportItemType([
+      {
+        imports: [
+          {
+            name: "H3Event"
+          }
+        ],
+        specifier: "h3"
+      },
+      {
+        imports: [
+          {
+            name: "NitroApp"
+          }
+        ],
+        specifier: "nitropack/types"
+      }
+    ]);
+    data.events.push({
+      key: "H3Event",
+      value: "H3Event",
+      extends: true,
+      isSilgiContext: false
+    });
+  });
+  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 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.hook("after: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:types", (opts) => {
+    addTemplate({
+      filename: "types/nitro.d.ts",
+      where: ".silgi",
+      getContents: () => {
+        return [
+          "import type { NitroRuntimeConfig } from 'nitropack/types'",
+          "",
+          'declare module "silgi/types" {',
+          "  interface SilgiRuntimeConfig extends NitroRuntimeConfig {}",
+          "}",
+          ""
+        ].join("\n");
+      }
+    });
+    opts.references.push({ path: "./nitro.d.ts" });
+  });
+  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
+];
+
+async function registerModuleExportScan(silgi) {
+  silgi.hook("before:schema.ts", async (options) => {
+    for (const module of silgi.scanModules) {
+      const moduleReExports = [];
+      if (!module.entryPath) {
+        continue;
+      }
+      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
+      const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
+      for (const e of findTypeExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      for (const e of findExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
+      const configKey = module.meta.configKey;
+      const moduleName = module.meta.name || module.meta._packageName;
+      const specifier = module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath);
+      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("ModuleRuntimeActions")) {
+        const importName = hash(`${configKey}ModuleRuntimeActions`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeActions"
+            }
+          ],
+          specifier
+        });
+        options.actions.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("ModuleRuntimeRouteRules")) {
+        const importName = hash(`${configKey}ModuleRuntimeRouteRules`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeRouteRules"
+            }
+          ],
+          specifier
+        });
+        options.routeRules.push({ key: configKey, value: importName });
+      }
+      if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
+        const importName = hash(`${configKey}ModuleRuntimeRouteRulesConfig`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeRouteRulesConfig"
+            }
+          ],
+          specifier
+        });
+        options.routeRulesConfig.push({ key: configKey, value: importName });
+      }
+    }
+  });
+}
+
+async function loadSilgiModuleInstance(silgiModule) {
+  if (typeof silgiModule === "string") {
+    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+  }
+  if (typeof silgiModule !== "function") {
+    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
+  }
+  return { silgiModule };
+}
+async function installModules(silgi, prepare = false) {
+  silgi.options.isPreparingModules = prepare;
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias,
+    fsCache: true,
+    moduleCache: true
+  });
+  for (const module of silgi.scanModules) {
+    if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) {
+      silgi.logger.info(`Module ${module.meta.configKey} installed`);
+    }
+    try {
+      const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
+        default: true,
+        conditions: silgi.options.conditions
+      }) : module.module;
+      if (silgiModule.name !== "silgiNormalizedModule") {
+        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
+        continue;
+      }
+      await installModule(silgiModule, silgi, prepare);
+    } catch (err) {
+      silgi.logger.error(err);
+    }
+  }
+  silgi.options.isPreparingModules = false;
+}
+async function installModule(moduleToInstall, silgi = useSilgiCLI$1(), inlineOptions, prepare = false) {
+  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
+  const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
+  if (res === false) {
+    return false;
+  }
+  const metaData = await silgiModule.getMeta?.();
+  if (prepare) {
+    return metaData;
+  }
+  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
+  if (installedModule) {
+    installedModule.installed = true;
+  } else {
+    throw new Error(`Module ${metaData?.name} not found`);
+  }
+}
+
+const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
+async function _resolveSilgiModule(silgiModule, silgi) {
+  let resolvedModulePath;
+  let buildTimeModuleMeta = {};
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias,
+    fsCache: true,
+    moduleCache: true
+  });
+  if (typeof silgiModule === "string") {
+    silgiModule = resolveAlias$1(silgiModule, silgi.options.alias);
+    if (isRelative(silgiModule)) {
+      silgiModule = resolve(silgi.options.rootDir, silgiModule);
+    }
+    try {
+      const src = resolveModuleURL(silgiModule, {
+        from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
+        suffixes: ["silgi", "silgi/index", "module", "module/index", "", "index"],
+        extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
+        // Maybe add https://github.com/unjs/exsolve/blob/dfff3e9bbc4a3a173a2d56b9b9ff731ab15598be/src/resolve.ts#L7
+        // conditions: silgi.options.conditions,
+      });
+      resolvedModulePath = fileURLToPath(src);
+      const resolvedSilgiModule = await jiti.import(src, { default: true });
+      if (typeof resolvedSilgiModule !== "function") {
+        throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
+      }
+      silgiModule = await jiti.import(src, {
+        default: true,
+        conditions: silgi.options.conditions
+      });
+      const moduleMetadataPath = new URL("module.json", src);
+      if (existsSync(moduleMetadataPath)) {
+        buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+      } else {
+        if (typeof silgiModule === "function") {
+          const meta = await silgiModule.getMeta?.();
+          const _exports = await scanExports(resolvedModulePath, true);
+          buildTimeModuleMeta = {
+            ...meta,
+            exports: _exports.map(({ from, ...rest }) => rest)
+          };
+        }
+      }
+    } catch (error) {
+      const code = error.code;
+      if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
+        throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+      }
+      if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+        const module = MissingModuleMatcher.exec(error.message)?.[1];
+        if (module && !module.includes(silgiModule)) {
+          throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
+        }
+      }
+    }
+  }
+  if (!buildTimeModuleMeta) {
+    throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
+  }
+  if (typeof silgiModule === "function") {
+    if (!buildTimeModuleMeta.configKey) {
+      const meta = await silgiModule.getMeta?.();
+      buildTimeModuleMeta = {
+        ...meta,
+        exports: []
+      };
+    }
+    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
+      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
+    }
+    const options = await silgiModule.getOptions?.() || {};
+    if (options) {
+      silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(
+        silgi.options._c12.config[buildTimeModuleMeta.configKey] || {},
+        options || {}
+      );
+    } else {
+      throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+    }
+    silgi.scanModules.push({
+      meta: buildTimeModuleMeta,
+      entryPath: resolvedModulePath || void 0,
+      installed: false,
+      options,
+      module: silgiModule
+    });
+  }
+}
+async function scanModules$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;
+}
+
+const safeFiles = [
+  "silgi/configs",
+  "silgi",
+  "silgi/rules",
+  "silgi/scan",
+  "silgi/vfs"
+];
+class SchemaParser {
+  options = {
+    debug: false
+  };
+  /**
+   *
+   */
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    if (this.options.debug)
+      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
+    return {
+      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
+      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
+      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
+    };
+  }
+  parseVariableDeclaration(ast, path) {
+    const silgi = useSilgiCLI$1();
+    if (ast.program.body.length === 0) {
+      if (safeFiles.find((i) => path.includes(i)))
+        return [];
+      silgi.errors.push({
+        type: "Parser",
+        path
+      });
+      consola$1.warn("This file has a problem:", path);
+    }
+    const variableDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
+    return variableDeclarations;
+  }
+  parseTSInterfaceDeclaration(ast, path = "") {
+    const silgi = useSilgiCLI$1();
+    if (ast.program.body.length === 0) {
+      if (safeFiles.find((i) => path.includes(i)))
+        return [];
+      silgi.errors.push({
+        type: "Parser",
+        path
+      });
+      consola$1.warn("This file has a problem:", path);
+    }
+    const interfaceDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
+    return interfaceDeclarations;
+  }
+  parseTypeDeclarations(ast, find = "", path = "") {
+    const data = [];
+    const variableDeclarations = this.parseVariableDeclaration(ast, path);
+    for (const item of variableDeclarations) {
+      for (const declaration of item.declaration.declarations) {
+        if (declaration.init?.callee?.name === find) {
+          const options = {};
+          if (declaration.init.arguments) {
+            for (const argument of declaration.init.arguments) {
+              for (const propertie of argument.properties) {
+                if (propertie.key.name === "name")
+                  options.pluginName = propertie.value.value;
+              }
+            }
+          }
+          for (const key in declaration.init.properties) {
+            const property = declaration.init.properties[key];
+            if (property.type === "ObjectProperty") {
+              if (property.key.name === "options") {
+                for (const key2 in property.value.properties) {
+                  const option = property.value.properties[key2];
+                  if (option.type === "ObjectProperty") {
+                    options[option.key.name] = option.value.value;
+                  }
+                }
+              }
+            }
+          }
+          options.type = false;
+          data.push({
+            exportName: declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  parseInterfaceDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseTSInterfaceDeclaration(ast, path)) {
+      if (!item?.declaration?.extends)
+        continue;
+      for (const declaration of item?.declaration?.extends) {
+        if (declaration.expression.name === find) {
+          const options = {};
+          options.type = true;
+          data.push({
+            exportName: item.declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  // private parsePlugin(ast: any, path: string = '') {
+  //   const data = {
+  //     export: [],
+  //     name: '',
+  //     path: '',
+  //   } as DataTypePlugin
+  //   for (const item of this.parseVariableDeclaration(ast)) {
+  //     for (const declaration of item.declaration.declarations) {
+  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
+  //         if (declaration.init.arguments) {
+  //           for (const argument of declaration.init.arguments) {
+  //             for (const propertie of argument.properties) {
+  //               if (propertie.key.name === 'name')
+  //                 data.name = propertie.value.value
+  //             }
+  //           }
+  //         }
+  //         data.export.push({
+  //           name: data.name,
+  //           as: camelCase(`${data.name}DefineSilgiModule`),
+  //           type: false,
+  //         })
+  //       }
+  //     }
+  //   }
+  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
+  //     if (!item?.declaration?.extends)
+  //       continue
+  //     for (const declaration of item?.declaration?.extends) {
+  //       if (declaration.expression.name === 'ModuleOptions') {
+  //         data.export.push({
+  //           name: item.declaration.id.name,
+  //           as: camelCase(`${data.name}ModuleOptions`),
+  //           type: true,
+  //         })
+  //       }
+  //       // TODO add other plugins
+  //     }
+  //   }
+  //   data.path = path
+  //   return data
+  // }
+}
+
+async function scanExportFile(silgi) {
+  const filePaths = /* @__PURE__ */ new Set();
+  const scannedPaths = [];
+  const dir = silgi.options.serverDir;
+  const files = (await globby(dir, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
+  if (files.length) {
+    const siblings = await readdir(dirname(dir)).catch(() => []);
+    const directory = basename(dir);
+    if (!siblings.includes(directory)) {
+      const directoryLowerCase = directory.toLowerCase();
+      const caseCorrected = siblings.find((sibling) => sibling.toLowerCase() === directoryLowerCase);
+      if (caseCorrected) {
+        const original = relative(silgi.options.serverDir, dir);
+        const corrected = relative(silgi.options.serverDir, join(dirname(dir), caseCorrected));
+        consola.warn(`Components not scanned from \`~/${corrected}\`. Did you mean to name the directory \`~/${original}\` instead?`);
+      }
+    }
+  }
+  for (const _file of files) {
+    const filePath = resolve(dir, _file);
+    if (scannedPaths.find((d) => filePath.startsWith(withTrailingSlash(d))) || isIgnored(filePath, silgi)) {
+      continue;
+    }
+    if (filePaths.has(filePath)) {
+      continue;
+    }
+    filePaths.add(filePath);
+    if (silgi.options.extensions.includes(extname(filePath))) {
+      const parser = new SchemaParser({
+        debug: false
+      });
+      const readfile = await readFile(filePath, "utf-8");
+      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
+      const createServices = exportVariables("createService", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      const scanTS = [];
+      const schemaTS = [];
+      if (createServices.length > 0) {
+        scanTS.push(...createServices.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "service" };
+        }));
+      }
+      const createSchemas = exportVariables("createSchema", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (createSchemas.length > 0) {
+        scanTS.push(...createSchemas.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "schema" };
+        }));
+      }
+      const createShareds = exportVariables("createShared", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (createShareds.length > 0) {
+        scanTS.push(...createShareds.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "shared" };
+        }));
+      }
+      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (sharedsTypes.length > 0) {
+        schemaTS.push(...sharedsTypes.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "shared" };
+        }));
+      }
+      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
+      if (hasError("Parser", silgi)) {
+        return;
+      }
+      if (contextTypes.length > 0) {
+        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
+          const randomString = hash(basename(path) + exportName);
+          const _name = `_v${randomString}`;
+          return { exportName, path, _name, type: "context" };
+        }));
+      }
+      silgi.hook("before:scan.ts", (options) => {
+        for (const { exportName, path, _name, type } of scanTS) {
+          if (!path.includes("vfs")) {
+            silgi.options.devServer.watch.push(path);
+          }
+          if (type === "service") {
+            options.services.push(_name);
+          }
+          if (type === "shared") {
+            options.shareds.push(_name);
+          }
+          if (type === "schema") {
+            options.schemas.push(_name);
+          }
+          options.addImportItem({
+            specifier: removeExtension(relativeWithDot(silgi.options.silgi.serverDir, path)),
+            imports: [
+              {
+                name: exportName,
+                as: _name
+              }
+            ]
+          });
+        }
+      });
+      silgi.hook("before:schema.ts", (options) => {
+        for (const { exportName, path, _name, type } of schemaTS) {
+          if (!path.includes("vfs")) {
+            silgi.options.devServer.watch.push(path);
+          }
+          if (type === "shared") {
+            options.shareds.push({
+              key: _name,
+              value: _name
+            });
+          }
+          if (type === "context") {
+            options.contexts.push({
+              key: _name,
+              value: _name
+            });
+          }
+          options.addImportItem({
+            imports: [
+              {
+                name: exportName,
+                as: _name
+              }
+            ],
+            specifier: removeExtension(relativeWithDot(silgi.options.build.typesDir, path))
+          });
+        }
+      });
+    }
+  }
+}
+
+function buildUriMap(silgi, currentPath = []) {
+  const uriMap = /* @__PURE__ */ new Map();
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let pathString = "";
+      if (node.pathParams) {
+        let paths = null;
+        if (node.pathParams?._def?.typeName !== void 0) {
+          try {
+            const shape = node.pathParams?.shape;
+            paths = shape ? Object.keys(shape) : null;
+          } catch {
+            paths = null;
+          }
+        }
+        if (paths?.length) {
+          pathString = paths.map((p) => `:${p}`).join("/");
+        }
+      }
+      uriMap.set(basePath, pathString);
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(silgi.schemas, currentPath);
+  silgi.uris = defu(silgi.uris, Object.fromEntries(uriMap));
+  return uriMap;
+}
+
+async function readScanFile(silgi) {
+  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
+  const context = await promises.readFile(path, { encoding: "utf-8" });
+  silgi.unimport = createUnimport(silgi.options.imports || {});
+  await silgi.unimport.init();
+  const injectedResult = await silgi.unimport.injectImports(context, path);
+  if (!injectedResult) {
+    throw new Error("Failed to inject imports");
+  }
+  const jiti = createJiti(silgi.options.rootDir, {
+    fsCache: true,
+    moduleCache: false,
+    debug: silgi.options.debug === true,
+    alias: silgi.options.alias
+  });
+  try {
+    globalThis._silgi_runtime = silgi.options.runtimeConfig;
+    injectedResult.code = `globalThis._silgi_runtime = ${JSON.stringify(silgi.options.runtimeConfig)};
+${injectedResult.code}`;
+    injectedResult.code = injectedResult.code.replace(/runtimeConfig: \{\}/, `runtimeConfig: ${JSON.stringify(silgi.options.runtimeConfig)}`);
+    const scanFile = await jiti.evalModule(
+      injectedResult.code,
+      {
+        filename: path,
+        async: true,
+        conditions: silgi.options.conditions
+      },
+      async (data, name) => {
+        return (await silgi.unimport.injectImports(data, name)).code;
+      }
+    );
+    silgi.uris = defu(silgi.uris, scanFile.uris) || {};
+    silgi.schemas = defu(scanFile.schemas, scanFile.uris) || {};
+    silgi.services = defu(scanFile.services, scanFile.uris) || {};
+    silgi.shareds = defu(scanFile.shareds, scanFile.shareds) || {};
+    silgi.modulesURIs = defu(scanFile.modulesURIs, scanFile.modulesURIs) || {};
+    return {
+      context,
+      object: {
+        schemas: scanFile.schemas,
+        uris: scanFile.uris,
+        services: scanFile.services,
+        shareds: scanFile.shareds,
+        modulesURIs: scanFile.modulesURIs
+      },
+      path
+    };
+  } catch (error) {
+    if (silgi.options.debug) {
+      console.error("Failed to read scan.ts file:", error);
+    } else {
+      consola.withTag("silgi").error(error);
+    }
+    return {
+      context,
+      object: {
+        schemas: {},
+        uris: {},
+        services: {},
+        shareds: {},
+        modulesURIs: {}
+      },
+      path
+    };
+  }
+}
+
+async function prepareScanFile(silgi) {
+  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
+    imports: [
+      {
+        specifier: "silgi",
+        imports: [
+          {
+            name: "createSilgi"
+          },
+          {
+            name: "createShared"
+          }
+        ]
+      },
+      {
+        specifier: "./configs",
+        imports: [
+          {
+            name: "cliConfigs"
+          }
+        ]
+      }
+    ],
+    typeImports: [
+      {
+        specifier: "silgi/types",
+        imports: [
+          {
+            name: "SilgiRuntimeOptions"
+          },
+          {
+            name: "FrameworkContext"
+          }
+        ]
+      }
+    ]
+  });
+  const scanned = {
+    uris: {},
+    services: [],
+    shareds: [],
+    schemas: [],
+    modulesURIs: {},
+    addImportItem,
+    addImportItemType
+  };
+  if (silgi.uris) {
+    defu(scanned.uris, silgi.uris);
+  }
+  if (silgi.modulesURIs) {
+    scanned.shareds.push(
+      `createShared({
+        modulesURIs,
+      })`
+    );
+    defu(scanned.modulesURIs, silgi.modulesURIs);
+  }
+  await silgi.callHook("before:scan.ts", scanned);
+  if (scanned.services.length > 0) {
+    addImportItem({
+      specifier: "silgi",
+      imports: {
+        name: "mergeServices"
+      }
+    });
+  }
+  if (scanned.shareds.length > 0) {
+    addImportItem({
+      specifier: "silgi",
+      imports: {
+        name: "mergeShared"
+      }
+    });
+  }
+  if (scanned.schemas.length > 0) {
+    addImportItem({
+      specifier: "silgi",
+      imports: {
+        name: "mergeSchemas"
+      }
+    });
+  }
+  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 const uris = ${JSON.stringify(scanned.uris, null, 2)}`,
+    "",
+    `export const modulesURIs = ${JSON.stringify(scanned.modulesURIs, null, 2)}`,
+    "",
+    scanned.schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
+    ...scanned.schemas.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.schemas.length > 0 ? "])" : "}",
+    "",
+    scanned.services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
+    ...scanned.services.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.services.length > 0 ? "])" : "}",
+    "",
+    scanned.shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
+    ...scanned.shareds.map((name) => {
+      return `  ${name},`;
+    }),
+    scanned.shareds.length > 0 ? "])" : "}",
+    ""
+  ];
+  await silgi.callHook("after:scan.ts", importData);
+  importData.unshift(...importsContent);
+  importData.unshift(...baseHeaderBannerComment);
+  return importData;
+}
+
+async function writeScanFiles(silgi) {
+  const data = await prepareScanFile(silgi);
+  if (!silgi.errors.length) {
+    await writeFile(
+      resolve(silgi.options.silgi.serverDir, "scan.ts"),
+      data.join("\n")
+    );
+  }
+  await readScanFile(silgi);
+  buildUriMap(silgi);
+  parseServices(silgi);
+  silgi.hook("before:scan.ts", (file) => {
+    file.uris = {
+      ...file.uris,
+      ...silgi.uris
+    };
+    file.modulesURIs = {
+      ...file.modulesURIs,
+      ...silgi.modulesURIs
+    };
+  });
+}
+
+async function createStorageCLI(silgi) {
+  const storage = createStorage();
+  const runtime = useSilgiRuntimeConfig();
+  const mounts = klona({
+    ...silgi.options.storage,
+    ...silgi.options.devStorage
+  });
+  for (const [path, opts] of Object.entries(mounts)) {
+    if (opts.driver) {
+      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+      const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
+      storage.mount(path, driver(processedOpts));
+    } else {
+      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+    }
+  }
+  return storage;
+}
+
+function useCLIRuntimeConfig(silgi) {
+  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
+  silgi.hook("prepare:configs.ts", (data) => {
+    data.runtimeConfig = safeRuntimeConfig;
+    silgi.options.envOptions = silgi.options.envOptions;
+  });
+  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;
+  }, {});
+}
+
+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);
+  const hooks = createHooks();
+  const silgi = {
+    modulesURIs: {},
+    scannedURIs: /* @__PURE__ */ new Map(),
+    services: {},
+    uris: {},
+    shareds: {},
+    schemas: {},
+    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,
+    async updateConfig(_config) {
+    },
+    routeRules: void 0,
+    adapters: {}
+  };
+  if (silgi.options.adapters && Object.keys(silgi.options.adapters)?.length > 0) {
+    for (const [key, value] of Object.entries(silgi.options.adapters)) {
+      silgi.adapters[key] = value;
+    }
+  }
+  await prepareEnv(options);
+  const routeRules = createRouteRules();
+  routeRules.importRules(options.routeRules ?? {});
+  silgi.routeRules = routeRules;
+  if (silgiCLICtx.tryUse()) {
+    silgiCLICtx.unset();
+    silgiCLICtx.set(silgi);
+  } else {
+    silgiCLICtx.set(silgi);
+    silgi.hook("close", () => silgiCLICtx.unset());
+  }
+  await silgi.hooks.callHook("ready", silgi);
+  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 scanExportFile(silgi);
+  await installModules(silgi, true);
+  useCLIRuntimeConfig(silgi);
+  await writeScanFiles(silgi);
+  silgi.storage = await createStorageCLI(silgi);
+  silgi.hooks.hook("close", async () => {
+    await silgi.storage.dispose();
+  });
+  if (silgi.options.logLevel !== void 0) {
+    silgi.logger.level = silgi.options.logLevel;
+  }
+  silgi.hooks.addHooks(silgi.options.hooks);
+  await installModules(silgi);
+  await silgi.hooks.callHook("scanFiles:done", silgi);
+  await generateApp(silgi);
+  if (silgi.options.imports) {
+    silgi.options.imports.dirs ??= [];
+    silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
+      if (typeof dir === "string") {
+        if (dir.startsWith("!")) {
+          return `!${resolveSilgiPath(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/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 writeScanFiles(silgi);
+  return silgi;
+}
 
 const commonArgs = {
   dir: {
@@ -65,7 +2429,7 @@ const command$1 = defineCommand({
         rawArgs: ["--commandType", "run"]
       });
     }
-    const silgi = useSilgiCLI();
+    const silgi = useSilgiCLI$1();
     if (!silgi) {
       throw new Error("Silgi is not initialized");
     }