silgi 0.0.13 → 0.1.0-beta.1

package/dist/shared/silgi.BMCYk2cR.mjs

@@ -1,841 +0,0 @@
-import consola, { createConsola } from 'consola';
-import { createHooks } from 'hookable';
-import { Buffer } from 'node:buffer';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { getContext } from 'unctx';
-
-class PergelError extends Error {
-  code;
-  details;
-  meta;
-  timestamp;
-  constructor(options) {
-    super(options.message);
-    this.name = "PergelError";
-    this.code = options.code;
-    this.details = options.details;
-    this.meta = options.meta;
-    this.timestamp = Date.now();
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  // Improve error formatting
-  toString() {
-    let errorString = `[${this.code}] ${this.message}`;
-    if (this.details) {
-      errorString += `
-Details: ${JSON.stringify(this.details, null, 2)}`;
-    }
-    return errorString;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      meta: this.meta,
-      timestamp: this.timestamp,
-      stack: this.stack
-    };
-  }
-  static createFrom(error, code = "UNKNOWN_ERROR") {
-    if (error instanceof PergelError) {
-      return error;
-    }
-    return new PergelError({
-      code,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error : undefined
-    });
-  }
-  static isPergelError(error) {
-    return error instanceof PergelError;
-  }
-}
-
-class MemoryCacheProvider {
-  cache = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    if (options.maxSize) {
-      setInterval(() => {
-        if (this.cache.size > options.maxSize) {
-          const entries = Array.from(this.cache.entries());
-          entries.sort(([, a], [, b]) => a.expiry - b.expiry);
-          const toDelete = entries.slice(0, entries.length - options.maxSize);
-          toDelete.forEach(([key]) => this.cache.delete(key));
-        }
-      }, 1e3);
-    }
-  }
-  async get(key) {
-    const entry = this.cache.get(key);
-    if (!entry)
-      return null;
-    if (Date.now() > entry.expiry) {
-      this.cache.delete(key);
-      return null;
-    }
-    return entry.value;
-  }
-  async set(key, value, ttl) {
-    this.cache.set(key, {
-      value,
-      expiry: Date.now() + ttl
-    });
-  }
-  async delete(key) {
-    this.cache.delete(key);
-  }
-  async clear() {
-    this.cache.clear();
-  }
-}
-class FileCacheProvider {
-  constructor(options = {}) {
-    this.options = options;
-    this.cacheDir = options.dir || join(process.cwd(), ".cache", "pergel");
-    if (!existsSync(this.cacheDir))
-      mkdirSync(this.cacheDir, { recursive: true });
-  }
-  cacheDir;
-  getFilePath(key) {
-    const safeKey = Buffer.from(key).toString("base64");
-    return join(this.cacheDir, `${safeKey}.json`);
-  }
-  async get(key) {
-    try {
-      const filePath = this.getFilePath(key);
-      if (!existsSync(filePath))
-        return null;
-      const data = JSON.parse(readFileSync(filePath, "utf-8"));
-      if (Date.now() > data.expiry) {
-        await this.delete(key);
-        return null;
-      }
-      return data.value;
-    } catch {
-      return null;
-    }
-  }
-  async set(key, value, ttl) {
-    const filePath = this.getFilePath(key);
-    const data = {
-      value,
-      expiry: Date.now() + ttl
-    };
-    writeFileSync(filePath, JSON.stringify(data), "utf-8");
-  }
-  async delete(key) {
-    try {
-      unlinkSync(this.getFilePath(key));
-    } catch {
-    }
-  }
-  async clear() {
-    try {
-      const files = existsSync(this.cacheDir) ? readdirSync(this.cacheDir) : [];
-      for (const file of files)
-        unlinkSync(join(this.cacheDir, file));
-    } catch {
-    }
-  }
-}
-
-const logger$1 = consola.withTag("pergel");
-class PluginManager {
-  // Removed readonly
-  constructor(silgi) {
-    this.silgi = silgi;
-  }
-  plugins = /* @__PURE__ */ new Map();
-  pluginPriorities = /* @__PURE__ */ new Map();
-  log(message, ...args) {
-    if (this.silgi.silgi.options.debug)
-      logger$1.withTag("plugin").log(message, ...args);
-  }
-  register(plugin) {
-    const pluginName = String(plugin.name);
-    this.log(`Registering plugin: ${pluginName}`);
-    if (this.plugins.has(pluginName)) {
-      throw new PergelError({
-        code: "PLUGIN_ALREADY_EXISTS",
-        message: `Plugin ${pluginName} already registered`
-      });
-    }
-    this.plugins.set(pluginName, plugin);
-    this.calculatePluginPriorities();
-  }
-  calculatePluginPriorities() {
-    const visited = /* @__PURE__ */ new Set();
-    const priorities = /* @__PURE__ */ new Map();
-    const baseOffset = 1e3;
-    const getBasePriority = (priority) => {
-      switch (priority) {
-        case "HIGHEST":
-          return baseOffset * 5;
-        case "HIGH":
-          return baseOffset * 4;
-        case "NORMAL":
-          return baseOffset * 3;
-        case "LOW":
-          return baseOffset * 2;
-        case "LOWEST":
-          return baseOffset;
-        default:
-          return baseOffset * 3;
-      }
-    };
-    const visit = (pluginName, depth = 0) => {
-      if (visited.has(pluginName))
-        return priorities.get(pluginName) || 0;
-      visited.add(pluginName);
-      const plugin = this.plugins.get(pluginName);
-      if (!plugin)
-        return 0;
-      let priority = getBasePriority(plugin.priority || "NORMAL");
-      const deps = plugin.dependencies || [];
-      for (const dep of deps) {
-        const depName = String(dep);
-        const depPriority = visit(depName, depth + 1);
-        priority = Math.min(priority, depPriority - baseOffset / (depth + 1));
-      }
-      priorities.set(pluginName, priority);
-      return priority;
-    };
-    for (const pluginName of this.plugins.keys()) {
-      visit(pluginName);
-    }
-    const validateDependencies = (pluginName, chain = /* @__PURE__ */ new Set()) => {
-      const plugin = this.plugins.get(pluginName);
-      if (!plugin)
-        return;
-      if (chain.has(pluginName)) {
-        throw new PergelError({
-          code: "CIRCULAR_DEPENDENCY",
-          message: `Circular dependency detected: ${Array.from(chain).join(" -> ")} -> ${pluginName}`
-        });
-      }
-      chain.add(pluginName);
-      for (const dep of plugin.dependencies || []) {
-        validateDependencies(String(dep), new Set(chain));
-      }
-    };
-    for (const pluginName of this.plugins.keys()) {
-      validateDependencies(pluginName);
-    }
-    this.pluginPriorities = priorities;
-    this.log("Plugin priorities:", Object.fromEntries([...priorities.entries()].sort((a, b) => b[1] - a[1]).map(([name, pri]) => [name, { priority: pri, basePriority: this.plugins.get(name)?.priority || "NORMAL" }])));
-  }
-  async runSetupHook() {
-    const sortedPlugins = [...this.plugins.values()].sort((a, b) => {
-      const priorityA = this.pluginPriorities.get(String(a.name)) ?? 0;
-      const priorityB = this.pluginPriorities.get(String(b.name)) ?? 0;
-      return priorityB - priorityA;
-    });
-    for (const plugin of sortedPlugins) {
-      if (plugin.dependencies?.length) {
-        for (const dep of plugin.dependencies) {
-          const depPlugin = this.plugins.get(String(dep));
-          if (!depPlugin) {
-            throw new PergelError({
-              code: "PLUGIN_DEPENDENCY_MISSING",
-              message: `Plugin ${String(plugin.name)} depends on ${String(dep)} which is not registered`
-            });
-          }
-        }
-      }
-      try {
-        await plugin.setup?.(plugin.defaults || {}, this.silgi);
-        consola.success(`Plugin ${String(plugin.name)} setup completed`);
-        await this.silgi.silgi.callHook("plugin:setup:finish", {
-          plugin,
-          initSilgi: this.silgi
-        });
-      } catch (error) {
-        this.plugins.delete(String(plugin.name));
-        throw new PergelError({
-          code: "PLUGIN_SETUP_ERROR",
-          message: `Failed to setup plugin ${String(plugin.name)}`,
-          cause: error instanceof Error ? error : undefined
-        });
-      }
-    }
-  }
-  async runHook(hookName, context) {
-    const ctx = {
-      ...context
-    };
-    this.log(`Running hook: ${String(hookName)}`, {
-      scope: context?.scope ? String(context.scope) : undefined,
-      serviceName: context?.serviceName ? String(context.serviceName) : undefined,
-      methodName: context?.methodName
-    });
-    const sortedPlugins = [...this.plugins.values()].sort((a, b) => {
-      const priorityA = this.pluginPriorities.get(String(a.name)) ?? 0;
-      const priorityB = this.pluginPriorities.get(String(b.name)) ?? 0;
-      return priorityB - priorityA;
-    });
-    for (const plugin of sortedPlugins) {
-      await this.executePluginHook(plugin, hookName, ctx);
-    }
-  }
-  async executePluginHook(plugin, hookName, context) {
-    const pluginName = String(plugin.name);
-    try {
-      const hookIndex = this.silgi.silgi.hooksNames.indexOf(hookName);
-      if (hookIndex === -1)
-        return;
-      const service = context.serviceName && context.scope ? this.silgi.getService(context.scope, context.serviceName) : void 0;
-      if (!service)
-        return;
-      const methodName = context.methodName;
-      const methodPluginConfig = methodName ? service.methodPlugins?.[methodName]?.[pluginName] : void 0;
-      const servicePluginConfig = service.plugins?.[pluginName];
-      const shouldExecute = (() => {
-        if (methodPluginConfig?.active !== void 0)
-          return methodPluginConfig.active;
-        if (servicePluginConfig?.active !== void 0)
-          return servicePluginConfig.active;
-        return false;
-      })();
-      if (shouldExecute) {
-        const config = methodPluginConfig || servicePluginConfig || {};
-        try {
-          await this.silgi.silgi.callHook(hookName, {
-            ...context,
-            meta: config
-          });
-        } catch (error) {
-          throw new PergelError({
-            code: "PLUGIN_BLOCKED",
-            message: `Plugin ${pluginName} blocked execution of ${hookName} hook${error instanceof Error ? `: ${error.message}` : ""}`,
-            details: {
-              pluginName,
-              hookName,
-              methodName,
-              config
-            }
-          });
-        }
-      }
-    } catch (error) {
-      const errorContext = {
-        plugin: pluginName,
-        hook: hookName,
-        scope: context.scope ? String(context.scope) : undefined,
-        service: context.serviceName ? String(context.serviceName) : undefined,
-        method: context.methodName
-      };
-      this.log(`Plugin error in ${pluginName}.${String(hookName)}:`, {
-        ...errorContext,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      await this.handlePluginError(plugin, String(hookName), error, context);
-      throw error;
-    }
-  }
-  // New method for plugin error handling
-  async handlePluginError(plugin, hookName, error, context) {
-    try {
-      this.silgi.silgi.callHook("app:error", {
-        ...context,
-        error: error instanceof Error ? error : new Error(String(error)),
-        hookName
-      });
-    } catch (errorHandlingError) {
-      this.log(`Failed to handle error in plugin ${String(plugin.name)}`, errorHandlingError);
-    }
-  }
-  // Plugin'i ismine göre getir
-  async getPlugin(name) {
-    return this.plugins.get(name);
-  }
-  isPluginsRegistered() {
-    return this.plugins.size > 0;
-  }
-}
-
-const silgiCtx = getContext("silgi");
-function useShared() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Nuxt instance is unavailable!");
-  }
-  return instance.silgi.options.shared;
-}
-function useSilgi() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Nuxt instance is unavailable!");
-  }
-  return instance;
-}
-function useHook() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Nuxt instance is unavailable!");
-  }
-  return instance.silgi.hooks.hook;
-}
-
-const logger = consola.withTag("pergel");
-class InitSilgi {
-  silgi;
-  constructor(silgi) {
-    this.silgi = silgi;
-    this.silgi.options._cacheProvider = this.createCacheProvider(this.silgi.options.cache, this.silgi.options.shared);
-    this.silgi.options._pluginManager = new PluginManager(this);
-    this.silgi.options.shared = this.silgi.options.shared ?? {};
-    this.silgi.options._serviceRegistry = /* @__PURE__ */ new Map();
-    this.silgi.options.services.forEach((service) => {
-      const key = `${service.scope}:${service.name}`;
-      this.silgi.options._serviceRegistry.set(key, service);
-    });
-    if (silgiCtx.tryUse()) {
-      silgiCtx.unset();
-      silgiCtx.set(this);
-      logger.success("Silgi context replaced");
-    } else {
-      silgiCtx.set(this);
-      silgi.hook("close", () => silgiCtx.unset());
-    }
-    consola.info("Silgi initialized");
-  }
-  // Helper to create cache provider
-  createCacheProvider(cacheOptions, context) {
-    const options = cacheOptions ?? { type: "memory" };
-    if (options.provider) {
-      return typeof options.provider === "function" ? options.provider(context) : options.provider;
-    }
-    switch (options.type ?? "memory") {
-      case "file":
-        return new FileCacheProvider(options.options?.file);
-      case "memory":
-      default:
-        return new MemoryCacheProvider(options.options?.memory);
-    }
-  }
-  log(message, ...args) {
-    if (this.silgi.options.debug)
-      logger.log(message, ...args);
-  }
-  async use(plugin) {
-    const start = (/* @__PURE__ */ new Date()).getTime();
-    this.log("Registering plugins");
-    this.silgi.callHook("plugin:register:before", plugin);
-    const plugins = Array.isArray(plugin) ? plugin : [plugin];
-    await Promise.all(plugins.map((p) => this.silgi.options._pluginManager.register(p)));
-    await this.silgi.options._pluginManager.runSetupHook();
-    this.silgi.callHook("plugin:register:after", plugin);
-    this.log("Plugins registered successfully");
-    const finish = (/* @__PURE__ */ new Date()).getTime();
-    consola.withTag("silgi").info(`Plugins registered ${finish - start}ms`);
-  }
-  getService(scope, name) {
-    const key = `${String(scope)}:${String(name)}`;
-    const service = this.silgi.options._serviceRegistry.get(key);
-    if (!service) {
-      throw new PergelError({
-        code: "SERVICE_NOT_FOUND",
-        message: `Service ${String(name)} not found in scope ${String(scope)}`
-      });
-    }
-    return service;
-  }
-  listScopes() {
-    const scopes = /* @__PURE__ */ new Set();
-    for (const key of this.silgi.options._serviceRegistry.keys()) {
-      const [scope] = key.split(":");
-      scopes.add(scope);
-    }
-    return Array.from(scopes);
-  }
-  getScope(scope) {
-    const services = [];
-    for (const key of this.silgi.options._serviceRegistry.keys()) {
-      if (key.startsWith(`${String(scope)}:`)) {
-        const [, name] = key.split(":");
-        services.push(name);
-      }
-    }
-    return {
-      name: services,
-      scope: String(scope)
-    };
-  }
-  // Bunun yerine daha açıklayıcı metodlar ekliyoruz:
-  getScopeServices(scope) {
-    const services = [];
-    for (const [key, service] of this.silgi.options._serviceRegistry.entries()) {
-      if (key.startsWith(`${String(scope)}:`)) {
-        const [, name] = key.split(":");
-        services.push([name, service]);
-      }
-    }
-    return {
-      services: services.map(([name]) => name),
-      scope,
-      methods: services.reduce((acc, [name, service]) => ({
-        ...acc,
-        [String(name)]: Array.from(service.handlers.keys())
-      }), {})
-    };
-  }
-  getAllServices() {
-    const scopes = this.listScopes();
-    return scopes.reduce((acc, scope) => ({
-      ...acc,
-      [scope]: this.getScopeServices(scope)
-    }), {});
-  }
-  scope(scope, context) {
-    return {
-      service: (serviceName) => {
-        const service = this.getService(scope, serviceName);
-        return {
-          execute: (methodName, input) => {
-            return service.execute(methodName, input, {
-              initSilgi: this,
-              scope: String(scope),
-              serviceName: String(serviceName),
-              methodName: String(methodName),
-              requestContext: context
-            });
-          }
-        };
-      }
-    };
-  }
-  async getFromCache(key) {
-    return this.silgi.options._cacheProvider.get(key);
-  }
-  async setInCache(key, value, ttl) {
-    return this.silgi.options._cacheProvider.set(key, value, ttl);
-  }
-  // Add a method to access serviceRegistry entries
-  getServiceRegistryEntries() {
-    return Array.from(this.silgi.options._serviceRegistry.entries());
-  }
-  // New simpler scope method that just accepts context
-  createScope(context) {
-    this.silgi.callHook("request:context", context);
-    return (scope) => ({
-      service: (serviceName) => {
-        const service = this.getService(scope, serviceName);
-        return {
-          // Rename 'call' to 'execute'
-          execute: (methodName, input) => {
-            return service.execute(methodName, input, {
-              initSilgi: this,
-              scope: String(scope),
-              serviceName: String(serviceName),
-              methodName: String(methodName),
-              requestContext: context
-            });
-          }
-        };
-      }
-    });
-  }
-  setEvent(key, value) {
-    this.silgi.options._eventContext ??= /* @__PURE__ */ new Map();
-    this.silgi.options._eventContext.set(key, value);
-  }
-  getEvent(key) {
-    return this.silgi.options._eventContext?.get(key);
-  }
-  async buidApp() {
-    if (this.silgi.options.plugins && !this.silgi.options._pluginManager.isPluginsRegistered()) {
-      await this.use(this.silgi.options.plugins);
-    }
-  }
-  async addH3App(router) {
-    if (this.silgi.options.plugins && !this.silgi.options._pluginManager.isPluginsRegistered()) {
-      await this.use(this.silgi.options.plugins);
-    }
-    this.silgi.options.h3Router = router;
-    await this.silgi.callHook("h3:app:setup", router);
-  }
-}
-
-function toMethodIdentifier(value) {
-  return typeof value === "symbol" ? value : String(value);
-}
-function toServiceIdentifier(value) {
-  return String(value);
-}
-function toScopeIdentifier(value) {
-  return String(value);
-}
-async function generateCacheKey(params) {
-  const {
-    scope,
-    serviceName,
-    methodName,
-    input,
-    namespace,
-    keyGenerator,
-    requestId,
-    cacheOptions
-  } = params;
-  const scopePrefix = cacheOptions?.scope === "request" ? "req" : "global";
-  const parts = [
-    scopePrefix,
-    // Always include scope prefix first
-    namespace,
-    toScopeIdentifier(scope),
-    toServiceIdentifier(serviceName),
-    toMethodIdentifier(methodName)
-  ].filter(Boolean);
-  if (cacheOptions?.scope === "request") {
-    if (!requestId) {
-      throw new PergelError({
-        code: "CACHE_ERROR",
-        message: "Request ID is required for request-scoped cache"
-      });
-    }
-    parts.push(requestId);
-  }
-  if (keyGenerator) {
-    const customKey = await Promise.resolve(keyGenerator(input));
-    parts.push(customKey);
-  } else {
-    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
-  }
-  return parts.join(":");
-}
-function normalizeResult(result) {
-  if (Array.isArray(result)) {
-    return [...result];
-  }
-  if (result && typeof result === "object") {
-    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
-      return Object.values(result);
-    }
-    return { ...result };
-  }
-  return result;
-}
-function createServiceFactory() {
-  return {
-    scope(scope) {
-      return {
-        service(name, config) {
-          const methods = /* @__PURE__ */ new Map();
-          const servicePlugins = config?.plugins || {};
-          const methodPlugins = {};
-          return {
-            methods(methodsConfig) {
-              Object.entries(methodsConfig).forEach(([methodName, methodConfig]) => {
-                const typedConfig = methodConfig;
-                const methodPluginConfig = typedConfig.options?.plugins || {};
-                methodPlugins[methodName] = Object.entries(methodPluginConfig).reduce((acc, [pluginName, pluginConfig]) => {
-                  const accumulator = acc;
-                  if (typeof pluginConfig === "object" && pluginConfig !== null) {
-                    const servicePluginConf = servicePlugins[pluginName];
-                    accumulator[pluginName] = {
-                      ...typeof servicePluginConf === "object" ? servicePluginConf : {},
-                      ...pluginConfig,
-                      active: pluginConfig.active ?? servicePluginConf?.active ?? false
-                    };
-                  } else {
-                    accumulator[pluginName] = { active: false };
-                  }
-                  return accumulator;
-                }, {});
-                methods.set(toMethodIdentifier(methodName), {
-                  handler: typedConfig.handler,
-                  options: {
-                    ...typedConfig.options,
-                    cache: typedConfig.options?.cache ? {
-                      ttl: typedConfig.options.cache.ttl,
-                      scope: typedConfig.options.cache.scope || "request",
-                      key: typedConfig.options.cache.key,
-                      namespace: typedConfig.options.cache.namespace
-                    } : undefined,
-                    plugins: methodPlugins[methodName]
-                  }
-                });
-              });
-              const executor = {
-                scope: toScopeIdentifier(scope),
-                name: toServiceIdentifier(name),
-                handlers: methods,
-                plugins: servicePlugins,
-                methodPlugins,
-                execute: async (methodName, input, context) => {
-                  const handler = methods.get(toMethodIdentifier(methodName));
-                  if (!handler) {
-                    return {
-                      success: false,
-                      error: {
-                        code: "METHOD_NOT_FOUND",
-                        message: `Method ${String(methodName)} not found`
-                      }
-                    };
-                  }
-                  let success = false;
-                  let error;
-                  let result;
-                  const { initSilgi, requestContext } = context;
-                  if (!initSilgi) {
-                    throw new Error("Pergel instance must be provided in context");
-                  }
-                  const cacheKey = handler.options?.cache ? await generateCacheKey({
-                    scope: toScopeIdentifier(scope),
-                    serviceName: toServiceIdentifier(name),
-                    methodName: toMethodIdentifier(methodName),
-                    input,
-                    namespace: handler.options.cache.namespace,
-                    keyGenerator: handler.options.cache.key,
-                    cacheOptions: handler.options.cache,
-                    requestId: context.requestContext.requestId
-                  }) : null;
-                  try {
-                    if (cacheKey) {
-                      const cachedResult = await initSilgi.getFromCache(cacheKey);
-                      if (cachedResult !== null) {
-                        return {
-                          success: true,
-                          data: normalizeResult(result),
-                          cached: false
-                        };
-                      }
-                    }
-                    await initSilgi.silgi.options._pluginManager.runHook("service:beforeExecute", {
-                      scope,
-                      serviceName: String(name),
-                      methodName: String(methodName),
-                      input,
-                      requestContext,
-                      initSilgi,
-                      options: handler.options
-                    });
-                    result = await handler.handler(input, initSilgi.silgi.options.shared, context.requestContext);
-                    success = true;
-                    await initSilgi.silgi.options._pluginManager.runHook("service:afterExecute", {
-                      scope,
-                      serviceName: String(name),
-                      methodName: String(methodName),
-                      input,
-                      result,
-                      requestContext,
-                      initSilgi
-                    });
-                    if (success && cacheKey && handler.options?.cache) {
-                      await initSilgi.setInCache(cacheKey, result, handler.options.cache.ttl);
-                    }
-                    return { success: true, data: normalizeResult(result), cached: false };
-                  } catch (err) {
-                    initSilgi.silgi.logger.error(err);
-                    error = err instanceof Error ? err : new Error("Unknown error");
-                    if (error instanceof PergelError && error.code === "PLUGIN_BLOCKED") {
-                      return {
-                        success: false,
-                        error: {
-                          code: error.code,
-                          message: error.message,
-                          details: error.details
-                        }
-                      };
-                    }
-                    await initSilgi.silgi.options._pluginManager.runHook("app:error", {
-                      scope,
-                      serviceName: String(name),
-                      methodName: String(methodName),
-                      input,
-                      error,
-                      options: handler.options,
-                      timestamp: Date.now(),
-                      initSilgi
-                    });
-                    return {
-                      success: false,
-                      error: error instanceof PergelError ? {
-                        code: error.code,
-                        message: error.message,
-                        details: error.details
-                      } : {
-                        code: "EXECUTION_ERROR",
-                        message: error.message || String(error)
-                      }
-                    };
-                  } finally {
-                    await initSilgi.silgi.options._pluginManager.runHook("app:finalize", {
-                      scope,
-                      serviceName: String(name),
-                      methodName: String(methodName),
-                      input,
-                      result,
-                      success,
-                      error,
-                      requestContext,
-                      initSilgi
-                    });
-                  }
-                }
-              };
-              return executor;
-            }
-          };
-        }
-      };
-    }
-  };
-}
-function defineService() {
-  return createServiceFactory();
-}
-const version = "0.0.1";
-function createSilgi(options) {
-  const hooks = createHooks();
-  const silgi = {
-    _version: version,
-    options,
-    hooks,
-    hooksNames: [
-      "app:error",
-      "app:finalize",
-      "plugin:register:after",
-      "plugin:register:before",
-      "close",
-      "plugin:setup:finish",
-      "ready",
-      "request:context",
-      "service:afterExecute",
-      "service:beforeExecute"
-    ],
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    ready: () => {
-      return hooks.callHook("ready", silgi);
-    },
-    close: () => hooks.callHook("close", silgi),
-    logger: createConsola(options.consolaOptions),
-    h3Router: options.h3Router
-  };
-  if (!options.debug) {
-    silgi.logger.pauseLogs();
-  }
-  const createSilgi2 = new InitSilgi(silgi);
-  hooks.hookOnce("close", () => {
-    hooks.removeAllHooks();
-  });
-  return createSilgi2;
-}
-function defineSilgiPlugin(plugin) {
-  return (options) => {
-    const pluginWithDefaults = plugin;
-    pluginWithDefaults.defaults = {
-      ...plugin.defaults || {},
-      ...options
-    };
-    return pluginWithDefaults;
-  };
-}
-
-export { defineSilgiPlugin as a, useSilgi as b, createSilgi as c, defineService as d, useHook as e, silgiCtx as s, useShared as u };