silgi 0.3.13 → 0.4.1

package/dist/core/index.mjs

@@ -0,0 +1,1444 @@
+import { watchConfig, loadConfig } from 'c12';
+import { resolveCompatibilityDatesFromEnv, formatDate, resolveCompatibilityDates } from 'compatx';
+import { klona } from 'klona/full';
+import { isDebug, isTest, isDevelopment } from 'std-env';
+import consola, { createConsola } from 'consola';
+import { colors } from 'consola/utils';
+import { relative, join, resolve, isAbsolute, dirname } from 'pathe';
+import escapeRE from 'escape-string-regexp';
+import { resolveModuleExportNames, resolvePath as resolvePath$1 } from 'mlly';
+import { existsSync, lstatSync, promises, writeFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import { resolveSilgiPath, resolveAlias, resolvePath, relativeWithDot, resolveSilgiModule } from 'silgi/kit';
+import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
+import { isRelative, withLeadingSlash, withTrailingSlash } from 'ufo';
+import defu$1, { defu } from 'defu';
+import { isEvent } from 'h3';
+import { createHooks } from 'hookable';
+import { defineUntypedSchema, applyDefaults } from 'untyped';
+import { getContext } from 'unctx';
+import { Buffer } from 'node:buffer';
+import { klona as klona$1 } from 'klona';
+import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
+import memoryDriver from 'unstorage/drivers/memory';
+import { parseSync } from '@oxc-parser/wasm';
+
+const SilgiCLIDefaults = {
+  // General
+  debug: isDebug,
+  // timing: isDebug,
+  logLevel: isTest ? 1 : 3,
+  // runtimeConfig: { app: {}, silgi: {} },
+  appConfig: {},
+  appConfigFiles: [],
+  // Dirs
+  scanDirs: [],
+  build: {
+    dir: ".silgi",
+    typesDir: "{{ build.dir }}/types"
+  },
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  serverDir: "{{ rootDir }}/server",
+  clientDir: "{{ rootDir }}/client",
+  silgi: {
+    serverDir: "{{ serverDir }}/silgi",
+    clientDir: "{{ clientDir }}/silgi",
+    publicDir: "{{ silgi.serverDir }}/public",
+    utilsDir: "{{ silgi.serverDir }}/utils",
+    composablesDir: "{{ silgi.serverDir }}/composables",
+    typesDir: "{{ silgi.serverDir }}/types",
+    servicesDir: "{{ silgi.serverDir }}/services"
+  },
+  // Modules
+  _modules: [],
+  modules: [],
+  // Features
+  // experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  // bundledStorage: [],
+  // publicAssets: [],
+  // serverAssets: [],
+  plugins: [],
+  // tasks: {},
+  // scheduledTasks: {},
+  imports: {
+    exclude: [],
+    dirs: [],
+    presets: [],
+    virtualImports: ["#imports"]
+  },
+  // virtual: {},
+  // compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  // devServer: { watch: [] },
+  watchOptions: { ignoreInitial: true },
+  // devProxy: {},
+  // Logging
+  // logging: {
+  //   compressedSizes: true,
+  //   buildSuccess: true,
+  // },
+  // Routing
+  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
+  // handlers: [],
+  // devHandlers: [],
+  // errorHandler: undefined,
+  // routeRules: {},
+  // Advanced
+  typescript: {
+    strict: false,
+    generateTsConfig: true,
+    // generateRuntimeConfigTypes: true,
+    tsconfigPath: "types/silgi.tsconfig.json",
+    internalPaths: false,
+    tsConfig: {},
+    customConditions: []
+  },
+  conditions: [],
+  nodeModulesDirs: [],
+  // hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "h3",
+    version: ""
+  },
+  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"]
+};
+
+const fallbackCompatibilityDate = "2025-02-04";
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+  if (!options.compatibilityDate.default) {
+    options.compatibilityDate.default = await _resolveDefault(options);
+  }
+}
+let _fallbackInfoShown = false;
+let _promptedUserToUpdate = false;
+async function _resolveDefault(options) {
+  const _todayDate = formatDate(/* @__PURE__ */ new Date());
+  const consola$1 = consola.withTag("silgi");
+  consola$1.warn(`No valid compatibility date is specified.`);
+  const onFallback = () => {
+    if (!_fallbackInfoShown) {
+      consola$1.info(
+        [
+          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
+          `  Please specify compatibility date to avoid unwanted behavior changes:`,
+          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
+          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
+          ``
+        ].join("\n")
+      );
+      _fallbackInfoShown = true;
+    }
+    return fallbackCompatibilityDate;
+  };
+  const shallUpdate = !_promptedUserToUpdate && await consola$1.prompt(
+    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
+    {
+      type: "confirm",
+      default: true
+    }
+  );
+  _promptedUserToUpdate = true;
+  if (!shallUpdate) {
+    return onFallback();
+  }
+  const { updateConfig } = await import('c12/update');
+  const updateResult = await updateConfig({
+    configFile: "silgi.config",
+    cwd: options.rootDir,
+    async onCreate({ configFile }) {
+      const shallCreate = await consola$1.prompt(
+        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
+        {
+          type: "confirm",
+          default: true
+        }
+      );
+      if (shallCreate !== true) {
+        return false;
+      }
+      return _getDefaultNitroConfig();
+    },
+    async onUpdate(config) {
+      config.compatibilityDate = _todayDate;
+    }
+  }).catch((error) => {
+    consola$1.error(`Failed to update config: ${error.message}`);
+    return null;
+  });
+  if (updateResult?.configFile) {
+    consola$1.success(
+      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
+    );
+    return _todayDate;
+  }
+  return onFallback();
+}
+function _getDefaultNitroConfig() {
+  return (
+    /* js */
+    `
+import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({})
+  `
+  );
+}
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getSilgiImportsPreset());
+  const h3Exports = await resolveModuleExportNames("h3", {
+    url: import.meta.url
+  });
+  options.imports.presets ??= [];
+  options.imports.presets.push({
+    from: "h3",
+    imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+  });
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.build.dir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getSilgiImportsPreset() {
+  return [
+    // TODO: buraya bizim importlarimiz gelecek.
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['useNitroApp'],
+    // },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['useRuntimeConfig', 'useAppConfig'],
+    // },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/cache',
+    //   imports: [
+    //     'defineCachedFunction',
+    //     'defineCachedEventHandler',
+    //     'cachedFunction',
+    //     'cachedEventHandler',
+    //   ],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/storage',
+    //   imports: ['useStorage'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/renderer',
+    //   imports: ['defineRenderHandler'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/meta',
+    //   imports: ['defineRouteMeta'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/route-rules',
+    //   imports: ['getRouteRules'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/context',
+    //   imports: ['useEvent'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/task',
+    //   imports: ['defineTask', 'runTask'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/error/utils',
+    //   imports: ['defineNitroErrorHandler'],
+    // },
+  ];
+}
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
+    () => options.rootDir
+  );
+  options.srcDir = resolve(options.srcDir || options.rootDir);
+  for (const key of ["srcDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  options.build.dir = resolve(options.rootDir, options.build.dir);
+  options.build.typesDir = resolveSilgiPath(
+    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
+    options,
+    options.rootDir
+  );
+  if (options.preset === "npm-package") {
+    const packageJsonPath = resolve(options.rootDir, "package.json");
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (packageJson.name === undefined) {
+      throw new Error("Package name is undefined");
+    }
+    options.alias ||= {};
+    options.alias[packageJson.name] = join(options.rootDir, "src/module.ts");
+    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime/");
+    options.alias = {
+      ...options.alias,
+      "silgi/runtime": join(runtimeDir),
+      "#internal/silgi": join(runtimeDir),
+      "silgi/runtime/*": join(runtimeDir, "*"),
+      "#internal/silgi/*": join(runtimeDir, "*")
+    };
+  }
+  if (options.typescript?.internalPaths) {
+    options.alias = {
+      ...options.alias,
+      "silgi/runtime": join(runtimeDir),
+      "#internal/silgi": join(runtimeDir),
+      "silgi/runtime/*": join(runtimeDir, "*"),
+      "#internal/silgi/*": join(runtimeDir, "*")
+    };
+    options.typescript.customConditions = [
+      ...options.typescript.customConditions,
+      "silgiTypes"
+    ];
+    options.conditions ||= [];
+    options.conditions.push("silgi");
+  }
+  options.alias = {
+    ...options.alias,
+    "~/": join(options.srcDir, "/"),
+    "@/": join(options.srcDir, "/"),
+    "~~/": join(options.rootDir, "/"),
+    "@@/": join(options.rootDir, "/")
+  };
+  if (options.alias && typeof options.alias === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  options.modulesDir = [resolve(options.rootDir, "node_modules")];
+  options.output.dir = resolveSilgiPath(
+    options.output.dir || SilgiCLIDefaults.output.dir,
+    options,
+    options.rootDir
+  );
+  options.output.publicDir = resolveSilgiPath(
+    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
+    options,
+    options.rootDir
+  );
+  options.output.serverDir = resolveSilgiPath(
+    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
+    options,
+    options.rootDir
+  );
+  options.serverDir = resolveSilgiPath(
+    options.serverDir || SilgiCLIDefaults.serverDir,
+    options,
+    options.rootDir
+  );
+  options.clientDir = resolveSilgiPath(
+    options.clientDir || SilgiCLIDefaults.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.serverDir = resolveSilgiPath(
+    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.clientDir = resolveSilgiPath(
+    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.publicDir = resolveSilgiPath(
+    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.utilsDir = resolveSilgiPath(
+    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.composablesDir = resolveSilgiPath(
+    options.silgi.composablesDir || SilgiCLIDefaults.silgi.composablesDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.typesDir = resolveSilgiPath(
+    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.servicesDir = resolveSilgiPath(
+    options.silgi.servicesDir || SilgiCLIDefaults.silgi.servicesDir,
+    options,
+    options.rootDir
+  );
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
+    )
+  ];
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs)];
+  options.appConfigFiles ??= [];
+  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
+  for (const dir of options.scanDirs) {
+    const configFile = _tryResolve("app.config", dir);
+    if (configFile && !options.appConfigFiles.includes(configFile)) {
+      options.appConfigFiles.push(configFile);
+    }
+  }
+  const modulesRuntimePaths = {};
+  if (options.typescript?.internalPaths) {
+    for (let i of options.modules) {
+      if (typeof i === "string") {
+        i = resolveAlias(i, options.alias);
+        if (isRelative(i)) {
+          i = resolve(options.rootDir, i);
+        }
+        const src = isAbsolute(i) ? pathToFileURL(await resolvePath(i, { fallbackToOriginal: false, extensions: options.extensions })).href : await resolvePath$1(i, { url: options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: options.extensions });
+        const cleanPath = src.replace(/(\/(?:src|dist)(?:\/runtime)?(?:\/.*)?$)/, "");
+        modulesRuntimePaths[`${i}/runtime`] = `${cleanPath}/src/runtime`;
+      }
+    }
+    for (const [key, value] of Object.entries(modulesRuntimePaths)) {
+      options.alias = {
+        ...options.alias,
+        [`${key}`]: value
+      };
+    }
+  }
+}
+function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
+  path = resolve(base, path);
+  if (existsSync(path)) {
+    return path;
+  }
+  for (const ext of extensions) {
+    const p = path + ext;
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+}
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.build.dir),
+    cache: resolve(options.build.dir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === undefined && options.devStorage.data === undefined) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  }
+}
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  // resolveRouteRulesOptions,
+  // resolveDatabaseOptions,
+  // resolveFetchOptions,
+  // resolveExportConditionsOptions,
+  // resolveRuntimeConfigOptions,
+  // resolveOpenAPIOptions,
+  resolveURLOptions,
+  // resolveAssetsOptions,
+  resolveStorageOptions
+  // resolveErrorOptions,
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  let presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
+  if (configOverrides.dev) {
+    presetOverride = "silgi-dev";
+  }
+  configOverrides = klona(configOverrides);
+  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('silgi/presets');
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "silgi",
+    cwd: configOverrides.rootDir,
+    dotenv: configOverrides.dev,
+    extend: { extendKey: ["extends", "preset"] },
+    overrides: {
+      ...configOverrides,
+      preset: presetOverride
+    },
+    async defaultConfig({ configs }) {
+      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      return {
+        // typescript: {
+        //   generateRuntimeConfigTypes:
+        //     !framework?.name || framework.name === 'nitro',
+        // },
+        preset: presetOverride || (await resolvePreset("", {
+          static: getConf("static"),
+          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+        }))?._meta?.name
+      };
+    },
+    defaults: SilgiCLIDefaults,
+    jitiOptions: {
+      alias: {
+        "silgi": "silgi/config",
+        "silgi/config": "silgi/config"
+      }
+    },
+    async resolve(id) {
+      const preset = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+      });
+      if (preset) {
+        return {
+          config: klona(preset)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  delete globalThis.defineSilgiConfig;
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  return options;
+}
+
+function getDirectory(p) {
+  try {
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+  } catch {
+  }
+  return p;
+}
+
+function renderAttrs(obj) {
+  const attrs = [];
+  for (const key in obj) {
+    attrs.push(renderAttr(key, obj[key]));
+  }
+  return attrs.join(" ");
+}
+function renderAttr(key, value) {
+  return value ? `${key}="${value}"` : "";
+}
+async function silgiGenerateType(silgi) {
+  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
+  const tsConfigPath = resolve(
+    silgi.options.build.dir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const tsconfigDir = dirname(tsConfigPath);
+  const include = /* @__PURE__ */ new Set([
+    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
+      /^(?=[^.])/,
+      "./"
+    ),
+    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
+    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
+  ]);
+  const exclude = /* @__PURE__ */ new Set([
+    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
+    relativeWithDot(silgi.options.build.dir, resolve(silgi.options.rootDir, "dist"))
+  ]);
+  for (const dir of silgi.options.modulesDir) {
+    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
+  }
+  const moduleEntryPaths = [];
+  for (const m of silgi.scanModules) {
+    if (m.entryPath) {
+      moduleEntryPaths.push(getDirectory(m.entryPath));
+    }
+  }
+  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
+  for (const path of modulePaths) {
+    const relative2 = relativeWithDot(silgi.options.build.dir, path);
+    include.add(join(relative2, "runtime"));
+    exclude.add(join(relative2, "runtime/server"));
+    include.add(join(relative2, "dist/runtime"));
+    exclude.add(join(relative2, "dist/runtime/server"));
+  }
+  const tsConfig = defu(silgi.options.typescript?.tsConfig, {
+    compilerOptions: {
+      forceConsistentCasingInFileNames: true,
+      strict: silgi.options.typescript.strict,
+      noEmit: true,
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      allowJs: true,
+      resolveJsonModule: true,
+      jsx: "preserve",
+      allowSyntheticDefaultImports: true,
+      jsxFactory: "h",
+      jsxFragmentFactory: "Fragment",
+      allowImportingTsExtensions: true,
+      customConditions: ["silgiTypes"],
+      paths: {
+        "#imports": [
+          relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-imports"))
+        ]
+        // ...(silgi.options.typescript?.internalPaths
+        //   ? {
+        //       'silgi/runtime': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       '#internal/silgi': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       'silgi/runtime/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //       '#internal/silgi/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //     }
+        //   : {}),
+      }
+    },
+    include: [...include],
+    exclude: [...exclude]
+  });
+  tsConfig.compilerOptions ||= {};
+  tsConfig.compilerOptions.paths ||= {};
+  tsConfig.include ||= [];
+  for (const alias in tsConfig.compilerOptions.paths) {
+    const paths = tsConfig.compilerOptions.paths[alias];
+    tsConfig.compilerOptions.paths[alias] = await Promise.all(
+      paths.map(async (path) => {
+        if (!isAbsolute(path)) {
+          return path;
+        }
+        const stats = await promises.stat(path).catch(
+          () => null
+          /* file does not exist */
+        );
+        return relativeWithDot(
+          tsconfigDir,
+          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
+        );
+      })
+    );
+  }
+  const references = [];
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    references.push({ types: pkg?.name || id });
+  }));
+  const declarations = [];
+  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
+  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  const _declarations = [
+    ...references.map((ref) => {
+      if ("path" in ref && isAbsolute(ref.path)) {
+        ref.path = relative(silgi.options.build.dir, ref.path);
+      }
+      return `/// <reference ${renderAttrs(ref)} />`;
+    }),
+    ...declarations,
+    "",
+    "export {}",
+    ""
+  ];
+  return {
+    declarations: _declarations,
+    tsConfig
+  };
+}
+
+const common = defineUntypedSchema({
+  /**
+   * Environment to use.
+   *
+   * @default 'h3'
+   */
+  environment: {
+    $resolve: (val) => val ?? "h3"
+  },
+  /**
+   * Whether Nuxt is running in development mode.
+   *
+   * Normally, you should not need to set this.
+   */
+  dev: {
+    $resolve: (val) => val ?? Boolean(isDevelopment)
+  },
+  /**
+   * Whether your app is being unit tested.
+   */
+  test: {
+    $resolve: (val) => val ?? Boolean(isTest)
+  },
+  /**
+   * Set to `true` to enable debug mode.
+   *
+   * At the moment, it prints out hook names and timings on the server, and
+   * logs hook arguments as well in the browser.
+   *
+   */
+  debug: {
+    $resolve: (val) => val ?? isDebug
+  },
+  plugins: {
+    $resolve: (val) => (val || []).filter(Boolean)
+  },
+  $schema: {}
+});
+
+const internal = defineUntypedSchema({
+  /** @private */
+  _majorVersion: 4,
+  /** @private */
+  _generate: false,
+  /** @private */
+  _prepare: false,
+  /** @private */
+  _requiredPlugins: {},
+  /**
+   * @private
+   * @type {Array<{ meta: ModuleMeta; timings?: Record<string, number | undefined>; entryPath?: string }>}
+   */
+  _installedPlugins: [],
+  /** @private */
+  _plugins: [],
+  extensions: [".js", ".mjs", ".ts"]
+});
+
+const SilgiConfigSchema = {
+  ...common,
+  ...internal
+};
+
+const silgiCtx = getContext("silgi");
+function useSilgi() {
+  const instance = silgiCtx.tryUse();
+  if (!instance) {
+    throw new Error("Silgi instance is unavailable!");
+  }
+  return instance;
+}
+function normalizeResult(result) {
+  if (Array.isArray(result)) {
+    return [...result];
+  }
+  if (result && typeof result === "object") {
+    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
+      return Object.values(result);
+    }
+    return { ...result };
+  }
+  return result;
+}
+
+var SilgiErrorCode = /* @__PURE__ */ ((SilgiErrorCode2) => {
+  SilgiErrorCode2["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
+  SilgiErrorCode2["AUTH_MISSING_CONTEXT"] = "AUTH_MISSING_CONTEXT";
+  SilgiErrorCode2["AUTH_INVALID_CONTEXT"] = "AUTH_INVALID_CONTEXT";
+  SilgiErrorCode2["AUTH_PERMISSION_DENIED"] = "AUTH_PERMISSION_DENIED";
+  SilgiErrorCode2["PLUGIN_ERROR"] = "PLUGIN_ERROR";
+  SilgiErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
+  SilgiErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
+  SilgiErrorCode2["CACHE_ERROR"] = "CACHE_ERROR";
+  SilgiErrorCode2["PLUGIN_ALREADY_EXISTS"] = "PLUGIN_ALREADY_EXISTS";
+  SilgiErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
+  SilgiErrorCode2["PLUGIN_INIT_ERROR"] = "PLUGIN_INIT_ERROR";
+  return SilgiErrorCode2;
+})(SilgiErrorCode || {});
+class SilgiError extends Error {
+  code;
+  details;
+  meta;
+  timestamp;
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "SilgiError";
+    this.code = options.code;
+    this.details = options.details;
+    this.meta = options.meta;
+    this.cause = options.cause;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  // Improve error formatting
+  toString() {
+    let str = `${this.name} [${this.code}]: ${this.message}`;
+    if (this.details) {
+      str += `
+Details: ${JSON.stringify(this.details, null, 2)}`;
+    }
+    if (this.meta) {
+      str += `
+Meta: ${JSON.stringify(this.meta, null, 2)}`;
+    }
+    if (this.stack) {
+      str += `
+${this.stack}`;
+    }
+    return str;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      meta: this.meta,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+  static createFrom(error, code = "UNKNOWN_ERROR") {
+    if (error instanceof SilgiError) {
+      return error;
+    }
+    return new SilgiError({
+      code,
+      message: error instanceof Error ? error.message : String(error),
+      cause: error instanceof Error ? error : undefined
+    });
+  }
+  static isSilgiError(error) {
+    return error instanceof SilgiError;
+  }
+}
+
+function uriParseError(message, code) {
+  throw new SilgiError({
+    code: `URI_PARSE_ERROR_${code}`,
+    message
+  });
+}
+function parseURI(uri, uris) {
+  if (!uri)
+    throw uriParseError("URI cannot be empty", "EMPTY_URI");
+  else if (!uris)
+    throw uriParseError("URIs is not nullable", "NULL_URIS");
+  const cleanUri = uri.replace(/^\/*(srn\/)?/, "").replace(/\/*$/, "");
+  const [path, queryString] = cleanUri.split("?");
+  const parts = path.split("/");
+  const query = queryString ? Object.fromEntries(
+    queryString.split("&").map((param) => param.split("="))
+  ) : undefined;
+  const method = query?.method ? query?.method.toLowerCase() : undefined;
+  if (method && parts.length < 3 || !method && parts.length < 4)
+    throw uriParseError("Invalid URI format lengt", "INVALID_FORMAT");
+  const namespaceName = parts[0];
+  const serviceName = parts[1];
+  const methodName = method || parts[2];
+  const actionName = method ? parts[2] : parts[3];
+  if (!namespaceName || !serviceName || !methodName || !actionName)
+    throw uriParseError("Invalid URI format", "INVALID_FORMAT");
+  const hasParameters = parts.length > 4;
+  const baseUri = `${namespaceName}/${serviceName}/${methodName}/${actionName}`;
+  const template = uris[baseUri];
+  if (template === "") {
+    if (hasParameters)
+      throw uriParseError("No parameters expected for this route", "UNEXPECTED_PARAMS");
+  } else if (!template) {
+    throw uriParseError("No route found for URI", "ROUTE_NOT_FOUND");
+  }
+  const routeTemplate = typeof template === "string" ? template : template.pattern;
+  const validators = typeof template === "string" ? undefined : template.validators;
+  const routerParams = {};
+  if (routeTemplate === "") {
+    if (parts.length > 4)
+      throw uriParseError("No parameters expected for this route", "UNEXPECTED_PARAMS");
+  } else {
+    const templateParts = routeTemplate.split("/").filter(Boolean);
+    const paramValues = parts.slice(4);
+    let valueIndex = 0;
+    templateParts.forEach((part) => {
+      if (part.startsWith(":")) {
+        const paramName = part.substring(1);
+        const paramValue = paramValues[valueIndex];
+        if (validators?.[paramName] && paramValue) {
+          if (!validators[paramName](paramValue)) {
+            throw uriParseError(`Invalid value for parameter ${paramName}`, "INVALID_PARAM_VALUE");
+          }
+        }
+        routerParams[paramName] = paramValue || undefined;
+        valueIndex++;
+      } else if (part && part === paramValues[valueIndex]) {
+        valueIndex++;
+      }
+    });
+  }
+  return {
+    namespaceName,
+    serviceName,
+    methodName,
+    actionName,
+    raw: cleanUri,
+    parts: [namespaceName, serviceName, methodName, actionName],
+    routerParams,
+    query,
+    uri: baseUri
+  };
+}
+
+async function findAction(silgi, uri) {
+  const { parts } = parseURI(uri, silgi.uris);
+  let result = silgi.services;
+  for (const part of parts) {
+    if (result && Object.prototype.hasOwnProperty.call(result, part)) {
+      result = Object.assign({}, result[part]);
+    } else {
+      console.error("Property not found:", part);
+      break;
+    }
+  }
+  return result;
+}
+async function scanAction(silgi) {
+  for (const [key, _value] of Object.entries(silgi.uris)) {
+    const segments = key.split("/").filter(Boolean);
+    if (segments.length !== 4) {
+      console.error(`Invalid URI format for key "${key}". URI must have exactly 4 segments in format: namespace/service/method/action`);
+      continue;
+    }
+    const [namespace, service, method, action] = segments;
+    if (!namespace || !service || !method || !action) {
+      console.error(`Invalid URI segments for key "${key}". All segments must be non-empty`);
+      continue;
+    }
+    const handler = await findAction(silgi, key);
+    silgi.scannedHandlers.set(key, handler);
+  }
+}
+
+async function createStorage(silgi) {
+  const storage = createStorage$1();
+  const mounts = klona$1({
+    ...silgi.options.storage,
+    ...silgi.options.devStorage
+  });
+  for (const [path, opts] of Object.entries(mounts)) {
+    if (opts.driver) {
+      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+      storage.mount("/memory:cache", memoryDriver());
+      storage.mount(path, driver(opts));
+    } else {
+      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+    }
+  }
+  return storage;
+}
+function useStorage(base = "/memory:cache") {
+  const silgi = useSilgi();
+  return base ? prefixStorage(silgi.storage, base) : silgi.storage;
+}
+async function generateStorageKey(params) {
+  const {
+    operation,
+    input,
+    keyGenerator,
+    requestId,
+    storageOptions
+  } = params;
+  const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
+  const parts = [
+    cacheScopePrefix,
+    // Always include scope prefix first
+    operation.namespaceName,
+    operation.serviceName,
+    operation.methodName
+  ].filter(Boolean);
+  if (storageOptions?.scope === "request") {
+    if (!requestId) {
+      throw new SilgiError({
+        code: "CACHE_ERROR",
+        message: "Request ID is required for request-scoped cache"
+      });
+    }
+    parts.push(requestId);
+  }
+  if (keyGenerator) {
+    const customKey = await Promise.resolve(keyGenerator(input));
+    parts.push(customKey);
+  } else {
+    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
+  }
+  return Buffer.from(parts.join(":")).toString("base64");
+}
+
+async function runSilgiPlugins(silgi) {
+  for (const plugin of silgi.plugins) {
+    try {
+      await plugin(silgi);
+    } catch (error) {
+      silgi.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+}
+async function createSilgi(config) {
+  const hooks = createHooks();
+  await applyDefaults(SilgiConfigSchema, config.options);
+  const silgi = {
+    schemas: config.schemas,
+    services: config.services,
+    shared: config.shared,
+    uris: config.uris,
+    modulesURIs: config.modulesURIs,
+    scannedHandlers: /* @__PURE__ */ new Map(),
+    plugins: config.plugins ?? [],
+    framework: config.framework,
+    storage: undefined,
+    options: config.options,
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => {
+      return hooks.callHook("ready", silgi);
+    },
+    close: () => hooks.callHook("close", silgi),
+    logger: createConsola(defu$1(config.options.consolaOptions, {
+      tag: "silgi"
+    })).withTag("silgi"),
+    captureError: (error, context = {}) => {
+      const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
+        console.error("Error while capturing another error", error_);
+      });
+      if (context.event && isEvent(context.event)) {
+        const errors = context.event.context.nitro?.errors;
+        if (errors) {
+          errors.push({ error, context });
+        }
+        if (context.event.waitUntil) {
+          context.event.waitUntil(promise);
+        }
+      }
+    }
+  };
+  await runSilgiPlugins(silgi);
+  await scanAction(silgi);
+  silgi.storage = await createStorage(silgi);
+  silgi.shared.storage = (...data) => {
+    return useStorage(...data);
+  };
+  if (silgiCtx.tryUse()) {
+    silgiCtx.unset();
+    silgiCtx.set(silgi);
+  } else {
+    silgiCtx.set(silgi);
+    silgi.hook("close", () => silgiCtx.unset());
+  }
+  silgi.logger.info("Silgi installed");
+  hooks.hookOnce("close", async () => {
+    hooks.removeAllHooks();
+    await silgi.storage.dispose();
+  });
+  return silgi;
+}
+
+function createSilgiFetch(options, localFetch) {
+  return (url, opts = {}) => {
+    opts = typeof options === "function" ? options(opts) : { ...options, ...opts };
+    if (!opts.method)
+      opts.method = "get";
+    const $fetch = getFetch(url, opts, localFetch);
+    return $fetch(fillPath(url, opts?.path), opts);
+  };
+}
+function getFetch(url, opts, localFetch) {
+  if (import.meta.server && localFetch) {
+    const isLocalFetch = url[0] === "/" && (!opts.baseURL || opts.baseURL[0] === "/");
+    if (isLocalFetch)
+      return localFetch;
+  }
+  return globalThis.$fetch;
+}
+function fillPath(path, params = {}) {
+  for (const [k, v] of Object.entries(params))
+    path = path.replace(`{${k}}`, encodeURIComponent(String(v)));
+  return path;
+}
+
+class SchemaParser {
+  options = {
+    debug: false
+  };
+  /**
+   *
+   */
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    if (this.options.debug)
+      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
+    return {
+      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
+      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
+      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
+    };
+  }
+  parseVariableDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
+  }
+  parseTSInterfaceDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
+  }
+  parseTypeDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseVariableDeclaration(ast)) {
+      for (const declaration of item.declaration.declarations) {
+        if (declaration.init.callee?.name === find) {
+          const options = {};
+          if (declaration.init.arguments) {
+            for (const argument of declaration.init.arguments) {
+              for (const propertie of argument.properties) {
+                if (propertie.key.name === "name")
+                  options.pluginName = propertie.value.value;
+              }
+            }
+          }
+          for (const key in declaration.init.properties) {
+            const property = declaration.init.properties[key];
+            if (property.type === "ObjectProperty") {
+              if (property.key.name === "options") {
+                for (const key2 in property.value.properties) {
+                  const option = property.value.properties[key2];
+                  if (option.type === "ObjectProperty") {
+                    options[option.key.name] = option.value.value;
+                  }
+                }
+              }
+            }
+          }
+          options.type = false;
+          data.push({
+            exportName: declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  parseInterfaceDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseTSInterfaceDeclaration(ast)) {
+      if (!item?.declaration?.extends)
+        continue;
+      for (const declaration of item?.declaration?.extends) {
+        if (declaration.expression.name === find) {
+          const options = {};
+          options.type = true;
+          data.push({
+            exportName: item.declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  // private parsePlugin(ast: any, path: string = '') {
+  //   const data = {
+  //     export: [],
+  //     name: '',
+  //     path: '',
+  //   } as DataTypePlugin
+  //   for (const item of this.parseVariableDeclaration(ast)) {
+  //     for (const declaration of item.declaration.declarations) {
+  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
+  //         if (declaration.init.arguments) {
+  //           for (const argument of declaration.init.arguments) {
+  //             for (const propertie of argument.properties) {
+  //               if (propertie.key.name === 'name')
+  //                 data.name = propertie.value.value
+  //             }
+  //           }
+  //         }
+  //         data.export.push({
+  //           name: data.name,
+  //           as: camelCase(`${data.name}DefineSilgiModule`),
+  //           type: false,
+  //         })
+  //       }
+  //     }
+  //   }
+  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
+  //     if (!item?.declaration?.extends)
+  //       continue
+  //     for (const declaration of item?.declaration?.extends) {
+  //       if (declaration.expression.name === 'SilgiModuleOptions') {
+  //         data.export.push({
+  //           name: item.declaration.id.name,
+  //           as: camelCase(`${data.name}SilgiModuleOptions`),
+  //           type: true,
+  //         })
+  //       }
+  //       // TODO add other plugins
+  //     }
+  //   }
+  //   data.path = path
+  //   return data
+  // }
+}
+
+function silgi(event) {
+  return {
+    execute: (uriString, input) => {
+      return execute(uriString, input, event);
+    }
+  };
+}
+async function execute(uriString, input, event) {
+  const silgiCtx = useSilgi();
+  if (event) {
+    silgiCtx.callHook("event:before", event);
+  }
+  let success = false;
+  let cached = false;
+  let error;
+  let result;
+  const operation = parseURI(uriString, silgiCtx.uris);
+  if (!operation) {
+    throw new SilgiError({
+      code: "INVALID_URI",
+      message: `Invalid URI: ${uriString}`
+    });
+  }
+  const hookContext = {
+    operation,
+    input,
+    event
+  };
+  try {
+    await silgiCtx.callHook("method:before", {
+      operation,
+      input,
+      event
+    });
+    const handler = silgiCtx.scannedHandlers.get(operation.uri);
+    if (!handler) {
+      return {
+        success: false,
+        error: {
+          code: "METHOD_NOT_FOUND",
+          message: `Method ${String(operation.methodName)} not found`
+        }
+      };
+    }
+    if (event)
+      await silgiCtx.callHook("event:before", event);
+    const cacheData = await cacheExecute(operation.uri, input, operation, handler, event);
+    await callModules(operation, handler, input, result, event);
+    if (cacheData?.success) {
+      result = cacheData.data;
+      success = cacheData.success;
+      cached = cacheData.cached;
+    } else {
+      const router = {
+        params: operation.routerParams,
+        query: operation.query
+      };
+      silgiCtx.shared.silgi = (_event) => silgi(_event || event);
+      result = await handler?.handler(router, input, silgiCtx.shared, event);
+      success = true;
+    }
+    await silgiCtx.callHook("method:after", {
+      operation,
+      input,
+      event,
+      result,
+      success
+    });
+    if (!cached) {
+      if (success && cacheData?.cachedKey && handler.storage) {
+        await useStorage(handler.storage.base).setItem(cacheData.cachedKey, result, handler.storage.options);
+      }
+    }
+    return { success: true, data: normalizeResult(result), cached };
+  } catch (err) {
+    error = err instanceof Error ? err : new Error("Unknown error");
+    if (error instanceof SilgiError) {
+      return {
+        success: false,
+        error: {
+          code: error.code,
+          message: error.message,
+          details: error.details
+        }
+      };
+    }
+    await silgiCtx.callHook("method:error", {
+      ...hookContext,
+      error,
+      timestamp: Date.now()
+    });
+    return {
+      success: false,
+      error: {
+        code: SilgiErrorCode.EXECUTION_ERROR,
+        message: error.message || String(error)
+      }
+    };
+  }
+}
+async function callModules(operation, handler, input, result, event) {
+  useSilgi();
+  if (!handler.modules)
+    return;
+  for (const [moduleKey, config] of Object.entries(handler.modules)) {
+    if (moduleKey) {
+      if (module) ;
+    }
+  }
+}
+async function cacheExecute(uriString, input, operation, handler, event) {
+  if (!handler.storage)
+    return;
+  const cacheKey = handler.storage ? await generateStorageKey({
+    operation,
+    input,
+    keyGenerator: handler.storage.key,
+    storageOptions: handler.storage,
+    requestId: event?.requestId
+  }) : null;
+  if (cacheKey) {
+    const cachedResult = await useStorage(handler.storage.base).getItem(cacheKey);
+    if (cachedResult !== null) {
+      return {
+        success: true,
+        data: normalizeResult(cachedResult),
+        cached: true,
+        cachedKey: cacheKey
+      };
+    }
+  }
+  return {
+    success: false,
+    data: null,
+    cached: false,
+    cachedKey: cacheKey
+  };
+}
+
+function merge(items) {
+  return Object.assign({}, ...Array.isArray(items) ? items : [items]);
+}
+function mergeSchemas(typesOrArray) {
+  return merge(typesOrArray);
+}
+function mergeServices(servicesOrArray) {
+  return merge(servicesOrArray);
+}
+function mergeShared(sharedOrArray) {
+  return merge(sharedOrArray);
+}
+
+function createSchema(silgiType) {
+  return silgiType;
+}
+
+function createService(variables) {
+  return variables;
+}
+
+function createShared(shared) {
+  return shared;
+}
+
+export { SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, loadOptions, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiGenerateType, useSilgi };