silgi 0.29.8 → 0.29.9

package/dist/cli/index.mjs

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

package/dist/cli/silgi.mjs

@@ -1,10 +1,10 @@
 import { generateDTS } from 'apiful/openapi';
 import consola$1, { consola } from 'consola';
 import { join, resolve, dirname, isAbsolute, relative, basename, extname } from 'pathe';
-import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, hash, relativeWithDot, writeFile, isDirectory, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
+import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, toArray, hash, writeFile, relativeWithDot, isDirectory, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
 import { mkdirSync, existsSync, writeFileSync, promises, readFileSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
-import { genObjectFromRawEntries, genObjectFromRaw, genObjectFromValues } from 'knitwork';
+import { genObjectFromRawEntries, genImport, genTypeImport, genObjectFromRaw, genObjectFromValues } from 'knitwork';
 import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolveModuleExportNames, findTypeExports, findExports } from 'mlly';
 import { resolveAlias } from 'pathe/utils';
 import { runtimeDir } from 'silgi/runtime/meta';
@@ -233,237 +233,209 @@ async function prepareConfigs(silgi) {
   return importData;
 }
 
-async function prepareCoreFile(data, frameworkContext, silgi) {
-  let importItems = {
-    "silgi": {
-      import: [
-        {
-          name: "createSilgi",
-          key: "createSilgi"
-        }
-      ],
-      from: "silgi"
-    },
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeOptions",
-          type: true,
-          key: "SilgiRuntimeOptions"
-        },
-        {
-          name: "FrameworkContext",
-          type: true,
-          key: "FrameworkContext"
-        },
-        {
-          name: "SilgiOptions",
-          type: true,
-          key: "SilgiOptions"
-        }
-      ],
-      from: "silgi/types"
-    },
-    "#silgi/vfs": {
-      import: [],
-      from: "./vfs"
-    },
-    "scan.ts": {
-      import: [
-        {
-          name: "uris",
-          type: false,
-          key: "uris"
-        },
-        {
-          name: "services",
-          type: false,
-          key: "services"
-        },
-        {
-          name: "shareds",
-          type: false,
-          key: "shareds"
-        },
-        {
-          name: "schemas",
-          type: false,
-          key: "schemas"
-        },
-        {
-          name: "modulesURIs",
-          type: false,
-          key: "modulesURIs"
-        }
-      ],
-      from: "./scan.ts"
-    },
-    "configs.ts": {
-      import: [
-        {
-          name: "cliConfigs",
-          type: false,
-          key: "cliConfigs"
+function scanImports(data) {
+  const genImports = [
+    ...data.imports ?? []
+  ];
+  const genTypeImports = [
+    ...data.typeImports ?? []
+  ];
+  function addImportItem(data2) {
+    for (const item of toArray(data2)) {
+      const isSpecifier = genImports.some((i) => i.specifier === item.specifier);
+      if (isSpecifier) {
+        const index = genImports.findIndex((i) => i.specifier === item.specifier);
+        if (Array.isArray(genImports[index].imports)) {
+          genImports[index].imports ??= [];
+          genImports[index].imports.push(...toArray(item.imports));
+        } else {
+          genImports[index].imports = item.imports;
         }
-      ],
-      from: "./configs.ts"
-    },
-    "rules.ts": {
-      import: [
-        {
-          name: "routeRules",
-          key: "routeRules"
+      } else {
+        genImports.push({
+          specifier: item.specifier,
+          imports: item.imports,
+          options: item.options
+        });
+      }
+    }
+  }
+  function addImportItemType(data2) {
+    for (const item of toArray(data2)) {
+      const isSpecifier = genTypeImports.some((i) => i.specifier === item.specifier);
+      if (isSpecifier) {
+        const index = genTypeImports.findIndex((i) => i.specifier === item.specifier);
+        if (Array.isArray(genTypeImports[index].imports)) {
+          genTypeImports[index].imports ??= [];
+          genTypeImports[index].imports.push(...toArray(item.imports));
+        } else {
+          genTypeImports[index].imports = item.imports;
         }
-      ],
-      from: "./rules.ts"
+      } else {
+        genTypeImports.push({
+          specifier: item.specifier,
+          imports: item.imports,
+          options: item.options
+        });
+      }
     }
+  }
+  return {
+    genImports,
+    genTypeImports,
+    addImportItem,
+    addImportItemType
   };
-  importItems = { ...data._importItems, ...importItems };
+}
+
+async function prepareCoreFile(silgi) {
+  const { genImports, genTypeImports, addImportItem, addImportItemType } = scanImports({
+    imports: [
+      {
+        specifier: "silgi/runtime",
+        imports: [
+          {
+            name: "mergeDeep"
+          }
+        ]
+      },
+      {
+        specifier: "silgi",
+        imports: [
+          {
+            name: "createSilgi"
+          }
+        ]
+      },
+      {
+        specifier: "./scan",
+        imports: [
+          {
+            name: "uris"
+          },
+          {
+            name: "services"
+          },
+          {
+            name: "shareds"
+          },
+          {
+            name: "schemas"
+          },
+          {
+            name: "modulesURIs"
+          }
+        ]
+      },
+      {
+        specifier: "./configs",
+        imports: [
+          {
+            name: "cliConfigs"
+          }
+        ]
+      },
+      {
+        specifier: "./rules",
+        imports: [
+          {
+            name: "routeRules"
+          }
+        ]
+      }
+    ],
+    typeImports: [
+      {
+        specifier: "silgi/types",
+        imports: [
+          {
+            name: "SilgiRuntimeOptions"
+          },
+          {
+            name: "BuildSilgi"
+          }
+        ]
+      }
+    ]
+  });
+  const before = [];
+  const after = [];
   const _data = {
-    customImports: data._customImports || [],
-    buildSilgiExtraContent: [],
-    beforeBuildSilgiExtraContent: [],
-    afterCliOptions: [],
-    _silgiConfigs: [],
-    customContent: [],
-    importItems
+    silgiConfigs: [],
+    addImportItem,
+    addImportItemType,
+    addFunction: (data) => {
+      for (const item of data) {
+        if (item.where === "after") {
+          after.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(framework)`);
+        }
+        if (item.where === "before") {
+          before.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(framework)`);
+        }
+      }
+    }
   };
-  await silgi.callHook("prepare:core.ts", _data);
-  if (importItems["#silgi/vfs"].import.length === 0) {
-    delete importItems["#silgi/vfs"];
-  }
+  await silgi.callHook("before:core.ts", _data);
   const plugins = [];
   for (const plugin of silgi.options.plugins) {
-    const pluginImportName = `_${hash(plugin.packageImport)}`;
-    _data.customImports.push(`import ${pluginImportName} from '${plugin.packageImport}'`);
+    const pluginImportName = hash(plugin.packageImport);
+    addImportItem({
+      specifier: plugin.packageImport,
+      imports: pluginImportName
+    });
     plugins.push(pluginImportName);
   }
   const importsContent = [
-    'import { mergeDeep } from "silgi/runtime"',
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
+    ...genImports.map(({ specifier, imports, options }) => {
+      return genImport(specifier, imports, options);
+    }),
+    ...genTypeImports.map(({ specifier, imports }) => {
+      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
     }),
-    "",
-    ..._data.customImports,
     ""
   ];
   const importData = [
     "",
-    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<SilgiRuntimeOptions>,buildOptions?: Partial<SilgiOptions>) {",
+    "export async function buildSilgi(option: BuildSilgi) {",
+    "",
+    ...before,
     "",
-    _data.beforeBuildSilgiExtraContent.length > 0 ? _data.beforeBuildSilgiExtraContent.map(({ value, type }) => {
-      return type === "function" ? value : `const ${value}`;
-    }) : "",
+    "const silgi = await createSilgi({",
+    " framework: option.framework,",
+    " shared: shareds,",
+    " services: services,",
+    " schemas: schemas,",
+    " uris,",
+    " modulesURIs,",
+    ` plugins: [${plugins.join(", ")}],`,
     "",
-    "  const silgi = await createSilgi({",
-    "      framework,",
-    "      shared: shareds as any,",
-    "      services: services as any,",
-    "      schemas: schemas as any,",
-    "      uris,",
-    "      modulesURIs,",
-    `      plugins: [${plugins.join(", ")}],`,
-    _data._silgiConfigs.length > 0 ? `      ${_data._silgiConfigs.map((config) => typeof config === "string" ? config : typeof config === "object" ? Object.entries(config).map(([key, value]) => `${key}: ${value}`).join(",\n      ") : "").join(",\n      ")},` : "",
-    "      options: mergeDeep(cliConfigs, {",
-    "        runtimeConfig: {} as SilgiRuntimeOptions,",
-    "        routeRules: routeRules as any,",
-    `        present: '${silgi.options.preset}',`,
-    "        ...moduleOptions,",
-    "        ...buildOptions,",
-    "      }) as any,",
-    "    })",
+    _data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
+      const code = genObjectFromRawEntries(Object.entries(item));
+      return ` ${code.slice(1, -1).trim()},`;
+    }).filter(Boolean).join("\n") : "",
     "",
-    ...frameworkContext,
+    " options: mergeDeep(cliConfigs, {",
+    "   runtimeConfig: {} as SilgiRuntimeOptions,",
+    "   routeRules: routeRules as any,",
+    `   present: '${silgi.options.preset}',`,
+    "   ...option.modules,",
+    "   ...option.options,",
+    "   }) as any,",
+    " })",
     "",
-    ..._data.buildSilgiExtraContent,
+    ...after,
     "",
     "  return silgi",
     "}",
     ""
   ];
-  await silgi.callHook("after:prepare:core.ts", importData);
+  await silgi.callHook("after:core.ts", importData);
   importData.unshift(...importsContent);
   return importData;
 }
 
-async function prepareFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const functions = [];
-  await silgi.callHook("prepare:createCoreFramework", {
-    importItems,
-    customImports,
-    functions
-  });
-  const content = [
-    ...functions.map((f) => f.params?.length ? ` await ${f.name}(framework, ${f.params.join(",")})` : ` await ${f.name}(framework)`)
-  ];
-  return {
-    content,
-    importItems,
-    customImports
-  };
-}
-async function createDTSFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const customContent = [];
-  await silgi.callHook("prepare:createDTSFramework", {
-    importItems,
-    customImports,
-    customContent
-  });
-  const content = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
 async function writeCoreFile(silgi) {
-  const data = await prepareFramework(silgi);
-  const coreContent = await prepareCoreFile({
-    _importItems: data?.importItems ?? {},
-    _customImports: data?.customImports ?? []
-  }, data?.content ?? [], silgi);
+  const coreContent = await prepareCoreFile(silgi);
   const configs = await prepareConfigs(silgi);
   const silgiDir = resolve(silgi.options.silgi.serverDir);
   const buildFiles = [];
@@ -564,6 +536,46 @@ ${methodEntries}
   return context;
 }
 
+async function createDTSFramework(silgi) {
+  const importItems = {
+    "silgi/types": {
+      import: [
+        {
+          name: "SilgiRuntimeContext",
+          type: true,
+          key: "SilgiRuntimeContext"
+        }
+      ],
+      from: "silgi/types"
+    }
+  };
+  const customImports = [];
+  const customContent = [];
+  await silgi.callHook("prepare:createDTSFramework", {
+    importItems,
+    customImports,
+    customContent
+  });
+  const content = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      if (silgi.options.typescript.removeFileExtension) {
+        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
+      }
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...customImports,
+    "",
+    ...customContent,
+    ""
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+
 async function prepareSchema(silgi) {
   const importItems = {
     "silgi/types": {
@@ -1049,8 +1061,9 @@ async function h3Framework(silgi, skip = false) {
       ""
     );
   });
-  silgi.hook("prepare:core.ts", (data) => {
-    data._silgiConfigs.push(`captureError: (silgi, error, context = {}) => {
+  silgi.hook("before:core.ts", (data) => {
+    data.createSilgiParams.push({
+      captureError: `(silgi, error, context = {}) => {
         const promise = silgi.hooks
           .callHookParallel('error', silgi, error, context)
           .catch((error_) => {
@@ -1066,7 +1079,8 @@ async function h3Framework(silgi, skip = false) {
             context.event.waitUntil(promise)
           }
         }
-      }`);
+      }`
+    });
   });
   if (silgi.options.imports !== false) {
     const h3Exports = await resolveModuleExportNames("h3", {

package/dist/kit/index.d.mts

@@ -1,4 +1,4 @@
-import { Commands, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
+import { Commands, SilgiCLIHooks, SilgiCLI, ModuleOptionsCustom, ModuleDefinition, SilgiModule, ServiceParseModule, SilgiPreset, SilgiPresetMeta, SilgiTemplate, ResolvedSilgiTemplate, SilgiEvents } from 'silgi/types';
 import { Buffer } from 'node:buffer';
 import { ConsolaOptions, ConsolaInstance } from 'consola';
 import * as rfc6902 from 'rfc6902';
@@ -6,6 +6,11 @@ import { IncomingMessage, ServerResponse } from 'node:http';
 
 declare function addCommands(data: Commands | Commands[]): Promise<void>;
 
+declare function addCoreFile(data: {
+    before?: SilgiCLIHooks['before:core.ts'];
+    after?: SilgiCLIHooks['after:core.ts'];
+}): Promise<void>;
+
 declare function addNPMPackage(data: {
     name: string;
     version?: string;
@@ -296,5 +301,5 @@ declare function hasInstalledModule(moduleKey: string, silgi?: SilgiCLI): boolea
 declare const baseHeaderBannerComment: string[];
 declare function processFilePath(src: string): string;
 
-export { MODE_RE, MigrationStatus, addCommands, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
 export type { FunctionConfig, JsonPatch, MigrationData, MigrationInfo, MigrationOptions, MigrationResult };

package/dist/kit/index.mjs

@@ -67,6 +67,14 @@ async function addCommands(data) {
   });
 }
 
+async function addCoreFile(data) {
+  const silgi = useSilgiCLI$1();
+  if (data.before)
+    silgi.hook("before:core.ts", data.before);
+  if (data.after)
+    silgi.hook("after:core.ts", data.after);
+}
+
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function addNPMPackage(data) {
   const silgi = useSilgiCLI$1();
@@ -287,7 +295,7 @@ function getAllEntries(obj) {
 }
 
 function hash(data) {
-  return camelCase(hash$1(data));
+  return `_${camelCase(hash$1(data))}`;
 }
 
 function isNuxt() {
@@ -961,4 +969,4 @@ function isValidIp(ip) {
   return false;
 }
 
-export { MODE_RE, MigrationStatus, addCommands, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, MigrationStatus, addCommands, addCoreFile, addNPMPackage, addTemplate, baseHeaderBannerComment, createFunction, createFunctionConfigs, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, formatFunctions, genEnsureSafeVar, generateMigration, getAllEntries, getIpAddress, getMigration, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, listMigrations, migrationDown, migrationUp, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };

package/dist/types/index.d.mts

@@ -14,6 +14,7 @@ import { H3Event } from 'h3';
 import { NitroRuntimeConfig } from 'nitropack/types';
 import { Defu } from 'defu';
 import { Stats } from 'node:fs';
+import { ESMImport, ESMCodeGenOptions } from 'knitwork';
 import { Unimport } from 'unimport';
 import { Storage, TransactionOptions, BuiltinDriverName, StorageValue } from 'unstorage';
 import { StandardSchemaV1 } from '@standard-schema/spec';
@@ -33,6 +34,9 @@ interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
     toString: () => string;
 }
 
+/**
+ * @deprecated
+ */
 interface ImportItem {
     importItems: {
         [key: string]: {
@@ -161,6 +165,11 @@ interface Commands {
     }) => string;
     order?: number;
 }
+interface GenImport {
+    specifier: string;
+    imports: ESMImport | ESMImport[];
+    options?: ESMCodeGenOptions;
+}
 
 interface SilgiCLIHooks extends SilgiHooks {
     /**
@@ -200,8 +209,8 @@ interface SilgiCLIHooks extends SilgiHooks {
         declarations: string[];
         tsConfig: TSConfig;
     }) => HookResult;
-    'prepare:core.ts': (data: PrepareCore) => HookResult;
-    'after:prepare:core.ts': (content: string[]) => HookResult;
+    'before:core.ts': (data: PrepareCore) => HookResult;
+    'after:core.ts': (content: string[]) => HookResult;
     'prepare:scan.ts': (data: Pick<ImportItem, 'customImports' | 'importItems'> & {
         uris: Record<string, string>;
         services: string[];
@@ -290,14 +299,15 @@ interface SilgiHooks {
 interface GenerateAppOptions {
     filter?: (template: ResolvedSilgiTemplate<any>) => boolean;
 }
-interface PrepareCore extends ImportItem {
-    buildSilgiExtraContent: string[];
-    beforeBuildSilgiExtraContent: {
-        value: string;
-        type: 'function' | 'variable';
-    }[];
-    afterCliOptions: string[];
-    _silgiConfigs: any[];
+interface PrepareCore {
+    silgiConfigs: Record<string, any>[];
+    addImportItem: (data: GenImport | GenImport[]) => void;
+    addImportItemType: (data: GenImport | GenImport[]) => void;
+    addFunction: (data: {
+        name: string;
+        params?: string[];
+        where: 'before' | 'after';
+    }[]) => void;
 }
 
 /**
@@ -1030,7 +1040,7 @@ interface FrameworkContext {
 }
 interface Silgi {
     schemas: any;
-    services: ResolvedServiceType;
+    services: RequiredServiceType<SilgiSchema>;
     shared: SilgiRuntimeShareds;
     uris: Record<string, any>;
     modulesURIs: Partial<Record<keyof SilgiRuntimeOptions | (string & {}), any>>;
@@ -1057,6 +1067,11 @@ interface SilgiConfig extends Partial<Omit<Silgi, 'options'>>, Partial<SilgiRunt
 interface SilgiFunction {
     execute: <TURI extends keyof SilgiURIs>(uriString: TURI, input: ExtractInputFromURI<TURI>, source?: ExtractSourceFromURI<TURI>, queryParams?: Record<string, string>) => Promise<ExtractOutputFromURI<TURI>>;
 }
+interface BuildSilgi {
+    framework: FrameworkContext;
+    modules?: Partial<SilgiRuntimeOptions>;
+    options?: Partial<SilgiOptions>;
+}
 
 interface SilgiAppPlugin {
     (silgi: Silgi): Promise<void> | void;
@@ -1181,4 +1196,4 @@ interface ServiceParseModule {
     (params: ServiceParse): Awaited<void> | void;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, PrepareCore, 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, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, PrepareCore, 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.29.8",
+  "version": "0.29.9",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -15,10 +15,22 @@
     "./config": "./lib/config.mjs",
     "./types": "./dist/types/index.d.mts",
     "./meta": "./lib/meta.mjs",
-    "./presets": "./dist/presets/index.mjs",
-    "./runtime": "./dist/runtime/index.mjs",
-    "./runtime/internal": "./dist/runtime/internal/index.mjs",
-    "./runtime/internal/*": "./dist/runtime/internal/*.mjs",
+    "./presets": {
+      "import": "./dist/presets/index.mjs",
+      "silgiDev": "./dist/presets/index.ts"
+    },
+    "./runtime": {
+      "import": "./dist/runtime/index.mjs",
+      "silgiDev": "./dist/runtime/index.ts"
+    },
+    "./runtime/internal/nitro": {
+      "import": "./dist/runtime/internal/nitro.mjs",
+      "silgiDev": "./dist/runtime/internal/nitro.ts"
+    },
+    "./runtime/internal": {
+      "import": "./dist/runtime/internal/index.mjs",
+      "silgiDev": "./dist/runtime/internal/index.ts"
+    },
     "./runtime/meta": "./lib/runtime-meta.mjs"
   },
   "main": "./dist/core/index.mjs",
@@ -89,6 +101,7 @@
     "ignore": "^7.0.3",
     "klona": "^2.0.6",
     "knitwork": "^1.2.0",
+    "magicast": "^0.3.5",
     "mlly": "^1.7.4",
     "ofetch": "^1.4.1",
     "ohash": "^2.0.11",