silgi 0.27.6 → 0.27.8

package/dist/cli/prepare.mjs

@@ -1,1578 +1,16 @@
 import { defineCommand, runCommand } from 'citty';
-import { resolve, join, relative, dirname, basename, extname } from 'pathe';
-import { peerDependencies, version } from 'silgi/meta';
-import { g as generateApp, b as build } from './build.mjs';
-import consola, { consola as consola$1 } from 'consola';
-import { createHooks, createDebugger } from 'hookable';
-import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
-import { relativeWithDot, hash, resolveAlias, directoryToURL, addTemplate, hasError, writeFile, parseServices, resolveSilgiPath } from 'silgi/kit';
-import { runtimeDir } from 'silgi/runtime/meta';
-import { scanExports, createUnimport } from 'unimport';
-import { c as createRouteRules, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { resolve } 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 { readFileSync } from 'node:fs';
 import * as p from '@clack/prompts';
-import { existsSync, promises, readFileSync, writeFileSync } from 'node:fs';
-import * as dotenv from 'dotenv';
-import { resolveModuleExportNames, findTypeExports, findExports } from 'mlly';
+import { consola } from 'consola';
 import { createJiti } from 'dev-jiti';
-import { h as hasInstalledModule } from './compatibility.mjs';
-import { fileURLToPath } from 'node:url';
-import { defu } from 'defu';
-import { resolveModuleURL } from 'exsolve';
-import { isRelative, withTrailingSlash } from 'ufo';
-import { generateTypes, resolveSchema } from 'untyped';
-import { readdir, readFile } from 'node:fs/promises';
-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 { l as loadOptions } from './loader.mjs';
-import { execSync } from 'node:child_process';
 import color from 'picocolors';
-
-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:prepare:schema.ts", (data) => {
-      data.unshift("type FrameworkContextExtends = {}");
-    });
-  }
-}
-
-async function h3Framework(silgi, skip = false) {
-  if (silgi.options.preset !== "h3" && skip === false)
-    return;
-  if (silgi.options.preset === "h3") {
-    silgi.hook("after:prepare:schema.ts", (data) => {
-      data.unshift("type FrameworkContextExtends = NitroApp");
-    });
-  }
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.importItems.h3 = {
-      import: [
-        {
-          name: "H3Event",
-          type: true,
-          key: "H3Event"
-        }
-      ],
-      from: "h3"
-    };
-    data.events.push({
-      key: "H3Event",
-      value: "H3Event",
-      extends: true,
-      isSilgiContext: false
-    });
-  });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["silgi/types"] = {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "h3" {',
-      "  interface H3EventContext extends SilgiRuntimeContext {}",
-      "}",
-      ""
-    );
-  });
-  silgi.hook("prepare:core.ts", (data) => {
-    data._silgiConfigs.push(`captureError: (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) {
-    const h3Exports = await resolveModuleExportNames("h3", {
-      url: import.meta.url
-    });
-    silgi.options.imports.presets ??= [];
-    silgi.options.imports.presets.push({
-      from: "h3",
-      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
-    });
-  }
-}
-
-async function nitroFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nitro" && skip === false)
-    return;
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
-        }
-      ],
-      from: "nitropack/types"
-    };
-  });
-  silgi.hook("after:prepare:schema.ts", (data) => {
-    data.unshift("type FrameworkContextExtends = NitroApp");
-  });
-  silgi.options.plugins.push({
-    packageImport: "silgi/runtime/internal/nitro",
-    path: join(runtimeDir, "internal/nitro")
-  });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["nitropack/types"] = {
-      import: [
-        {
-          name: "NitroRuntimeConfig",
-          type: true,
-          key: "NitroRuntimeConfig"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "silgi/types" {',
-      "  interface SilgiRuntimeConfig extends NitroRuntimeConfig {}",
-      "}",
-      ""
-    );
-  });
-  if (silgi.options.imports !== false) {
-    silgi.options.imports.presets ??= [];
-  }
-  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("prepare:schema.ts", async (options) => {
-    for (const module of silgi.scanModules) {
-      const moduleReExports = [];
-      if (!module.entryPath) {
-        continue;
-      }
-      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
-      const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
-      for (const e of findTypeExports(normalisedModuleTypes)) {
-        moduleReExports.push(e);
-      }
-      for (const e of findExports(normalisedModuleTypes)) {
-        moduleReExports.push(e);
-      }
-      const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
-      const configKey = module.meta.configKey;
-      const moduleName = module.meta.name || module.meta._packageName;
-      options.importItems[configKey] = {
-        import: [],
-        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
-      };
-      if (hasTypeExport("ModuleOptions")) {
-        const importName = `_${hash(`${configKey}ModuleOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleOptions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.options.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeOptions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeOptions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.runtimeOptions.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeShareds")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeShareds`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeShareds as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.shareds.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleEvents")) {
-        const importName = `_${hash(`${configKey}ModuleEvents`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleEvents as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.events.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeContexts")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeContexts`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeContexts as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.contexts.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleHooks")) {
-        const importName = `_${hash(`${configKey}ModuleHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleHooks as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.hooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeHooks")) {
-        const importName = `_${hash(`${configKey}RuntimeHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeHooks as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.runtimeHooks.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeActions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeActions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeActions as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.actions.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeMethods")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeMethods`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeMethods as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.methods.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeRouteRules")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRules`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRules as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.routeRules.push({ key: configKey, value: importName });
-      }
-      if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRulesConfig`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRulesConfig as ${importName}`,
-          type: true,
-          key: importName
-        });
-        options.routeRulesConfig.push({ key: configKey, value: importName });
-      }
-    }
-  });
-}
-
-async function loadSilgiModuleInstance(silgiModule) {
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-  }
-  return { silgiModule };
-}
-async function installModules(silgi, prepare = false) {
-  silgi.options.isPreparingModules = prepare;
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias,
-    fsCache: true,
-    moduleCache: true
-  });
-  for (const module of silgi.scanModules) {
-    if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) {
-      silgi.logger.info(`Module ${module.meta.configKey} installed`);
-    }
-    try {
-      const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
-        default: true,
-        conditions: silgi.options.conditions
-      }) : module.module;
-      if (silgiModule.name !== "silgiNormalizedModule") {
-        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
-        continue;
-      }
-      await installModule(silgiModule, silgi, prepare);
-    } catch (err) {
-      silgi.logger.error(err);
-    }
-  }
-  silgi.options.isPreparingModules = false;
-}
-async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions, prepare = false) {
-  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-  const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
-  if (res === false) {
-    return false;
-  }
-  const metaData = await silgiModule.getMeta?.();
-  if (prepare) {
-    return metaData;
-  }
-  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
-  if (installedModule) {
-    installedModule.installed = true;
-  } else {
-    throw new Error(`Module ${metaData?.name} not found`);
-  }
-}
-
-const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
-async function _resolveSilgiModule(silgiModule, silgi) {
-  let resolvedModulePath;
-  let buildTimeModuleMeta = {};
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias,
-    fsCache: true,
-    moduleCache: true
-  });
-  if (typeof silgiModule === "string") {
-    silgiModule = resolveAlias(silgiModule, silgi.options.alias);
-    if (isRelative(silgiModule)) {
-      silgiModule = resolve(silgi.options.rootDir, silgiModule);
-    }
-    try {
-      const src = resolveModuleURL(silgiModule, {
-        from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
-        suffixes: ["silgi", "silgi/index", "module", "module/index", "", "index"],
-        extensions: [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]
-        // Maybe add https://github.com/unjs/exsolve/blob/dfff3e9bbc4a3a173a2d56b9b9ff731ab15598be/src/resolve.ts#L7
-        // conditions: silgi.options.conditions,
-      });
-      resolvedModulePath = fileURLToPath(src);
-      const resolvedSilgiModule = await jiti.import(src, { default: true });
-      if (typeof resolvedSilgiModule !== "function") {
-        throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
-      }
-      silgiModule = await jiti.import(src, {
-        default: true,
-        conditions: silgi.options.conditions
-      });
-      const moduleMetadataPath = new URL("module.json", src);
-      if (existsSync(moduleMetadataPath)) {
-        buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-      } else {
-        if (typeof silgiModule === "function") {
-          const meta = await silgiModule.getMeta?.();
-          const _exports = await scanExports(resolvedModulePath, true);
-          buildTimeModuleMeta = {
-            ...meta,
-            exports: _exports.map(({ from, ...rest }) => rest)
-          };
-        }
-      }
-    } catch (error) {
-      const code = error.code;
-      if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
-        throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-      }
-      if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
-        const module = MissingModuleMatcher.exec(error.message)?.[1];
-        if (module && !module.includes(silgiModule)) {
-          throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
-        }
-      }
-    }
-  }
-  if (!buildTimeModuleMeta) {
-    throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
-  }
-  if (typeof silgiModule === "function") {
-    if (!buildTimeModuleMeta.configKey) {
-      const meta = await silgiModule.getMeta?.();
-      buildTimeModuleMeta = {
-        ...meta,
-        exports: []
-      };
-    }
-    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
-      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
-    }
-    const options = await silgiModule.getOptions?.() || {};
-    if (options) {
-      silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(
-        silgi.options._c12.config[buildTimeModuleMeta.configKey] || {},
-        options || {}
-      );
-    } else {
-      throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-    }
-    silgi.scanModules.push({
-      meta: buildTimeModuleMeta,
-      entryPath: resolvedModulePath || void 0,
-      installed: false,
-      options,
-      module: silgiModule
-    });
-  }
-}
-async function scanModules$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;
-}
-
-async function commands(silgi) {
-  const commands2 = {
-    ...silgi.options.commands
-  };
-  await silgi.callHook("prepare:commands", commands2);
-  addTemplate({
-    filename: "cli.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(commands2, null, 2)
-  });
-  silgi.commands = commands2;
-  silgi.hook("prepare:schema.ts", async (object) => {
-    const allTags = Object.values(commands2).reduce((acc, commandGroup) => {
-      Object.values(commandGroup).forEach((command) => {
-        if (command.tags) {
-          command.tags.forEach((tag) => acc.add(tag));
-        }
-      });
-      return acc;
-    }, /* @__PURE__ */ new Set());
-    const data = [
-      "",
-      generateTypes(
-        await resolveSchema(
-          {
-            ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"]))
-          }
-        ),
-        {
-          interfaceName: "SilgiCommandsExtended",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 0
-        }
-      ),
-      ""
-    ];
-    object.customImports?.push(...data);
-  });
-}
-
-function resolveIgnorePatterns(silgi, relativePath) {
-  if (!silgi) {
-    return [];
-  }
-  const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
-  const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
-  if (existsSync(nuxtignoreFile)) {
-    const contents = readFileSync(nuxtignoreFile, "utf-8");
-    ignorePatterns.push(...contents.trim().split(/\r?\n/));
-  }
-  return ignorePatterns;
-}
-function isIgnored(pathname, silgi, _stats) {
-  if (!silgi) {
-    return false;
-  }
-  if (!silgi._ignore) {
-    silgi._ignore = ignore(silgi.options.ignoreOptions);
-    silgi._ignore.add(resolveIgnorePatterns(silgi));
-  }
-  const relativePath = relative(silgi.options.rootDir, pathname);
-  if (relativePath[0] === "." && relativePath[1] === ".") {
-    return false;
-  }
-  return !!(relativePath && silgi._ignore.ignores(relativePath));
-}
-function resolveGroupSyntax(group) {
-  let groups = [group];
-  while (groups.some((group2) => group2.includes("{"))) {
-    groups = groups.flatMap((group2) => {
-      const [head, ...tail] = group2.split("{");
-      if (tail.length) {
-        const [body = "", ...rest] = tail.join("{").split("}");
-        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
-      }
-      return group2;
-    });
-  }
-  return groups;
-}
-
-const safeFiles = [
-  "silgi/configs",
-  "silgi",
-  "silgi/rules",
-  "silgi/scan",
-  "silgi/vfs"
-];
-class SchemaParser {
-  options = {
-    debug: false
-  };
-  /**
-   *
-   */
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  parseExports(content, filePath) {
-    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
-    if (this.options.debug)
-      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
-    return {
-      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
-      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
-      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
-    };
-  }
-  parseVariableDeclaration(ast, path) {
-    const silgi = useSilgiCLI();
-    if (ast.program.body.length === 0) {
-      if (safeFiles.find((i) => path.includes(i)))
-        return [];
-      silgi.errors.push({
-        type: "Parser",
-        path
-      });
-      consola.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();
-    if (ast.program.body.length === 0) {
-      if (safeFiles.find((i) => path.includes(i)))
-        return [];
-      silgi.errors.push({
-        type: "Parser",
-        path
-      });
-      consola.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$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 = await readFile(filePath, "utf-8");
-      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
-      const createServices = exportVariables("createService", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      const scanTS = [];
-      const schemaTS = [];
-      if (createServices.length > 0) {
-        scanTS.push(...createServices.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "service" };
-        }));
-      }
-      const createSchemas = exportVariables("createSchema", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (createSchemas.length > 0) {
-        scanTS.push(...createSchemas.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "schema" };
-        }));
-      }
-      const createShareds = exportVariables("createShared", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (createShareds.length > 0) {
-        scanTS.push(...createShareds.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "shared" };
-        }));
-      }
-      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (sharedsTypes.length > 0) {
-        schemaTS.push(...sharedsTypes.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "shared" };
-        }));
-      }
-      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
-      }
-      if (contextTypes.length > 0) {
-        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "context" };
-        }));
-      }
-      silgi.hook("prepare:scan.ts", (options) => {
-        for (const { exportName, path, _name, type } of scanTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "service") {
-            options.services.push(_name);
-          }
-          if (type === "shared") {
-            options.shareds.push(_name);
-          }
-          if (type === "schema") {
-            options.schemas.push(_name);
-          }
-          options.importItems[path] ??= {
-            import: [],
-            from: relativeWithDot(silgi.options.silgi.serverDir, path)
-          };
-          options.importItems[path].import.push({
-            name: `${exportName} as ${_name}`,
-            key: _name
-          });
-        }
-      });
-      silgi.hook("prepare:schema.ts", (options) => {
-        for (const { exportName, path, _name, type } of schemaTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "shared") {
-            options.shareds.push({
-              key: _name,
-              value: _name
-            });
-          }
-          if (type === "context") {
-            options.contexts.push({
-              key: _name,
-              value: _name
-            });
-          }
-          options.importItems[path] ??= {
-            import: [],
-            from: relativeWithDot(silgi.options.build.typesDir, path)
-          };
-          options.importItems[path].import.push({
-            name: `${exportName} as ${_name}`,
-            key: _name
-          });
-        }
-      });
-    }
-  }
-}
-
-function buildUriMap(silgi, currentPath = []) {
-  const uriMap = /* @__PURE__ */ new Map();
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let pathString = "";
-      if (node.pathParams) {
-        let paths = null;
-        if (node.pathParams?._def?.typeName !== void 0) {
-          try {
-            const shape = node.pathParams?.shape;
-            paths = shape ? Object.keys(shape) : null;
-          } catch {
-            paths = null;
-          }
-        }
-        if (paths?.length) {
-          pathString = paths.map((p) => `:${p}`).join("/");
-        }
-      }
-      uriMap.set(basePath, pathString);
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(silgi.schemas, currentPath);
-  silgi.uris = defu(silgi.uris, Object.fromEntries(uriMap));
-  return uriMap;
-}
-
-async function readScanFile(silgi) {
-  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  silgi.unimport = createUnimport(silgi.options.imports || {});
-  await silgi.unimport.init();
-  const injectedResult = await silgi.unimport.injectImports(context, path);
-  if (!injectedResult) {
-    throw new Error("Failed to inject imports");
-  }
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: true,
-    moduleCache: false,
-    debug: silgi.options.debug,
-    alias: silgi.options.alias
-  });
-  try {
-    if (silgi.options.commandType === "prepare") {
-      globalThis._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$1.withTag("silgi").error(error);
-    }
-    return {
-      context,
-      object: {
-        schemas: {},
-        uris: {},
-        services: {},
-        shareds: {},
-        modulesURIs: {}
-      },
-      path
-    };
-  }
-}
-
-async function prepareServerFiles(silgi) {
-  const importItems = {
-    "silgi": {
-      import: [
-        { name: "createSilgi", key: "createSilgi" },
-        { name: "createShared", key: "createShared" }
-      ],
-      from: "silgi"
-    },
-    "silgi/types": {
-      import: [
-        { name: "SilgiRuntimeOptions", type: true, key: "SilgiRuntimeOptions" },
-        { name: "FrameworkContext", type: true, key: "FrameworkContext" }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "configs.ts": {
-      import: [
-        {
-          name: "cliConfigs",
-          type: false,
-          key: "cliConfigs"
-        }
-      ],
-      from: "./configs.ts"
-    }
-  };
-  const scanned = {
-    uris: {},
-    services: [],
-    shareds: [
-      `createShared({
-        modulesURIs,
-      })`
-    ],
-    schemas: [],
-    modulesURIs: {},
-    customImports: [],
-    importItems
-  };
-  if (silgi.uris) {
-    defu(scanned.uris, silgi.uris);
-  }
-  if (silgi.modulesURIs) {
-    defu(scanned.modulesURIs, silgi.modulesURIs);
-  }
-  await silgi.callHook("prepare:scan.ts", scanned);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
-  if (scanned.services.length > 0) {
-    importItems.silgi.import.push({ name: "mergeServices", key: "mergeServices" });
-  }
-  if (scanned.shareds.length > 0) {
-    importItems.silgi.import.push({ name: "mergeShared", key: "mergeShared" });
-  }
-  if (scanned.schemas.length > 0) {
-    importItems.silgi.import.push({ name: "mergeSchemas", key: "mergeSchemas" });
-  }
-  for (const key in importItems) {
-    importItems[key].import = deduplicateImportsByKey(importItems[key].import);
-  }
-  const importsContent = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
-    }),
-    "",
-    ...scanned.customImports,
-    ""
-  ];
-  const importData = [
-    `export const uris = ${JSON.stringify(scanned.uris, null, 2)}`,
-    "",
-    `export const modulesURIs = ${JSON.stringify(scanned.modulesURIs, null, 2)}`,
-    "",
-    scanned.schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
-    ...scanned.schemas.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.schemas.length > 0 ? "])" : "}",
-    "",
-    scanned.services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
-    ...scanned.services.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.services.length > 0 ? "])" : "}",
-    "",
-    scanned.shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
-    ...scanned.shareds.map((name) => {
-      return `  ${name},`;
-    }),
-    scanned.shareds.length > 0 ? "])" : "}",
-    ""
-  ];
-  await silgi.callHook("after:prepare:scan.ts", importData);
-  importData.unshift(...importsContent);
-  return importData;
-}
-function deduplicateImportsByKey(imports) {
-  const seenKeys = /* @__PURE__ */ new Map();
-  return imports.filter((item) => {
-    if (seenKeys.has(item.key)) {
-      return false;
-    }
-    seenKeys.set(item.key, true);
-    return true;
-  });
-}
-
-async function writeScanFiles(silgi) {
-  const data = await prepareServerFiles(silgi);
-  if (!silgi.errors.length) {
-    await writeFile(
-      resolve(silgi.options.silgi.serverDir, "scan.ts"),
-      data.join("\n")
-    );
-  }
-  await readScanFile(silgi);
-  buildUriMap(silgi);
-  parseServices(silgi);
-  silgi.hook("prepare:scan.ts", (file) => {
-    file.uris = {
-      ...file.uris,
-      ...silgi.uris
-    };
-    file.modulesURIs = {
-      ...file.modulesURIs,
-      ...silgi.modulesURIs
-    };
-  });
-}
-
-async function createStorageCLI(silgi) {
-  const storage = createStorage();
-  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;
-}
-
-async function installPackages(silgi) {
-  const packages = {
-    dependencies: {
-      "@fastify/deepmerge": peerDependencies["@fastify/deepmerge"],
-      "@silgi/ecosystem": peerDependencies["@silgi/ecosystem"],
-      ...silgi.options.installPackages?.dependencies
-    },
-    devDependencies: {
-      ...silgi.options.installPackages?.devDependencies
-    }
-  };
-  await silgi.callHook("prepare:installPackages", packages);
-  if (silgi.options.preset === "npm-package") {
-    packages.devDependencies = {
-      ...packages.devDependencies,
-      ...packages.dependencies
-    };
-    packages.dependencies = {};
-  }
-  addTemplate({
-    filename: "install.json",
-    where: ".silgi",
-    write: true,
-    getContents: () => JSON.stringify(packages, null, 2)
-  });
-}
-
-function useCLIRuntimeConfig(silgi) {
-  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
-  silgi.hook("prepare:configs.ts", (data) => {
-    data.runtimeConfig = safeRuntimeConfig;
-    silgi.options.envOptions = silgi.options.envOptions;
-  });
-  addTemplate({
-    filename: "env.example",
-    write: true,
-    where: ".silgi",
-    getContents() {
-      console.log("Generating env.example");
-      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: [],
-    commands: {},
-    _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) {
-    },
-    routeRules: void 0
-  };
-  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());
-  }
-  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 commands(silgi);
-  await installPackages(silgi);
-  await generateApp(silgi);
-  if (silgi.options.imports) {
-    silgi.options.imports.dirs ??= [];
-    silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
-      if (typeof dir === "string") {
-        if (dir.startsWith("!")) {
-          return `!${resolveSilgiPath(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;
-}
+import { useSilgiCLI } from 'silgi';
+import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { l as loadOptions } from './types.mjs';
 
 const commonArgs = {
   dir: {
@@ -1616,7 +54,7 @@ const command$1 = defineCommand({
       return data?.result?.silgi?.options?.runtimeConfig || {};
     };
     if (!data?.result?.silgi && args.active) {
-      consola$1.error("Silgi not found");
+      consola.error("Silgi not found");
       return;
     }
     const silgi = useSilgiCLI();
@@ -1647,11 +85,11 @@ const command$1 = defineCommand({
       }
     } else {
       if (!silgi) {
-        consola$1.error("Silgi not found");
+        consola.error("Silgi not found");
         return;
       }
       if (Object.keys(cliJson).length === 0) {
-        consola$1.warn("No commands found in cli.json");
+        consola.warn("No commands found in cli.json");
         return;
       }
       const allTags = Object.values(silgi.commands).reduce((acc, commandGroup) => {