silgi 0.30.6 → 0.32.0

package/dist/build.mjs

@@ -27,7 +27,6 @@ import 'exsolve';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import '@oxc-parser/wasm';
 import 'knitwork';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/build.mjs

@@ -1,13 +1,13 @@
-import consola, { consola as consola$1 } from 'consola';
+import { consola } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
-import { resolve, join, relative, dirname, basename, extname, isAbsolute } from 'pathe';
+import { resolve, join, relative, extname, basename, dirname, isAbsolute } from 'pathe';
 import { useSilgiCLI, replaceRuntimeValues, silgiCLICtx, autoImportTypes } from 'silgi';
-import { isPresents, addTemplate, addCoreFile, relativeWithDot, hash, resolveAlias, directoryToURL, hasError, removeExtension, addImports, baseHeaderBannerComment, writeFile, parseServices, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, genEnsureSafeVar, toArray, isDirectory } from 'silgi/kit';
+import { isPresents, addTemplate, addCoreFile, relativeWithDot, hash, resolveAlias, directoryToURL, removeExtension, addImports, baseHeaderBannerComment, writeFile, parseServices, normalizeTemplate, useLogger, resolveSilgiPath, hasSilgiModule, genEnsureSafeVar, toArray, isDirectory } from 'silgi/kit';
 import { runtimeDir } from 'silgi/runtime/meta';
 import { scanExports, createUnimport, toExports } from 'unimport';
 import { c as createRouteRules } from '../_chunks/routeRules.mjs';
 import * as p from '@clack/prompts';
-import { existsSync, promises, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import * as dotenv from 'dotenv';
 import { findTypeExports, findExports, resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
 import { createJiti } from 'dev-jiti';
@@ -16,10 +16,9 @@ import { fileURLToPath } from 'node:url';
 import { defu } from 'defu';
 import { resolveModuleURL } from 'exsolve';
 import { isRelative, withTrailingSlash } from 'ufo';
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { globby } from 'globby';
 import ignore from 'ignore';
-import { parseSync } from '@oxc-parser/wasm';
 import { genImport, genTypeImport, genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues, genAugmentation } from 'knitwork';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
@@ -757,312 +756,193 @@ function resolveGroupSyntax(group) {
   return groups;
 }
 
-const safeFiles = [
-  "silgi/configs",
-  "silgi",
-  "silgi/rules",
-  "silgi/scan",
-  "silgi/vfs"
-];
-class SchemaParser {
-  options = {
-    debug: false
+const TYPE_DECLARATION_EXPORT_REGEX = /\bexport\s+(?<declaration>(interface|type|declare (async function|function|let|const enum|const|enum|var|class)))\s+(?<name>[\w$]+)(?:\s+extends\s+(?<extends>[\w$, \t\n\r]+))?/g;
+const FUNCTION_VARIABLE_EXPORT_REGEX = /\bexport\s+(?:const|let|var)\s+(?<name>[\w$]+)\s*=\s*(?<funcName>\w+)\s*\(/g;
+function extractExportMatches(regex, fileContent, additionalMetadata = {}) {
+  const matchedExports = [];
+  for (const match of fileContent.matchAll(regex)) {
+    const name = match.groups?.name || "";
+    const declaration = match.groups?.declaration || "";
+    const funcName = match.groups?.funcName || "";
+    const extendsClause = match.groups?.extends || "";
+    const codeSnippet = funcName ? `export const ${name} = ${funcName}(` : `export ${declaration} ${name}`;
+    const extendedTypes = extendsClause ? extendsClause.split(",").map((typeName) => typeName.trim()) : [];
+    matchedExports.push({
+      ...additionalMetadata,
+      name,
+      declaration,
+      funcName,
+      code: codeSnippet,
+      start: match.index,
+      end: (match.index || 0) + match[0].length,
+      extends: extendedTypes
+    });
+  }
+  return matchedExports;
+}
+function generateUniqueIdentifier(filePath, exportName) {
+  const fileBaseName = basename(filePath);
+  const uniqueString = `${fileBaseName}${exportName}`;
+  return hash(uniqueString);
+}
+function categorizeExports(exportedEntities, filePath) {
+  const runtimeExports = [];
+  const typeExports = [];
+  const functionExportCategories = {
+    createService: "service",
+    createSchema: "schema",
+    createShared: "shared"
   };
-  /**
-   *
-   */
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
+  for (const [functionName, category] of Object.entries(functionExportCategories)) {
+    const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
+    for (const exportEntity of matchingExports) {
+      if (!exportEntity.name)
+        continue;
+      runtimeExports.push({
+        exportName: exportEntity.name,
+        path: filePath,
+        uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
+        category
+      });
+    }
   }
-  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),
-    };
+  const interfaceExportCategories = {
+    ExtendShared: "shared",
+    ExtendContext: "context"
+  };
+  for (const [extensionName, category] of Object.entries(interfaceExportCategories)) {
+    const matchingExports = exportedEntities.filter(
+      (entity) => entity.declaration === "interface" && entity.extends?.includes(extensionName)
+    );
+    for (const exportEntity of matchingExports) {
+      if (!exportEntity.name)
+        continue;
+      typeExports.push({
+        exportName: exportEntity.name,
+        path: filePath,
+        uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
+        category
+      });
+    }
   }
-  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
+  return { runtimeExports, typeExports };
+}
+function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports) {
+  silgiInstance.hook("before:scan.ts", (options) => {
+    for (const { exportName, path, uniqueId, category } of runtimeExports) {
+      if (!path.includes("vfs")) {
+        silgiInstance.options.devServer.watch.push(path);
+      }
+      switch (category) {
+        case "service":
+          options.services.push(uniqueId);
+          break;
+        case "shared":
+          options.shareds.push(uniqueId);
+          break;
+        case "schema":
+          options.schemas.push(uniqueId);
+          break;
+      }
+      options.addImportItem({
+        specifier: removeExtension(relativeWithDot(silgiInstance.options.silgi.serverDir, path)),
+        imports: [{ name: exportName, as: uniqueId }]
       });
-      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
+  });
+  silgiInstance.hook("before:schema.ts", (options) => {
+    for (const { exportName, path, uniqueId, category } of typeExports) {
+      if (!path.includes("vfs")) {
+        silgiInstance.options.devServer.watch.push(path);
+      }
+      if (category === "shared" || category === "context") {
+        const targetCollection = category === "shared" ? options.shareds : options.contexts;
+        targetCollection.push({ key: uniqueId, value: uniqueId });
+      }
+      options.addImportItem({
+        imports: [{ name: exportName, as: uniqueId }],
+        specifier: removeExtension(relativeWithDot(silgiInstance.options.build.typesDir, 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
-          });
-        }
+  });
+}
+async function verifyDirectoryCaseSensitivity(directoryPath, rootDirectory) {
+  const directoryName = basename(directoryPath);
+  const parentDirectory = dirname(directoryPath);
+  try {
+    const siblingEntries = await readdir(parentDirectory);
+    if (!siblingEntries.includes(directoryName)) {
+      const directoryNameLowerCase = directoryName.toLowerCase();
+      const caseInsensitiveMatch = siblingEntries.find(
+        (sibling) => sibling.toLowerCase() === directoryNameLowerCase
+      );
+      if (caseInsensitiveMatch) {
+        const originalRelative = relative(rootDirectory, directoryPath);
+        const correctedRelative = relative(
+          rootDirectory,
+          join(parentDirectory, caseInsensitiveMatch)
+        );
+        consola.warn(
+          `Components not scanned from \`~/${correctedRelative}\`. Did you mean to name the directory \`~/${originalRelative}\` instead?`
+        );
       }
     }
-    return data;
+  } catch {
   }
-  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?`);
-      }
-    }
+async function scanExportFile(silgiInstance) {
+  const processedFilePaths = /* @__PURE__ */ new Set();
+  const alreadyScannedPaths = [];
+  const serverDirectory = silgiInstance.options.serverDir;
+  if (!serverDirectory) {
+    consola.warn("No server directory specified for scanning");
+    return;
   }
-  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;
+  try {
+    const matchedFiles = await globby(serverDirectory, {
+      cwd: silgiInstance.options.rootDir,
+      ignore: silgiInstance.options.ignore
+    });
+    if (matchedFiles.length) {
+      await verifyDirectoryCaseSensitivity(
+        serverDirectory,
+        silgiInstance.options.rootDir
+      );
     }
-    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;
+    for (const relativeFilePath of matchedFiles.sort()) {
+      const absoluteFilePath = resolve(silgiInstance.options.rootDir, relativeFilePath);
+      if (alreadyScannedPaths.find((path) => absoluteFilePath.startsWith(withTrailingSlash(path))) || isIgnored(absoluteFilePath, silgiInstance) || processedFilePaths.has(absoluteFilePath)) {
+        continue;
       }
-      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" };
-        }));
+      processedFilePaths.add(absoluteFilePath);
+      const fileExtension = extname(absoluteFilePath);
+      if (!silgiInstance.options.extensions?.includes(fileExtension)) {
+        continue;
       }
-      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
-      if (hasError("Parser", silgi)) {
-        return;
+      try {
+        const fileContent = await readFile(absoluteFilePath, "utf-8");
+        const typeDeclarationExports = extractExportMatches(
+          TYPE_DECLARATION_EXPORT_REGEX,
+          fileContent,
+          { type: "declaration" }
+        );
+        const functionVariableExports = extractExportMatches(
+          FUNCTION_VARIABLE_EXPORT_REGEX,
+          fileContent,
+          { type: "variable" }
+        );
+        const allExportedEntities = [...typeDeclarationExports, ...functionVariableExports];
+        const { runtimeExports, typeExports } = categorizeExports(
+          allExportedEntities,
+          absoluteFilePath
+        );
+        registerExportsWithHooks(silgiInstance, runtimeExports, typeExports);
+      } catch (error) {
+        consola.error(`Error processing file ${absoluteFilePath}:`, error);
       }
-      if (contextTypes.length > 0) {
-        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
-          const randomString = hash(basename(path) + exportName);
-          const _name = `_v${randomString}`;
-          return { exportName, path, _name, type: "context" };
-        }));
-      }
-      silgi.hook("before:scan.ts", (options) => {
-        for (const { exportName, path, _name, type } of scanTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "service") {
-            options.services.push(_name);
-          }
-          if (type === "shared") {
-            options.shareds.push(_name);
-          }
-          if (type === "schema") {
-            options.schemas.push(_name);
-          }
-          options.addImportItem({
-            specifier: removeExtension(relativeWithDot(silgi.options.silgi.serverDir, path)),
-            imports: [
-              {
-                name: exportName,
-                as: _name
-              }
-            ]
-          });
-        }
-      });
-      silgi.hook("before:schema.ts", (options) => {
-        for (const { exportName, path, _name, type } of schemaTS) {
-          if (!path.includes("vfs")) {
-            silgi.options.devServer.watch.push(path);
-          }
-          if (type === "shared") {
-            options.shareds.push({
-              key: _name,
-              value: _name
-            });
-          }
-          if (type === "context") {
-            options.contexts.push({
-              key: _name,
-              value: _name
-            });
-          }
-          options.addImportItem({
-            imports: [
-              {
-                name: exportName,
-                as: _name
-              }
-            ],
-            specifier: removeExtension(relativeWithDot(silgi.options.build.typesDir, path))
-          });
-        }
-      });
     }
+  } catch (error) {
+    consola.error("Error scanning export files:", error);
   }
 }
 
@@ -1153,7 +1033,7 @@ ${injectedResult.code}`;
     if (silgi.options.debug) {
       console.error("Failed to read scan.ts file:", error);
     } else {
-      consola$1.withTag("silgi").error(error);
+      consola.withTag("silgi").error(error);
     }
     return {
       context,
@@ -1572,7 +1452,7 @@ async function createSilgiCLI(config = {}, opts = {}) {
     hooks,
     errors: [],
     _requiredModules: {},
-    logger: opts.consola || consola$1.withTag("silgi"),
+    logger: opts.consola || consola.withTag("silgi"),
     close: () => silgi.hooks.callHook("close", silgi),
     storage: void 0,
     scanModules: [],
@@ -1680,7 +1560,7 @@ async function generateApiFul(silgi) {
     Object.entries(config?.services ?? {}).filter(([, service]) => Boolean(service.schema))
   );
   if (Object.keys(resolvedOpenAPIServices).length === 0) {
-    consola$1.info("No OpenAPI schemas found, skipping generation");
+    consola.info("No OpenAPI schemas found, skipping generation");
     return;
   }
   for (const service of Object.values(resolvedOpenAPIServices)) {

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.30.6";
+const version = "0.32.0";
 const packageJson = {
 	version: version};
 

package/dist/cli/init.mjs

@@ -24,7 +24,6 @@ import 'defu';
 import 'exsolve';
 import 'globby';
 import 'ignore';
-import '@oxc-parser/wasm';
 import 'knitwork';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/install.mjs

@@ -27,7 +27,6 @@ import 'exsolve';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import '@oxc-parser/wasm';
 import 'knitwork';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/types.mjs

@@ -17,6 +17,7 @@ import { defu } from 'defu';
 const SilgiCLIDefaults = {
   // General
   debug: isDebug === true ? true : void 0,
+  schema: "zod",
   // timing: isDebug,
   logLevel: isTest ? 1 : 3,
   // runtimeConfig: { app: {}, silgi: {} },

package/dist/cli/watch.mjs

@@ -29,7 +29,6 @@ import 'exsolve';
 import 'node:fs/promises';
 import 'globby';
 import 'ignore';
-import '@oxc-parser/wasm';
 import 'knitwork';
 import 'klona';
 import 'silgi/runtime';

package/dist/types/index.d.mts

@@ -10,8 +10,10 @@ import { PresetName, PresetOptions, PresetNameInput } from 'silgi/presets';
 import { ResolvedServiceType as ResolvedServiceType$1, SilgiRuntimeShareds as SilgiRuntimeShareds$1, SilgiRuntimeOptions as SilgiRuntimeOptions$1, RouteRules as RouteRules$1, ModuleMeta as ModuleMeta$1, SilgiModule as SilgiModule$1, BuildSilgi as BuildSilgi$1, Commands as Commands$1, SilgiRouteRules as SilgiRouteRules$1, DotenvOptions as DotenvOptions$1, EnvOptions as EnvOptions$1, SilgiRuntimeConfig as SilgiRuntimeConfig$1, ServiceParseModule as ServiceParseModule$1, SilgiCLIHooks as SilgiCLIHooks$1, StorageMounts as StorageMounts$1, SilgiTemplate as SilgiTemplate$1, SilgiFrameworkInfo as SilgiFrameworkInfo$1 } from 'silgi/types';
 import { Adapter, TablesSchema, InferModelTypes } from 'unadapter/types';
 import { UnimportPluginOptions } from 'unimport/unplugin';
-import { Router, H3Event } from 'h3';
-import { NitroApp, NitroRuntimeConfig } from 'nitropack/types';
+import * as h3 from 'h3';
+import { H3Event } from 'h3';
+import * as nitropack_types from 'nitropack/types';
+import { NitroRuntimeConfig } from 'nitropack/types';
 import { Defu } from 'defu';
 import { Stats } from 'node:fs';
 import { ESMImport, ESMCodeGenOptions } from 'knitwork';
@@ -153,7 +155,7 @@ interface GenImport {
     imports: ESMImport | ESMImport[];
     options?: ESMCodeGenOptions;
 }
-type Framework<T extends PresetName> = T extends 'nitro' ? NitroApp : T extends 'nuxt' ? NitroApp : T extends 'h3' ? Router : never;
+type Framework<T extends PresetName> = T extends 'nitro' ? nitropack_types.NitroApp : T extends 'nuxt' ? nitropack_types.NitroApp : T extends 'h3' ? h3.Router : never;
 interface DefineFrameworkOptions<T extends PresetName> extends Omit<BuildSilgi$1, 'framework'> {
     framework: Framework<T>;
 }
@@ -579,6 +581,7 @@ interface SilgiPresetMeta {
     compatibilityDate?: DateString;
 }
 
+type Schema = 'zod' | 'valibot' | 'arkType' | 'typebox';
 /**
  * SilgiCLI normalized options (silgi.options)
  */
@@ -591,6 +594,7 @@ interface SilgiCLIOptions extends PresetOptions {
     commandType: CommandType;
     commands: Commands$1[];
     routeRules: SilgiRouteRules$1;
+    schema: Schema | Schema[];
     environments: DotenvOptions$1[];
     activeEnvironment: 'prod' | 'docker' | 'staging' | 'testing' | '.env' | (string & {});
     envOptions: EnvOptions$1;
@@ -1187,4 +1191,4 @@ interface ServiceParseModule {
     (params: ServiceParse): Awaited<void> | void;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };
+export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DefineFrameworkOptions, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, Schema, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.30.6",
+  "version": "0.32.0",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -81,7 +81,6 @@
   "dependencies": {
     "@clack/prompts": "^0.10.1",
     "@fastify/deepmerge": "^3.1.0",
-    "@oxc-parser/wasm": "^0.60.0",
     "@standard-schema/spec": "^1.0.0",
     "apiful": "^2.1.0",
     "c12": "^3.0.3",