silgi 0.42.5 → 0.43.0

package/dist/cli/framework/emptyFramework.mjs

@@ -0,0 +1,7 @@
+//#region src/cli/framework/emptyFramework.ts
+async function emptyFramework(silgi) {
+	if (silgi.options.preset === "npm-package" || !silgi.options.preset) {}
+}
+
+//#endregion
+export { emptyFramework };

package/dist/cli/framework/h3.mjs

@@ -0,0 +1,55 @@
+import { addCoreFile, addTemplate, isPresents } from "silgi/kit";
+
+//#region src/cli/framework/h3.ts
+async function h3Framework(silgi, skip = false) {
+	if (!isPresents(["h3"]) && skip === false) return;
+	silgi.hook("before:schema.ts", (data) => {
+		data.addImportItemType([{
+			imports: [{ name: "H3Event" }],
+			specifier: "h3"
+		}, {
+			imports: [{ name: "NitroApp" }],
+			specifier: "nitropack/types"
+		}]);
+	});
+	silgi.hook("prepare:types", (opts) => {
+		addTemplate({
+			filename: "types/h3.d.ts",
+			where: ".silgi",
+			getContents: () => {
+				return [
+					"import type { SilgiRuntimeContext } from 'silgi/types'",
+					"",
+					"declare module \"h3\" {",
+					"  interface H3EventContext extends SilgiRuntimeContext {}",
+					"}",
+					""
+				].join("\n");
+			}
+		});
+		opts.references.push({ path: "./h3.d.ts" });
+	});
+	addCoreFile({ before: ({ silgiConfigs }) => {
+		silgiConfigs.push({ captureError: `(silgi, error, context = {}) => {
+          const promise = silgi.hooks
+            .callHookParallel('error', silgi, error, context)
+            .catch((error_) => {
+              console.error('Error while capturing another error', error_)
+            })
+    
+          if (context.event && isEvent(context.event)) {
+            const errors = context.event.context.nitro?.errors
+            if (errors) {
+              errors.push({ error, context })
+            }
+            if (context.event.waitUntil) {
+              context.event.waitUntil(promise)
+            }
+          }
+        }` });
+	} });
+	if (silgi.options.imports !== false) silgi.options.imports.presets ??= [];
+}
+
+//#endregion
+export { h3Framework };

package/dist/cli/framework/index.mjs

@@ -0,0 +1,15 @@
+import { emptyFramework } from "./emptyFramework.mjs";
+import { h3Framework } from "./h3.mjs";
+import { nitroFramework } from "./nitro.mjs";
+import { nuxtFramework } from "./nuxt.mjs";
+
+//#region src/cli/framework/index.ts
+const frameworkSetup = [
+	emptyFramework,
+	h3Framework,
+	nitroFramework,
+	nuxtFramework
+];
+
+//#endregion
+export { frameworkSetup };

package/dist/cli/framework/nitro.mjs

@@ -0,0 +1,24 @@
+import { h3Framework } from "./h3.mjs";
+import { join } from "pathe";
+import { isPresents } from "silgi/kit";
+import { runtimeDir } from "silgi/runtime/meta";
+
+//#region src/cli/framework/nitro.ts
+async function nitroFramework(silgi, skip = false) {
+	if (!isPresents(["nitro"]) && skip === false) return;
+	silgi.hook("before:schema.ts", (data) => {
+		data.addImportItemType({
+			imports: [{ name: "NitroApp" }],
+			specifier: "nitropack/types"
+		});
+	});
+	silgi.options.plugins.push({
+		packageImport: "silgi/runtime/internal/nitro",
+		path: join(runtimeDir, "internal/nitro")
+	});
+	if (silgi.options.imports !== false) silgi.options.imports.presets ??= [];
+	await h3Framework(silgi, true);
+}
+
+//#endregion
+export { nitroFramework };

package/dist/cli/framework/nuxt.mjs

@@ -0,0 +1,10 @@
+import { nitroFramework } from "./nitro.mjs";
+
+//#region src/cli/framework/nuxt.ts
+async function nuxtFramework(silgi, skip = false) {
+	if (silgi.options.preset !== "nuxt" && skip === false) return;
+	await nitroFramework(silgi, true);
+}
+
+//#endregion
+export { nuxtFramework };

package/dist/cli/index.d.mts

@@ -1 +1 @@
-
+export { };

package/dist/cli/index.mjs

@@ -1,32 +1,29 @@
 #!/usr/bin/env node
-import { defineCommand, runMain } from 'citty';
-
-const version = "0.42.5";
-const packageJson = {
-	version: version};
+import { package_default } from "../package.mjs";
+import { defineCommand, runMain } from "citty";
 
+//#region src/cli/index.ts
 const main = defineCommand({
-  meta: {
-    name: "Silgi",
-    version: packageJson.version,
-    description: "Silgi CLI"
-  },
-  args: {
-    version: {
-      alias: "v",
-      description: "Show version"
-    }
-  },
-  subCommands: {
-    prepare: () => import('./prepare.mjs').then(function (n) { return n.p; }).then((m) => m.default),
-    init: () => import('./init.mjs').then((m) => m.default),
-    commands: () => import('./prepare.mjs').then(function (n) { return n.b; }).then((m) => m.default),
-    install: () => import('./install.mjs').then((m) => m.default),
-    watch: () => import('./watch.mjs').then((m) => m.default),
-    reset: () => import('./reset.mjs').then((m) => m.default),
-    run: () => import('./run.mjs').then((m) => m.default)
-  },
-  run() {
-  }
+	meta: {
+		name: "Silgi",
+		version: package_default.version,
+		description: "Silgi CLI"
+	},
+	args: { version: {
+		alias: "v",
+		description: "Show version"
+	} },
+	subCommands: {
+		prepare: () => import("./commands/prepare.mjs").then((m) => m.default),
+		init: () => import("./commands/init.mjs").then((m) => m.default),
+		commands: () => import("./commands/commands.mjs").then((m) => m.default),
+		install: () => import("./commands/install.mjs").then((m) => m.default),
+		watch: () => import("./commands/watch.mjs").then((m) => m.default),
+		reset: () => import("./commands/reset.mjs").then((m) => m.default),
+		run: () => import("./commands/run.mjs").then((m) => m.default)
+	},
+	run() {}
 });
 runMain(main);
+
+//#endregion

package/dist/cli/module/exportScan.mjs

@@ -0,0 +1,180 @@
+import { hash, relativeWithDot } from "silgi/kit";
+import { promises } from "node:fs";
+import { findExports, findTypeExports } from "mlly";
+import { dirname, join } from "node:path";
+
+//#region src/cli/module/exportScan.ts
+async function registerModuleExportScan(silgi) {
+	silgi.hook("before:schema.ts", async (options) => {
+		for (const module of silgi.scanModules) {
+			const moduleReExports = [];
+			if (!module.entryPath) continue;
+			const path = module.meta._packageName ? join(dirname(module.entryPath), "types/index.d.mts") : join(dirname(module.entryPath), "types/index.ts");
+			const moduleTypes = await promises.readFile(path, "utf8").catch(() => "");
+			const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
+			for (const e of findTypeExports(normalisedModuleTypes)) moduleReExports.push(e);
+			for (const e of findExports(normalisedModuleTypes)) moduleReExports.push(e);
+			const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
+			const configKey = module.meta.configKey;
+			const moduleName = module.meta.name || module.meta._packageName;
+			const specifier = module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, join(dirname(module.entryPath), "types/index"));
+			if (hasTypeExport("ModuleOptions")) {
+				const importName = hash(`${configKey}ModuleOptions`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleOptions"
+					}],
+					specifier
+				});
+				options.options.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleRuntimeOptions")) {
+				const importName = hash(`${configKey}ModuleRuntimeOptions`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleRuntimeOptions"
+					}],
+					specifier
+				});
+				options.runtimeOptions.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleRuntimeShareds")) {
+				const importName = hash(`${configKey}ModuleRuntimeShareds`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleRuntimeShareds"
+					}],
+					specifier
+				});
+				options.shareds.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleEvents")) {
+				const importName = hash(`${configKey}ModuleEvents`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleEvents"
+					}],
+					specifier
+				});
+				options.events.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleRuntimeContexts")) {
+				const importName = hash(`${configKey}ModuleRuntimeContexts`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleRuntimeContexts"
+					}],
+					specifier
+				});
+				options.contexts.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleHooks")) {
+				const importName = hash(`${configKey}ModuleHooks`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleHooks"
+					}],
+					specifier
+				});
+				options.hooks.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleRuntimeHooks")) {
+				const importName = hash(`${configKey}RuntimeHooks`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleRuntimeHooks"
+					}],
+					specifier
+				});
+				options.runtimeHooks.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("SetupModuleOption")) {
+				const importName = hash(`${configKey}SetupModuleOption`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "SetupModuleOption"
+					}],
+					specifier
+				});
+				options.setupModuleOption.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("ModuleRuntimeMethods")) {
+				const importName = hash(`${configKey}ModuleRuntimeMethods`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "ModuleRuntimeMethods"
+					}],
+					specifier
+				});
+				options.methods.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("RouteRules")) {
+				const importName = hash(`${configKey}RouteRules`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "RouteRules"
+					}],
+					specifier
+				});
+				options.routeRules.push({
+					key: configKey,
+					value: importName
+				});
+			}
+			if (hasTypeExport("MetaData")) {
+				const importName = hash(`${configKey}MetaData`);
+				options.addImportItemType({
+					imports: [{
+						as: importName,
+						name: "MetaData"
+					}],
+					specifier
+				});
+				options.metaDatas.push({
+					key: configKey,
+					value: importName
+				});
+			}
+		}
+	});
+}
+
+//#endregion
+export { registerModuleExportScan };

package/dist/cli/module/install.mjs

@@ -0,0 +1,49 @@
+import { hasInstalledModule$1 as hasInstalledModule } from "../utils/compatibility.mjs";
+import { useSilgiCLI } from "silgi";
+import { createJiti } from "dev-jiti";
+
+//#region src/cli/module/install.ts
+async function loadSilgiModuleInstance(silgiModule) {
+	if (typeof silgiModule === "string") throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+	if (typeof silgiModule !== "function") throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
+	return { silgiModule };
+}
+async function installModules(silgi, prepare = false) {
+	silgi.options.isPreparingModules = prepare;
+	const jiti = createJiti(silgi.options.rootDir, {
+		alias: silgi.options.alias,
+		fsCache: true,
+		moduleCache: true
+	});
+	for (const module of silgi.scanModules) {
+		if (hasInstalledModule(module.meta.configKey) && !silgi.options.dev) silgi.logger.info(`Module ${module.meta.configKey} installed`);
+		try {
+			const silgiModule = module.entryPath !== void 0 ? await jiti.import(module.entryPath, {
+				default: true,
+				conditions: silgi.options.conditions
+			}) : module.module;
+			if (silgiModule.name !== "silgiNormalizedModule") {
+				silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
+				continue;
+			}
+			await installModule(silgiModule, silgi, prepare);
+		} catch (err) {
+			silgi.logger.error(err);
+		}
+	}
+	silgi.options.isPreparingModules = false;
+}
+/** Installs a module on a Nuxt instance. */
+async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions, prepare = false) {
+	const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
+	const res = await silgiModule(inlineOptions || {}, silgi) ?? {};
+	if (res === false) return false;
+	const metaData = await silgiModule.getMeta?.();
+	if (prepare) return metaData;
+	const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
+	if (installedModule) installedModule.installed = true;
+	else throw new Error(`Module ${metaData?.name} not found`);
+}
+
+//#endregion
+export { installModules };

package/dist/cli/module/scan.mjs

@@ -0,0 +1,195 @@
+import { scanSilgiExports } from "../scan/scanExportFile.mjs";
+import { consola as consola$1 } from "consola";
+import { resolve } from "pathe";
+import { directoryToURL, isPresents, resolveAlias } from "silgi/kit";
+import { scanExports } from "unimport";
+import { existsSync, promises } from "node:fs";
+import { isRelative } from "ufo";
+import { defu } from "defu";
+import { createJiti } from "dev-jiti";
+import { fileURLToPath } from "node:url";
+import { resolveModuleURL } from "exsolve";
+
+//#region src/cli/module/scan.ts
+const MissingModuleMatcher = /Cannot find module\s+['"]?([^'")\s]+)['"]?/i;
+async function _resolveSilgiModule(silgiModule, silgi) {
+	let resolvedModulePath;
+	let buildTimeModuleMeta = {};
+	const jiti = createJiti(silgi.options.rootDir, {
+		alias: silgi.options.alias,
+		fsCache: true,
+		moduleCache: true
+	});
+	if (typeof silgiModule === "string") {
+		silgiModule = resolveAlias(silgiModule, silgi.options.alias);
+		if (isRelative(silgiModule)) silgiModule = resolve(silgi.options.rootDir, silgiModule);
+		try {
+			const src = resolveModuleURL(silgiModule, {
+				from: silgi.options.modulesDir.map((m) => directoryToURL(m.replace(/\/node_modules\/?$/, "/"))),
+				suffixes: [
+					"silgi",
+					"silgi/index",
+					"module",
+					"module/index",
+					"",
+					"index"
+				],
+				extensions: [
+					".js",
+					".mjs",
+					".cjs",
+					".ts",
+					".mts",
+					".cts"
+				]
+			});
+			resolvedModulePath = fileURLToPath(src);
+			const resolvedSilgiModule = await jiti.import(src, { default: true });
+			if (typeof resolvedSilgiModule !== "function") throw new TypeError(`Nuxt module should be a function: ${silgiModule}.`);
+			silgiModule = await jiti.import(src, {
+				default: true,
+				conditions: silgi.options.conditions
+			});
+			const moduleMetadataPath = new URL("module.json", src);
+			if (existsSync(moduleMetadataPath)) buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+			else if (typeof silgiModule === "function") {
+				const meta = await silgiModule.getMeta?.();
+				const _exports = await scanExports(resolvedModulePath, true);
+				buildTimeModuleMeta = {
+					...meta,
+					exports: _exports.map(({ from,...rest }) => rest)
+				};
+			}
+			if (!isPresents(["npm-package"])) {
+				const runtimeFolder = new URL("runtime", src);
+				await scanSilgiExports(runtimeFolder.pathname, buildTimeModuleMeta._packageName);
+			}
+		} catch (error) {
+			const code = error.code;
+			if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+			if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+				const module = MissingModuleMatcher.exec(error.message)?.[1];
+				if (module && !module.includes(silgiModule)) throw new TypeError(`Error while importing module \`${silgiModule}\`: ${error}`);
+			}
+		}
+	}
+	if (!buildTimeModuleMeta) throw new Error(`Module ${silgiModule} is not a valid Silgi module`);
+	if (typeof silgiModule === "function") {
+		if (!buildTimeModuleMeta.configKey) {
+			const meta = await silgiModule.getMeta?.();
+			buildTimeModuleMeta = {
+				...meta,
+				exports: []
+			};
+		}
+		if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
+		const options = await silgiModule.getOptions?.() || {};
+		if (options) silgi.options._c12.config[buildTimeModuleMeta.configKey] = defu(silgi.options._c12.config[buildTimeModuleMeta.configKey] || {}, options || {});
+		else throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+		silgi.scanModules.push({
+			meta: buildTimeModuleMeta,
+			entryPath: resolvedModulePath || void 0,
+			installed: false,
+			options,
+			module: silgiModule
+		});
+	}
+}
+async function scanModules(silgi) {
+	const _modules = [...silgi.options._modules, ...silgi.options.modules];
+	for await (const mod of _modules) await _resolveSilgiModule(mod, silgi);
+	const moduleMap = new Map(silgi.scanModules.map((m) => [m.meta?.configKey, m]));
+	const graphData = createDependencyGraph(silgi.scanModules);
+	const sortedKeys = topologicalSort(graphData);
+	const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
+	silgi.scanModules = modules;
+}
+function createDependencyGraph(modules) {
+	const graph = new Map();
+	const inDegree = new Map();
+	modules.forEach((module) => {
+		const key = module.meta?.configKey;
+		if (key) {
+			graph.set(key, new Set());
+			inDegree.set(key, 0);
+		}
+	});
+	modules.forEach((module) => {
+		const key = module.meta?.configKey;
+		if (!key) return;
+		const requiredDeps = module.meta?.requiredDependencies || [];
+		const beforeDeps = module.meta?.beforeDependencies || [];
+		const afterDeps = module.meta?.afterDependencies || [];
+		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);
+			inDegree.set(key, (inDegree.get(key) || 0) + 1);
+			processedDeps.add(dep);
+		});
+		beforeDeps.forEach((dep) => {
+			if (!graph.has(dep)) return;
+			graph.get(key)?.add(dep);
+			inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+		});
+		afterDeps.forEach((dep) => {
+			if (processedDeps.has(dep)) return;
+			if (!graph.has(dep)) return;
+			graph.get(dep)?.add(key);
+			inDegree.set(key, (inDegree.get(key) || 0) + 1);
+		});
+	});
+	return {
+		graph,
+		inDegree
+	};
+}
+function findCyclicDependencies(graph) {
+	const visited = new Set();
+	const recursionStack = new Set();
+	const cycles = [];
+	function dfs(node, path = []) {
+		visited.add(node);
+		recursionStack.add(node);
+		path.push(node);
+		for (const neighbor of graph.get(node) || []) if (recursionStack.has(neighbor)) {
+			const cycleStart = path.indexOf(neighbor);
+			if (cycleStart !== -1) cycles.push([...path.slice(cycleStart), neighbor]);
+		} else if (!visited.has(neighbor)) dfs(neighbor, [...path]);
+		recursionStack.delete(node);
+		path.pop();
+	}
+	for (const node of graph.keys()) if (!visited.has(node)) dfs(node, []);
+	return cycles;
+}
+function topologicalSort(graphData) {
+	const { graph, inDegree } = graphData;
+	const order = [];
+	const queue = [];
+	for (const [node, degree] of inDegree.entries()) if (degree === 0) queue.push(node);
+	if (queue.length === 0) {}
+	while (queue.length > 0) {
+		const node = queue.shift();
+		order.push(node);
+		const neighbors = Array.from(graph.get(node) || []);
+		for (const neighbor of neighbors) {
+			const newDegree = (inDegree.get(neighbor) || 0) - 1;
+			inDegree.set(neighbor, newDegree);
+			if (newDegree === 0) queue.push(neighbor);
+		}
+	}
+	if (order.length !== graph.size) {
+		const cycles = findCyclicDependencies(graph);
+		if (cycles.length > 0) {
+			const cycleStr = cycles.map((cycle) => `  ${cycle.join(" -> ")}`).join("\n");
+			throw new Error(`Circular dependencies detected:\n${cycleStr}`);
+		} else {
+			const unresolvedModules = Array.from(graph.keys()).filter((key) => !order.includes(key));
+			throw new Error(`Unable to resolve dependencies for modules: ${unresolvedModules.join(", ")}`);
+		}
+	}
+	return order;
+}
+
+//#endregion
+export { scanModules };

package/dist/cli/scan/prepareCommands.mjs

@@ -0,0 +1,40 @@
+import { useSilgiCLI } from "../../core/silgiApp.mjs";
+import { debugMode } from "../utils/debug.mjs";
+import { addTemplate } from "silgi/kit";
+import { genAugmentation } from "knitwork";
+
+//#region src/cli/scan/prepareCommands.ts
+async function prepareCommands(silgi = useSilgiCLI()) {
+	const commands = [];
+	await silgi.callHook("prepare:commands", commands);
+	if (debugMode("command")) addTemplate({
+		filename: "cli.json",
+		where: ".silgi",
+		write: true,
+		getContents: () => JSON.stringify(commands, null, 2)
+	});
+	silgi.hook("prepare:types", async ({ references }) => {
+		const allTags = commands.reduce((acc, commandGroup) => {
+			Object.values(commandGroup).forEach((command) => {
+				if (command.tags) command.tags.forEach((tag) => acc.add(tag));
+			});
+			return acc;
+		}, new Set());
+		const data = [
+			genAugmentation("silgi/types", { SilgiCommands: { ...Object.fromEntries(Array.from(allTags.values()).map((tag) => [tag, "string"])) } }),
+			"",
+			"export {}"
+		];
+		addTemplate({
+			filename: "types/commands.d.ts",
+			write: true,
+			where: ".silgi",
+			getContents: () => data.join("\n")
+		});
+		references.push({ path: "./commands.d.ts" });
+	});
+	silgi.options.commands = commands;
+}
+
+//#endregion
+export { prepareCommands };

package/dist/cli/scan/prepareConfigs.mjs

@@ -0,0 +1,33 @@
+import { useCLIRuntimeConfig } from "../core/runtimeConfig.mjs";
+import { resolve } from "pathe";
+import { useSilgiCLI } from "silgi";
+import { baseHeaderBannerComment, genEnsureSafeVar, writeFile } from "silgi/kit";
+import { genObjectFromRawEntries } from "knitwork";
+
+//#region src/cli/scan/prepareConfigs.ts
+async function prepareConfigs(silgi = useSilgiCLI()) {
+	useCLIRuntimeConfig();
+	const _data = { runtimeConfig: {} };
+	for (const module of silgi.scanModules) if (module.meta.cliToRuntimeOptionsKeys && module.meta.cliToRuntimeOptionsKeys?.length > 0) for (const key of module.meta.cliToRuntimeOptionsKeys) _data[module.meta.configKey] = {
+		..._data[module.meta.configKey],
+		[key]: module.options[key]
+	};
+	else _data[module.meta.configKey] = {};
+	await silgi.callHook("prepare:configs.ts", _data);
+	const importData = [
+		"import type { SilgiRuntimeOptions, SilgiRuntimeConfig, SilgiOptions } from 'silgi/types'",
+		"import { useRuntimeConfig } from 'silgi/runtime'",
+		"",
+		`export const runtimeConfig: SilgiRuntimeConfig = ${genObjectFromRawEntries(Object.entries(_data.runtimeConfig).map(([key, value]) => [key, genEnsureSafeVar(value)]), "")}`,
+		"",
+		"export const localConfig = useRuntimeConfig(undefined, runtimeConfig)",
+		""
+	];
+	delete _data.runtimeConfig;
+	importData.push(`export const cliConfigs: Partial<SilgiRuntimeOptions & SilgiOptions> = ${genObjectFromRawEntries(Object.entries(_data).map(([key, value]) => [key, genEnsureSafeVar(value)]))}`);
+	importData.unshift(...baseHeaderBannerComment);
+	await writeFile(resolve(silgi.options.silgi.serverDir, "configs.ts"), importData.join("\n"));
+}
+
+//#endregion
+export { prepareConfigs };