silgi 0.30.5 → 0.31.0

package/dist/build.mjs

@@ -1,12 +1,12 @@
-import { watch } from 'chokidar';
-import consola from 'consola';
-import { join, basename } from 'pathe';
-import { debounce } from 'perfect-debounce';
-import { u as useSilgiCLI, a as silgiCLIIClose } from './_chunks/silgiApp.mjs';
-import { r as reloadScan } from './cli/devServer.mjs';
-import { c as createSilgiCLI, b as build } from './cli/build.mjs';
+export { p as prepareBuild, w as watchDev } from './cli/dev.mjs';
+import 'chokidar';
+import 'consola';
+import 'pathe';
+import 'perfect-debounce';
+import './_chunks/silgiApp.mjs';
 import 'unctx';
 import 'silgi';
+import './cli/build.mjs';
 import 'hookable';
 import 'silgi/kit';
 import 'silgi/runtime/meta';
@@ -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';
@@ -44,73 +43,3 @@ import 'pkg-types';
 import 'apiful/openapi';
 import 'pathe/utils';
 import 'untyped';
-
-async function prepareBuild(config) {
-  const silgi = await createSilgiCLI({
-    commandType: config?.commandType || "prepare",
-    ...config
-  });
-  await build(silgi);
-  return silgi;
-}
-
-async function watchDev() {
-  let watcher;
-  async function load() {
-    await prepareBuild({
-      commandType: "prepare",
-      activeEnvironment: ".env"
-    });
-  }
-  const reload = debounce(load);
-  const silgi = useSilgiCLI();
-  silgi.options.watchOptions.ignored ??= [];
-  silgi.options.watchOptions.ignoreInitial = true;
-  if (Array.isArray(silgi.options.watchOptions.ignored)) {
-    silgi.options.watchOptions.ignored.push(
-      `!${join(silgi.options.silgi.serverDir, "config")}`
-    );
-  }
-  silgi.options.devServer.watch.push(
-    join(silgi.options.serverDir, "services"),
-    join(silgi.options.serverDir, "schemas"),
-    join(silgi.options.serverDir, "shared"),
-    join(silgi.options.serverDir, "utils"),
-    join(silgi.options.serverDir, "types"),
-    join(silgi.options.silgi.serverDir, "config"),
-    join(silgi.options.rootDir, "silgi.config.ts")
-  );
-  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir", "change"]);
-  if (silgi.options.devServer.watch.length > 0) {
-    silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)];
-    watcher = watch(silgi.options.devServer.watch, silgi.options.watchOptions);
-    watcher.on("all", async (event, path, stats) => {
-      if (!watchReloadEvents.has(event)) {
-        return;
-      }
-      const startTime = performance.now();
-      silgi.errors = [];
-      try {
-        await reloadScan(path, stats);
-        await reload();
-      } catch (error) {
-        consola.withTag("silgi").error(error);
-      }
-      silgi.errors = [];
-      const endTime = performance.now();
-      const elapsedTime = Math.round(endTime - startTime);
-      silgi.logger.success(`${basename(path)} - ${elapsedTime}ms`);
-    }).on("error", (error) => {
-      consola.withTag("silgi").error(error);
-    });
-  }
-  async function close() {
-    await silgiCLIIClose();
-  }
-  return {
-    watcher,
-    close
-  };
-}
-
-export { prepareBuild, watchDev };

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/dev.mjs

@@ -0,0 +1,83 @@
+import { watch } from 'chokidar';
+import consola from 'consola';
+import { join, basename } from 'pathe';
+import { debounce } from 'perfect-debounce';
+import { u as useSilgiCLI$1, a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
+import { useSilgiCLI } from 'silgi';
+import { c as createSilgiCLI, b as build } from './build.mjs';
+
+async function reloadScan(path, _stats) {
+  const silgi = useSilgiCLI();
+  await silgi.callHook("reload:scan", path, _stats);
+}
+
+async function prepareBuild(config) {
+  const silgi = await createSilgiCLI({
+    commandType: config?.commandType || "prepare",
+    ...config
+  });
+  await build(silgi);
+  return silgi;
+}
+
+async function watchDev() {
+  let watcher;
+  async function load() {
+    await prepareBuild({
+      commandType: "prepare",
+      activeEnvironment: ".env"
+    });
+  }
+  const reload = debounce(load);
+  const silgi = useSilgiCLI$1();
+  silgi.options.watchOptions.ignored ??= [];
+  silgi.options.watchOptions.ignoreInitial = true;
+  if (Array.isArray(silgi.options.watchOptions.ignored)) {
+    silgi.options.watchOptions.ignored.push(
+      `!${join(silgi.options.silgi.serverDir, "config")}`
+    );
+  }
+  silgi.options.devServer.watch.push(
+    join(silgi.options.serverDir, "services"),
+    join(silgi.options.serverDir, "schemas"),
+    join(silgi.options.serverDir, "shared"),
+    join(silgi.options.serverDir, "utils"),
+    join(silgi.options.serverDir, "types"),
+    join(silgi.options.silgi.serverDir, "config"),
+    join(silgi.options.silgi.serverDir, "modules"),
+    join(silgi.options.rootDir, "silgi.config.ts")
+  );
+  const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir", "change"]);
+  if (silgi.options.devServer.watch.length > 0) {
+    silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)];
+    watcher = watch(silgi.options.devServer.watch, silgi.options.watchOptions);
+    watcher.on("all", async (event, path, stats) => {
+      if (!watchReloadEvents.has(event)) {
+        return;
+      }
+      const startTime = performance.now();
+      silgi.errors = [];
+      try {
+        await reloadScan(path, stats);
+        await reload();
+      } catch (error) {
+        consola.withTag("silgi").error(error);
+      }
+      silgi.errors = [];
+      const endTime = performance.now();
+      const elapsedTime = Math.round(endTime - startTime);
+      silgi.logger.success(`${basename(path)} - ${elapsedTime}ms`);
+    }).on("error", (error) => {
+      consola.withTag("silgi").error(error);
+    });
+  }
+  async function close() {
+    await silgiCLIIClose();
+  }
+  return {
+    watcher,
+    close
+  };
+}
+
+export { prepareBuild as p, watchDev as w };

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.30.5";
+const version = "0.31.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/watch.mjs

@@ -1,14 +1,14 @@
-import { basename } from 'node:path';
-import { watch } from 'chokidar';
 import { defineCommand, runCommand } from 'citty';
 import consola from 'consola';
-import { join } from 'pathe';
-import { useSilgiCLI } from 'silgi';
 import { version } from 'silgi/meta';
-import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { r as reloadScan } from './devServer.mjs';
+import { w as watchDev } from './dev.mjs';
 import { b as commonArgs, a as command$1 } from './prepare.mjs';
+import 'chokidar';
+import 'pathe';
+import 'perfect-debounce';
+import '../_chunks/silgiApp.mjs';
 import 'unctx';
+import 'silgi';
 import './build.mjs';
 import 'hookable';
 import 'silgi/kit';
@@ -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';
@@ -69,56 +68,13 @@ const command = defineCommand({
     await runCommand(command$1, {
       rawArgs: ["--commandType", "dev", "--dev", "true"]
     });
-    const silgi = useSilgiCLI();
-    silgi.options.watchOptions.ignored ??= [];
-    silgi.options.watchOptions.ignoreInitial = true;
-    if (Array.isArray(silgi.options.watchOptions.ignored)) {
-      silgi.options.watchOptions.ignored.push(
-        `!${join(silgi.options.silgi.serverDir, "config")}`
-      );
-    }
-    silgi.options.devServer.watch.push(
-      join(silgi.options.serverDir, "services"),
-      join(silgi.options.serverDir, "schemas"),
-      join(silgi.options.serverDir, "shared"),
-      join(silgi.options.serverDir, "utils"),
-      join(silgi.options.serverDir, "types"),
-      join(silgi.options.silgi.serverDir, "config"),
-      join(silgi.options.rootDir, "silgi.config.ts")
-    );
-    const watchReloadEvents = /* @__PURE__ */ new Set(["add", "addDir", "unlink", "unlinkDir", "change"]);
-    let watcher;
-    if (silgi.options.devServer.watch.length > 0) {
-      silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)];
-      watcher = watch(silgi.options.devServer.watch, silgi.options.watchOptions);
-      watcher.on("all", async (event, path, stats) => {
-        if (!watchReloadEvents.has(event)) {
-          return;
-        }
-        const startTime = performance.now();
-        silgi.errors = [];
-        try {
-          await reloadScan(path, stats);
-          await runCommand(command$1, {
-            rawArgs: ["--commands", "run", "--dev", "true"]
-          });
-        } catch (error) {
-          consola.withTag("silgi").error(error);
-        }
-        silgi.errors = [];
-        const endTime = performance.now();
-        const elapsedTime = Math.round(endTime - startTime);
-        silgi.logger.success(`${basename(path)} - ${elapsedTime}ms`);
-      }).on("error", (error) => {
-        consola.withTag("silgi").error(error);
-      });
-    }
+    const watch = await watchDev();
     process.on("SIGINT", async () => {
       consola.withTag("silgi").info("Shutting down...");
-      if (watcher) {
-        watcher.close();
+      if (watch) {
+        watch.close();
       }
-      await silgiCLIIClose();
+      await watch.close();
       process.exit(0);
     });
     consola.withTag("silgi").success("Prepare completed");

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>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.30.5",
+  "version": "0.31.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",
@@ -124,7 +123,7 @@
     "@antfu/eslint-config": "^4.12.0",
     "@nuxt/kit": "^3.16.2",
     "@nuxt/schema": "^3.16.2",
-    "@silgi/ecosystem": "^0.6.0",
+    "@silgi/ecosystem": "^0.6.2",
     "@types/node": "^22.15.2",
     "@types/semver": "^7.7.0",
     "@vitest/coverage-v8": "3.0.5",

package/dist/cli/devServer.mjs

@@ -1,8 +0,0 @@
-import { useSilgiCLI } from 'silgi';
-
-async function reloadScan(path, _stats) {
-  const silgi = useSilgiCLI();
-  await silgi.callHook("reload:scan", path, _stats);
-}
-
-export { reloadScan as r };