silgi 0.43.16 → 0.43.18

package/dist/build.d.mts

@@ -1,3 +1,3 @@
-import { watchDev } from "./cli/build/dev.mjs";
-import { prepareBuild } from "./cli/build/prepare.mjs";
+import { watchDev$1 as watchDev } from "./cli/build/dev.mjs";
+import { prepareBuild$1 as prepareBuild } from "./cli/build/prepare.mjs";
 export { prepareBuild, watchDev };

package/dist/cli/build/dev.d.mts

@@ -1,9 +1,10 @@
 import { FSWatcher } from "chokidar";
 
 //#region src/cli/build/dev.d.ts
-declare function watchDev(): Promise<{
+interface WatchDevResult {
   watcher: FSWatcher | undefined;
   close: () => Promise<void>;
-}>;
+}
+declare function watchDev(): Promise<WatchDevResult>;
 //#endregion
-export { watchDev };
+export { watchDev as watchDev$1 };

package/dist/cli/build/dev.mjs

@@ -8,46 +8,27 @@ import { basename } from "pathe";
 import { debounce } from "perfect-debounce";
 
 //#region src/cli/build/dev.ts
+const WATCH_IGNORE_FILES = [
+	"scan",
+	"meta",
+	"core",
+	"configs"
+];
+const WATCH_IGNORE_EXTENSIONS = [
+	"ts",
+	"js",
+	"mjs",
+	"cjs",
+	"d.ts",
+	"d.mts",
+	"d.cts",
+	"d.js"
+];
 const IGNORED_WATCH_PATTERNS = [
 	"**/.silgi/**",
 	"**/.output/**",
 	"**/types/**",
-	"**/scan.ts",
-	"**/scan.js",
-	"**/scan.mjs",
-	"**/scan.cjs",
-	"**/scan.d.ts",
-	"**/scan.d.mts",
-	"**/scan.d.cts",
-	"**/scan.d.js",
-	"**/scan.d.ts",
-	"**/meta.ts",
-	"**/meta.js",
-	"**/meta.mjs",
-	"**/meta.cjs",
-	"**/meta.d.ts",
-	"**/meta.d.mts",
-	"**/meta.d.cts",
-	"**/meta.d.js",
-	"**/meta.d.ts",
-	"**/core.ts",
-	"**/core.js",
-	"**/core.mjs",
-	"**/core.cjs",
-	"**/core.d.ts",
-	"**/core.d.mts",
-	"**/core.d.cts",
-	"**/core.d.js",
-	"**/core.d.ts",
-	"**/configs.ts",
-	"**/configs.js",
-	"**/configs.mjs",
-	"**/configs.cjs",
-	"**/configs.d.ts",
-	"**/configs.d.mts",
-	"**/configs.d.cts",
-	"**/configs.d.js",
-	"**/configs.d.ts"
+	...WATCH_IGNORE_FILES.flatMap((file) => WATCH_IGNORE_EXTENSIONS.map((ext) => `**/${file}.${ext}`))
 ];
 function isIgnoredByPattern(path) {
 	return IGNORED_WATCH_PATTERNS.some((pattern) => micromatch.isMatch(path, pattern));
@@ -55,14 +36,24 @@ function isIgnoredByPattern(path) {
 async function watchDev() {
 	const silgi = useSilgiCLI();
 	let watcher;
+	const changedFiles = new Set();
 	async function load() {
+		const startTime = performance.now();
+		if (changedFiles.size > 0) {
+			const fileList = Array.from(changedFiles).map((f) => basename(f)).join(", ");
+			consola.info(`Rebuilding: ${fileList}`);
+			changedFiles.clear();
+		}
 		await prepareBuild({
 			commandType: "prepare",
 			activeEnvironment: silgi.options.activeEnvironment || ".env",
 			dev: true
 		});
+		const endTime = performance.now();
+		const elapsedTime = Math.round(endTime - startTime);
+		silgi.logger.success(`Build completed in ${elapsedTime}ms`);
 	}
-	const reload = debounce(load);
+	const reload = debounce(load, 300);
 	const watchReloadEvents = new Set([
 		"add",
 		"addDir",
@@ -72,22 +63,17 @@ async function watchDev() {
 	]);
 	if (silgi.options.devServer.watch.length > 0) {
 		silgi.options.devServer.watch = [...new Set(silgi.options.devServer.watch)].filter((p) => !isIgnoredByPattern(p));
-		consola.info("[silgi] Watching files/directories:", silgi.options.devServer.watch);
+		consola.info(`[silgi] Watching ${silgi.options.devServer.watch.length} paths for changes`);
 		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 = [];
+			changedFiles.add(path);
 			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);
 		});

package/dist/cli/build/prepare.d.mts

@@ -3,4 +3,4 @@ import { SilgiCLI, SilgiCLIConfig } from "silgi/types";
 //#region src/cli/build/prepare.d.ts
 declare function prepareBuild(config?: SilgiCLIConfig): Promise<SilgiCLI>;
 //#endregion
-export { prepareBuild };
+export { prepareBuild as prepareBuild$1 };

package/dist/cli/commands/init.mjs

@@ -45,7 +45,7 @@ const command = defineCommand({
 			"",
 			"export default defineSilgiConfig({",
 			`  preset: '${framework}',`,
-			`  compatibilityDate: '${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}',`,
+			`  compatibilityDate: '${new Date().toISOString().split("T")[0]}',`,
 			"",
 			"})",
 			""

package/dist/cli/commands/run.mjs

@@ -1,74 +1,23 @@
-import { watchDev } from "../build/dev.mjs";
-import { commonArgs } from "../utils/common.mjs";
-import prepare_default from "./prepare.mjs";
+import watch_default from "./watch.mjs";
 import consola from "consola";
 import { version } from "silgi/meta";
 import { runCommand } from "citty";
-import { execa } from "execa";
 
 //#region src/cli/commands/run.ts
 const command = {
 	meta: {
-		name: "dev",
-		description: "Start the development server for the project",
+		name: "run",
+		description: "[DEPRECATED] Use \"silgi watch <command>\" instead",
 		version
 	},
-	args: {
-		...commonArgs,
-		command: {
-			type: "string",
-			description: "your application start command",
-			required: false
-		}
-	},
-	async run({ args, rawArgs }) {
-		await runCommand(prepare_default, { rawArgs: [
-			"--commandType",
-			"dev",
-			"--dev",
-			"true"
-		] });
-		const startCommand = args.command || rawArgs[0];
-		let childProcess = null;
-		let watcher = null;
-		let exiting = false;
-		const cleanupAndExit = async (code = 0) => {
-			if (exiting) return;
-			exiting = true;
-			try {
-				if (watcher?.close) await watcher.close().catch(() => {});
-				if (childProcess) childProcess.kill("SIGTERM");
-			} catch {}
-			process.exit(code);
-		};
-		const handleSignal = (signal) => {
-			consola.info(`Received ${signal}, terminating...`);
-			cleanupAndExit(0);
-		};
-		process.on("SIGINT", handleSignal);
-		process.on("SIGTERM", handleSignal);
-		process.on("SIGHUP", handleSignal);
-		try {
-			watcher = await watchDev();
-			consola.info(`Starting: nr ${startCommand}`);
-			childProcess = execa("nr", [startCommand], {
-				stdio: "inherit",
-				cwd: process.cwd()
-			});
-			childProcess.on("exit", (code) => {
-				if (code !== 0) consola.error(`Process exited with code ${code}`);
-				else consola.success("Process exited successfully.");
-				cleanupAndExit(code ?? 0);
-			});
-			childProcess.on("error", (err) => {
-				consola.error("Child process error:", err);
-				cleanupAndExit(1);
-			});
-			await childProcess;
-		} catch (error) {
-			consola.error("Error:", error);
-			cleanupAndExit(1);
-		}
+	args: { command: {
+		type: "string",
+		description: "your application start command",
+		required: false
+	} },
+	async run({ rawArgs }) {
+		consola.warn("The \"run\" command is deprecated. Please use \"silgi watch <command>\" instead.");
+		return runCommand(watch_default, { rawArgs });
 	}
 };
 var run_default = command;

package/dist/cli/commands/watch.mjs

@@ -4,6 +4,9 @@ import prepare_default from "./prepare.mjs";
 import consola from "consola";
 import { version } from "silgi/meta";
 import { defineCommand, runCommand } from "citty";
+import { execa } from "execa";
+import psTree from "ps-tree";
+import treeKill from "tree-kill";
 
 //#region src/cli/commands/watch.ts
 const command = defineCommand({
@@ -21,9 +24,14 @@ const command = defineCommand({
 		stub: {
 			type: "boolean",
 			description: "Run in silgi development mode"
+		},
+		command: {
+			type: "string",
+			description: "Optional command to run alongside watch (e.g., \"npm run dev\")",
+			required: false
 		}
 	},
-	async run() {
+	async run({ args, rawArgs }) {
 		await runCommand(prepare_default, { rawArgs: [
 			"--commandType",
 			"dev",
@@ -31,15 +39,89 @@ const command = defineCommand({
 			"true"
 		] });
 		const watch = await watchDev();
-		process.on("SIGINT", async () => {
-			consola.withTag("silgi").info("Shutting down...");
-			if (watch) watch.close();
-			await watch.close();
+		const userCommand = args.command || rawArgs[0];
+		let childProcess = null;
+		if (userCommand) {
+			consola.withTag("silgi").info(`Starting: ${userCommand}`);
+			const [cmd, ...cmdArgs] = userCommand.split(" ");
+			if (!cmd) {
+				consola.error("Invalid command provided");
+				process.exit(1);
+			}
+			childProcess = execa(cmd, cmdArgs, {
+				stdio: "inherit",
+				cwd: process.cwd(),
+				cleanup: true,
+				detached: false
+			});
+			childProcess.on("exit", (code) => {
+				if (code !== 0) consola.error(`Process exited with code ${code}`);
+				process.exit(code ?? 0);
+			});
+			childProcess.on("error", (err) => {
+				consola.error("Child process error:", err);
+				process.exit(1);
+			});
+		}
+		let isShuttingDown = false;
+		const shutdown = async (signal) => {
+			if (isShuttingDown) return;
+			isShuttingDown = true;
+			consola.withTag("silgi").info(`Received ${signal}, shutting down...`);
+			try {
+				if (childProcess && childProcess.pid) {
+					const children = await new Promise((resolve) => {
+						psTree(childProcess.pid, (err, children$1) => {
+							if (err) resolve([]);
+							else resolve(children$1);
+						});
+					});
+					if (children.length > 0) {
+						consola.info("Terminating process tree:");
+						children.forEach((child) => {
+							consola.info(`  - ${child.COMMAND} (PID: ${child.PID})`);
+						});
+					}
+					const processCount = children.length + 1;
+					consola.info(`Terminating ${processCount} processes...`);
+					await new Promise((resolve) => {
+						treeKill(childProcess.pid, "SIGTERM", (err) => {
+							if (err) consola.withTag("silgi").error("Error killing process tree:", err);
+							resolve();
+						});
+					});
+					await new Promise((resolve) => setTimeout(resolve, 2e3));
+					if (childProcess.pid) try {
+						treeKill(childProcess.pid, "SIGKILL");
+					} catch {}
+				}
+				if (watch?.close) await watch.close();
+				consola.success("All processes terminated successfully");
+			} catch (error) {
+				consola.withTag("silgi").error("Error during shutdown:", error);
+			}
 			process.exit(0);
+		};
+		process.on("SIGINT", () => shutdown("SIGINT"));
+		process.on("SIGTERM", () => shutdown("SIGTERM"));
+		process.on("SIGHUP", () => shutdown("SIGHUP"));
+		process.on("SIGQUIT", () => shutdown("SIGQUIT"));
+		process.on("exit", () => {
+			if (childProcess && childProcess.pid) try {
+				treeKill(childProcess.pid, "SIGKILL");
+			} catch {}
+		});
+		process.on("uncaughtException", (error) => {
+			consola.withTag("silgi").error("Uncaught exception:", error);
+			shutdown("uncaughtException");
+		});
+		process.on("unhandledRejection", (reason, promise) => {
+			consola.withTag("silgi").error("Unhandled rejection at:", promise, "reason:", reason);
+			shutdown("unhandledRejection");
 		});
 		consola.withTag("silgi").success("Prepare completed");
 		consola.withTag("silgi").info("Process is still running. Press Ctrl+C to exit.");
-		setInterval(() => {}, 1e3);
+		if (!childProcess) await new Promise(() => {});
 	}
 });
 var watch_default = command;

package/dist/cli/config/index.d.mts

@@ -1,3 +1,3 @@
-import { loadOptions } from "./loader.mjs";
-import { silgiGenerateType } from "./types.mjs";
+import { loadOptions$1 as loadOptions } from "./loader.mjs";
+import { silgiGenerateType$1 as silgiGenerateType } from "./types.mjs";
 export { loadOptions, silgiGenerateType };

package/dist/cli/config/loader.d.mts

@@ -3,4 +3,4 @@ import { LoadConfigOptions, SilgiCLIConfig, SilgiCLIOptions } from "silgi/types"
 //#region src/cli/config/loader.d.ts
 declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
 //#endregion
-export { loadOptions };
+export { loadOptions as loadOptions$1 };

package/dist/cli/config/resolvers/compatibility.mjs

@@ -12,7 +12,7 @@ async function resolveCompatibilityOptions(options) {
 let _fallbackInfoShown = false;
 let _promptedUserToUpdate = false;
 async function _resolveDefault(options) {
-	const _todayDate = formatDate(/* @__PURE__ */ new Date());
+	const _todayDate = formatDate(new Date());
 	const consola$2 = consola.withTag("silgi");
 	consola$2.warn(`No valid compatibility date is specified.`);
 	const onFallback = () => {

package/dist/cli/config/types.d.mts

@@ -11,4 +11,4 @@ declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
   tsConfig: TSConfig;
 }>;
 //#endregion
-export { silgiGenerateType };
+export { silgiGenerateType as silgiGenerateType$1 };

package/dist/cli/core/apiful.mjs

@@ -12,7 +12,7 @@ async function generateApiFul(silgi) {
 	}
 	if (!config.services || hasSilgiModule("openapi")) {
 		config.services ??= {};
-		config.services = { silgi: { schema: join(silgi.options.build.dir, "openapi.json") } };
+		config.services.silgi = { schema: join(silgi.options.build.dir, "openapi.json") };
 	}
 	const resolvedOpenAPIServices = Object.fromEntries(Object.entries(config?.services ?? {}).filter(([, service]) => Boolean(service.schema)));
 	if (Object.keys(resolvedOpenAPIServices).length === 0) {

package/dist/cli/core/app.mjs

@@ -42,7 +42,7 @@ async function generateApp(app, options = {}) {
 	}
 	const templateContext = { app };
 	const writes = [];
-	const dirs = /* @__PURE__ */ new Set();
+	const dirs = new Set();
 	const changedTemplates = [];
 	async function processTemplate(template) {
 		let dir;

package/dist/cli/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import package_default from "../package.mjs";
+import { package_default } from "../package.mjs";
 import { defineCommand, runMain } from "citty";
 
 //#region src/cli/index.ts

package/dist/cli/module/install.mjs

@@ -1,4 +1,4 @@
-import { hasInstalledModule } from "../utils/compatibility.mjs";
+import { hasInstalledModule$1 as hasInstalledModule } from "../utils/compatibility.mjs";
 import { useSilgiCLI } from "silgi";
 import { createJiti } from "dev-jiti";
 

package/dist/cli/module/scan.mjs

@@ -103,12 +103,12 @@ async function scanModules(silgi) {
 	silgi.scanModules = modules;
 }
 function createDependencyGraph(modules) {
-	const graph = /* @__PURE__ */ new Map();
-	const inDegree = /* @__PURE__ */ new Map();
+	const graph = new Map();
+	const inDegree = new Map();
 	modules.forEach((module) => {
 		const key = module.meta?.configKey;
 		if (key) {
-			graph.set(key, /* @__PURE__ */ new Set());
+			graph.set(key, new Set());
 			inDegree.set(key, 0);
 		}
 	});
@@ -118,7 +118,7 @@ function createDependencyGraph(modules) {
 		const requiredDeps = module.meta?.requiredDependencies || [];
 		const beforeDeps = module.meta?.beforeDependencies || [];
 		const afterDeps = module.meta?.afterDependencies || [];
-		const processedDeps = /* @__PURE__ */ new Set();
+		const processedDeps = new Set();
 		requiredDeps.forEach((dep) => {
 			if (!graph.has(dep)) throw new Error(`Required dependency "${dep}" for module "${key}" is missing`);
 			graph.get(dep)?.add(key);
@@ -143,8 +143,8 @@ function createDependencyGraph(modules) {
 	};
 }
 function findCyclicDependencies(graph) {
-	const visited = /* @__PURE__ */ new Set();
-	const recursionStack = /* @__PURE__ */ new Set();
+	const visited = new Set();
+	const recursionStack = new Set();
 	const cycles = [];
 	function dfs(node, path = []) {
 		visited.add(node);

package/dist/cli/scan/prepareCommands.mjs

@@ -19,7 +19,7 @@ async function prepareCommands(silgi = useSilgiCLI()) {
 				if (command.tags) command.tags.forEach((tag) => acc.add(tag));
 			});
 			return acc;
-		}, /* @__PURE__ */ new Set());
+		}, new Set());
 		const data = [
 			genAugmentation("silgi/types", { SilgiCommands: { ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"])) } }),
 			"",

package/dist/cli/scan/scanExportFile.mjs

@@ -152,7 +152,7 @@ async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNam
 	const exportEntities = [];
 	const fileContent = await readFile(absoluteFilePath, "utf-8");
 	const parsed = await parseAsync(absoluteFilePath, fileContent);
-	const variableDeclarations = /* @__PURE__ */ new Map();
+	const variableDeclarations = new Map();
 	for (const node of parsed.program.body) {
 		if (node.type === "VariableDeclaration" && Array.isArray(node.declarations)) {
 			for (const decl of node.declarations) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier") variableDeclarations.set(decl.id.name, decl);
@@ -224,7 +224,7 @@ async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNam
 	return exportEntities;
 }
 async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
-	const processedFilePaths = /* @__PURE__ */ new Set();
+	const processedFilePaths = new Set();
 	const alreadyScannedPaths = [];
 	const serverDirectory = path || silgiInstance.options.serverDir;
 	const functionExportNames = scanOptions.functionExportNames ?? DEFAULT_FUNCTION_EXPORT_NAMES;
@@ -263,7 +263,7 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
 			if (!silgiInstance.options.extensions?.includes(fileExtension)) continue;
 			try {
 				const exportEntities = await extractExportEntitiesFromFile(absoluteFilePath, functionExportNames, interfaceExtendsNames);
-				const seenServiceSignatures = /* @__PURE__ */ new Map();
+				const seenServiceSignatures = new Map();
 				for (const entity of exportEntities) if ((entity.funcName === "createService" || entity.funcName === "createWebSocket") && entity.servicePath && entity.serviceMethod) {
 					const key = `${entity.serviceMethod}:${entity.servicePath}`;
 					if (seenServiceSignatures.has(key)) throw new Error(`Duplicate ${entity.funcName} detected for path "${entity.servicePath}" and method "${entity.serviceMethod}".\nFirst found in: ${seenServiceSignatures.get(key)}\nDuplicate in: ${absoluteFilePath}\nPlease ensure each service path/method combination is unique.`);

package/dist/cli/scan/writeTypesAndFiles.mjs

@@ -24,7 +24,7 @@ async function writeTypesAndFiles(silgi) {
 		await silgi.unimport.init();
 		const allImports = await silgi.unimport.getImports();
 		autoImportExports = toExports(allImports).replace(/#internal\/nitro/g, relative(typesDir, runtimeDir));
-		const resolvedImportPathMap = /* @__PURE__ */ new Map();
+		const resolvedImportPathMap = new Map();
 		for (const i of allImports.filter((i$1) => !i$1.type)) {
 			if (resolvedImportPathMap.has(i.from)) continue;
 			let path = resolveAlias$1(i.from, silgi.options.alias);

package/dist/cli/utils/compatibility.mjs

@@ -30,4 +30,4 @@ function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
 }
 
 //#endregion
-export { checkSilgiCompatibility, hasInstalledModule };
+export { checkSilgiCompatibility, hasInstalledModule as hasInstalledModule$1 };

package/dist/core/context.d.mts

@@ -27,4 +27,4 @@ declare function useRuntime(): SilgiRuntimeConfig;
 * ```
 */
 //#endregion
-export { updateRuntimeStorage, useRuntime };
+export { updateRuntimeStorage as updateRuntimeStorage$1, useRuntime as useRuntime$1 };

package/dist/core/createSilgi.d.mts

@@ -3,4 +3,4 @@ import { Silgi, SilgiConfig } from "silgi/types";
 //#region src/core/createSilgi.d.ts
 declare function createSilgi(config: SilgiConfig): Promise<Silgi>;
 //#endregion
-export { createSilgi };
+export { createSilgi as createSilgi$1 };

package/dist/core/error.d.mts

@@ -62,4 +62,4 @@ declare function createError<DataT = unknown>(input: string | (Partial<SilgiErro
 */
 declare function isError<DataT = unknown>(input: any): input is SilgiError<DataT>;
 //#endregion
-export { SilgiError, createError, isError };
+export { SilgiError as SilgiError$1, createError as createError$1, isError as isError$1 };

package/dist/core/event.d.mts

@@ -23,4 +23,4 @@ declare class SilgiEventResponse {
   get headers(): Headers;
 }
 //#endregion
-export { SilgiHttpEvent };
+export { SilgiHttpEvent as SilgiHttpEvent$1 };

package/dist/core/index.d.mts

@@ -1,22 +1,22 @@
-import { updateRuntimeStorage, useRuntime } from "./context.mjs";
-import { createSilgi } from "./createSilgi.mjs";
-import { SilgiError, createError, isError } from "./error.mjs";
-import { SilgiHttpEvent } from "./event.mjs";
-import { handleResponse, kHandled, kNotFound } from "./response.mjs";
-import { getWebsocket, handler, middleware, silgiFetch } from "./silgi.mjs";
-import { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI } from "./silgiApp.mjs";
-import { storageMount } from "./storage.mjs";
-import { silgiCtx, tryUseSilgi, useSilgi } from "./unctx.mjs";
-import { createEventStream } from "./utils/event-stream.mjs";
-import { getEvent, getEventContext } from "./utils/event.mjs";
-import { deepMergeObjects } from "./utils/merge.mjs";
-import { createMiddleware } from "./utils/middleware.mjs";
-import { createResolver, getUrlPrefix } from "./utils/resolver.mjs";
-import { replaceRuntimeValues } from "./utils/runtime.mjs";
-import { createSchema } from "./utils/schema.mjs";
-import { createService, createWebSocket, defineServiceSetup } from "./utils/service.mjs";
-import { createShared } from "./utils/shared.mjs";
-import { createStorage, useSilgiStorage } from "./utils/storage.mjs";
+import { updateRuntimeStorage$1 as updateRuntimeStorage, useRuntime$1 as useRuntime } from "./context.mjs";
+import { createSilgi$1 as createSilgi } from "./createSilgi.mjs";
+import { SilgiError$1 as SilgiError, createError$1 as createError, isError$1 as isError } from "./error.mjs";
+import { SilgiHttpEvent$1 as SilgiHttpEvent } from "./event.mjs";
+import { handleResponse$1 as handleResponse, kHandled$1 as kHandled, kNotFound$1 as kNotFound } from "./response.mjs";
+import { getWebsocket$1 as getWebsocket, handler$1 as handler, middleware$1 as middleware, silgiFetch$1 as silgiFetch } from "./silgi.mjs";
+import { silgiCLICtx$1 as silgiCLICtx, tryUseSilgiCLI$1 as tryUseSilgiCLI, useSilgiCLI$1 as useSilgiCLI } from "./silgiApp.mjs";
+import { storageMount$1 as storageMount } from "./storage.mjs";
+import { silgiCtx$1 as silgiCtx, tryUseSilgi$1 as tryUseSilgi, useSilgi$1 as useSilgi } from "./unctx.mjs";
+import { createEventStream$1 as createEventStream } from "./utils/event-stream.mjs";
+import { getEvent$1 as getEvent, getEventContext$1 as getEventContext } from "./utils/event.mjs";
+import { deepMergeObjects$1 as deepMergeObjects } from "./utils/merge.mjs";
+import { createMiddleware$1 as createMiddleware } from "./utils/middleware.mjs";
+import { createResolver$3 as createResolver, getUrlPrefix$1 as getUrlPrefix } from "./utils/resolver.mjs";
+import { replaceRuntimeValues$1 as replaceRuntimeValues } from "./utils/runtime.mjs";
+import { createSchema$1 as createSchema } from "./utils/schema.mjs";
+import { createService$1 as createService, createWebSocket$1 as createWebSocket, defineServiceSetup$1 as defineServiceSetup } from "./utils/service.mjs";
+import { createShared$1 as createShared } from "./utils/shared.mjs";
+import { createStorage$1 as createStorage, useSilgiStorage$1 as useSilgiStorage } from "./utils/storage.mjs";
 
 //#region src/core/index.d.ts
 // TODO: bunlari yinede destekle.

package/dist/core/response.d.mts

@@ -1,4 +1,4 @@
-import { SilgiError } from "./error.mjs";
+import { SilgiError$1 as SilgiError } from "./error.mjs";
 import { SilgiEvent } from "silgi/types";
 
 //#region src/core/response.d.ts
@@ -17,4 +17,4 @@ declare const kNotFound: symbol;
 declare const kHandled: symbol;
 declare function handleResponse(val: unknown, event: SilgiEvent, config: SilgiHandlerConfig): Response | Promise<Response>;
 //#endregion
-export { handleResponse, kHandled, kNotFound };
+export { handleResponse as handleResponse$1, kHandled as kHandled$1, kNotFound as kNotFound$1 };

package/dist/core/silgi.d.mts

@@ -16,4 +16,4 @@ declare function middleware(event: SilgiEvent): Promise<any>;
 declare function handler(event: SilgiEvent): Promise<any>;
 declare function getWebsocket(silgi?: Silgi): WebSocketOptions;
 //#endregion
-export { getWebsocket, handler, middleware, silgiFetch };
+export { getWebsocket as getWebsocket$1, handler as handler$1, middleware as middleware$1, silgiFetch as silgiFetch$1 };

package/dist/core/silgiApp.d.mts

@@ -6,4 +6,4 @@ declare const silgiCLICtx: UseContext<SilgiCLI>;
 declare function useSilgiCLI(): SilgiCLI;
 declare function tryUseSilgiCLI(): SilgiCLI | null;
 //#endregion
-export { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI };
+export { silgiCLICtx as silgiCLICtx$1, tryUseSilgiCLI as tryUseSilgiCLI$1, useSilgiCLI as useSilgiCLI$1 };

package/dist/core/storage.d.mts

@@ -4,4 +4,4 @@ import { Silgi, SilgiStorageBase } from "silgi/types";
 //#region src/core/storage.d.ts
 declare function storageMount<T extends Storage = Storage>(silgi?: Silgi): (base: keyof SilgiStorageBase, driver: Parameters<Storage["mount"]>[1]) => T;
 //#endregion
-export { storageMount };
+export { storageMount as storageMount$1 };

package/dist/core/unctx.d.mts

@@ -18,4 +18,4 @@ declare function useSilgi(): Silgi;
 */
 declare function tryUseSilgi(): Silgi | null;
 //#endregion
-export { silgiCtx, tryUseSilgi, useSilgi };
+export { silgiCtx as silgiCtx$1, tryUseSilgi as tryUseSilgi$1, useSilgi as useSilgi$1 };

package/dist/core/utils/event-stream.d.mts

@@ -1,4 +1,4 @@
-import { EventStream } from "./internal/event-stream.mjs";
+import { EventStream$1 as EventStream } from "./internal/event-stream.mjs";
 import { SilgiEvent } from "silgi/types";
 
 //#region src/core/utils/event-stream.d.ts
@@ -50,4 +50,4 @@ interface EventStreamMessage {
 */
 declare function createEventStream(event: SilgiEvent, opts?: EventStreamOptions): EventStream;
 //#endregion
-export { EventStreamMessage, EventStreamOptions, createEventStream };
+export { EventStreamMessage, EventStreamOptions, createEventStream as createEventStream$1 };