silgi 0.42.4 → 0.43.0

package/dist/cli/commands/run.mjs

@@ -0,0 +1,105 @@
+import { watchDev } from "../build/dev.mjs";
+import { commonArgs } from "../utils/common.mjs";
+import prepare_default from "./prepare.mjs";
+import consola from "consola";
+import { useSilgiCLI } from "silgi";
+import { version } from "silgi/meta";
+import { defineCommand, runCommand } from "citty";
+import { x } from "tinyexec";
+
+//#region src/cli/commands/run.ts
+const command = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start the development server for the project",
+		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 silgi = useSilgiCLI();
+		const startCommand = args.command || rawArgs[0];
+		let childPid = null;
+		let hasExited = false;
+		let exitTimeout = null;
+		const cleanupAndExit = (code = 0) => {
+			if (hasExited) return;
+			hasExited = true;
+			if (exitTimeout) clearTimeout(exitTimeout);
+			process.exit(code);
+		};
+		const handleSignal = async (signal, watcher) => {
+			consola.info(`Received ${signal}, terminating process...`);
+			if (watcher && typeof watcher.close === "function") try {
+				await watcher.close();
+			} catch {}
+			if (childPid) {
+				try {
+					process.kill(childPid, signal);
+				} catch (err) {
+					consola.error(`Failed to kill process: ${err instanceof Error ? err.message : err}`);
+				}
+				exitTimeout = setTimeout(() => {
+					consola.warn("Process did not exit gracefully, forcing termination...");
+					try {
+						if (childPid) process.kill(childPid, "SIGKILL");
+					} catch {}
+					cleanupAndExit(1);
+				}, 3e3);
+			} else cleanupAndExit(0);
+		};
+		const setupSignalHandlers = (watcher) => {
+			[
+				"SIGINT",
+				"SIGTERM",
+				"SIGHUP"
+			].forEach((signal) => {
+				process.on(signal, () => {
+					handleSignal(signal, watcher);
+				});
+			});
+		};
+		try {
+			const watcher = await watchDev();
+			setupSignalHandlers(watcher);
+			consola.info(`Starting command: nr ${startCommand}`);
+			const proc = x("nr", [startCommand], { nodeOptions: {
+				stdio: "inherit",
+				shell: true,
+				cwd: process.cwd(),
+				killSignal: "SIGINT"
+			} });
+			if (proc && typeof proc.pid === "number") childPid = proc.pid;
+			try {
+				await proc;
+				consola.success(`Process exited successfully.`);
+				cleanupAndExit(0);
+			} catch (procError) {
+				const exitCode = procError && typeof procError.exitCode === "number" ? procError.exitCode : 1;
+				consola.error(`Process exited with code: ${exitCode}`);
+				if (silgi.options.debug) consola.withTag("silgi").error("Error while running the command", procError);
+				cleanupAndExit(exitCode);
+			}
+		} catch (error) {
+			consola.error(`Failed to start the development server: ${error instanceof Error ? error.message : error}`);
+			if (silgi.options.debug) consola.withTag("silgi").error("Error while running the command", error);
+			cleanupAndExit(1);
+		}
+	}
+});
+var run_default = command;
+
+//#endregion
+export { run_default as default };

package/dist/cli/commands/watch.mjs

@@ -0,0 +1,48 @@
+import { watchDev } from "../build/dev.mjs";
+import { commonArgs } from "../utils/common.mjs";
+import prepare_default from "./prepare.mjs";
+import consola from "consola";
+import { version } from "silgi/meta";
+import { defineCommand, runCommand } from "citty";
+
+//#region src/cli/commands/watch.ts
+const command = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start the development server for the project",
+		version
+	},
+	args: {
+		...commonArgs,
+		preset: {
+			type: "string",
+			description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+		},
+		stub: {
+			type: "boolean",
+			description: "Run in silgi development mode"
+		}
+	},
+	async run() {
+		await runCommand(prepare_default, { rawArgs: [
+			"--commandType",
+			"dev",
+			"--dev",
+			"true"
+		] });
+		const watch = await watchDev();
+		process.on("SIGINT", async () => {
+			consola.withTag("silgi").info("Shutting down...");
+			if (watch) watch.close();
+			await watch.close();
+			process.exit(0);
+		});
+		consola.withTag("silgi").success("Prepare completed");
+		consola.withTag("silgi").info("Process is still running. Press Ctrl+C to exit.");
+		setInterval(() => {}, 1e3);
+	}
+});
+var watch_default = command;
+
+//#endregion
+export { watch_default as default };

package/dist/cli/config/defaults.mjs

@@ -0,0 +1,117 @@
+import { isDebug, isTest } from "std-env";
+
+//#region src/cli/config/defaults.ts
+const SilgiCLIDefaults = {
+	debug: isDebug === true ? true : void 0,
+	schemaVendor: "zod",
+	logLevel: isTest ? 1 : 3,
+	appConfig: {},
+	appConfigFiles: [],
+	commandType: "prepare",
+	commands: [],
+	runtimeConfig: { silgi: {} },
+	storages: [],
+	devServer: { watch: [] },
+	package: {
+		name: "",
+		present: "npm-package"
+	},
+	scanDirs: [],
+	build: {
+		dir: ".silgi",
+		typesDir: "{{ build.dir }}/types",
+		templates: []
+	},
+	output: {
+		dir: "{{ rootDir }}/.output",
+		serverDir: "{{ output.dir }}/server",
+		publicDir: "{{ output.dir }}/public"
+	},
+	serverDir: "{{ rootDir }}/server",
+	clientDir: "{{ rootDir }}/client",
+	migrationDir: "{{ rootDir }}/migration",
+	silgi: {
+		serverDir: "{{ serverDir }}/silgi",
+		clientDir: "{{ clientDir }}/silgi",
+		publicDir: "{{ silgi.serverDir }}/public",
+		utilsDir: "{{ silgi.serverDir }}/utils",
+		vfsDir: "{{ silgi.serverDir }}/vfs",
+		typesDir: "{{ silgi.serverDir }}/types"
+	},
+	codegen: { env: { safeList: [["silgi", "version"]] } },
+	_modules: [],
+	modules: [],
+	future: {},
+	storage: {},
+	devStorage: {},
+	stub: false,
+	plugins: [],
+	imports: {
+		exclude: [],
+		dirs: [],
+		presets: [],
+		virtualImports: ["#silgiImports"]
+	},
+	ignore: [
+		"**/*.stories.{js,cts,mts,ts,jsx,tsx}",
+		"**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}",
+		"**/*.d.{cts,mts,ts}",
+		"**/.{pnpm-store,vercel,netlify,output,git,cache,data}",
+		".silgi",
+		"**/-*.*"
+	],
+	dev: false,
+	watchOptions: {
+		ignoreInitial: true,
+		ignored: [
+			"**/node_modules/**",
+			"**/.git/**",
+			"**/.silgi/**",
+			"**/.output/**",
+			"**/.vscode/**",
+			"**/.idea/**",
+			"**/.nuxt/**",
+			"**/.gitignore",
+			"**/.gitattributes",
+			"**/assets/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/coverage/**",
+			"**/test/**",
+			"**/tests/**",
+			"**/tmp/**"
+		]
+	},
+	typescript: {
+		generateTsConfig: true,
+		tsconfigPath: ".silgi/types/silgi.tsconfig.json",
+		tsConfig: {},
+		customConditions: [],
+		generateRuntimeConfigTypes: true,
+		removeFileExtension: false
+	},
+	conditions: [],
+	nodeModulesDirs: [],
+	hooks: {},
+	framework: {
+		name: "h3",
+		version: ""
+	},
+	extensions: [
+		".js",
+		".jsx",
+		".mjs",
+		".ts",
+		".tsx",
+		".vue"
+	],
+	ignoreOptions: void 0,
+	apiFul: {},
+	installPackages: {
+		dependencies: {},
+		devDependencies: {}
+	}
+};
+
+//#endregion
+export { SilgiCLIDefaults };

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

@@ -1,11 +1,3 @@
-import { SilgiCLIConfig, LoadConfigOptions, SilgiCLIOptions, SilgiCLI } from 'silgi/types';
-import { TSConfig } from 'pkg-types';
-
-declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
-
-declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
-    declarations: string[];
-    tsConfig: TSConfig;
-}>;
-
-export { loadOptions, silgiGenerateType };
+import { loadOptions$1 as loadOptions } from "./loader.mjs";
+import { silgiGenerateType$1 as silgiGenerateType } from "./types.mjs";
+export { loadOptions, silgiGenerateType };

package/dist/cli/config/index.mjs

@@ -1,17 +1,4 @@
-export { l as loadOptions } from '../loader.mjs';
-export { s as silgiGenerateType } from '../types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola';
-import 'consola/utils';
-import 'pathe';
-import 'escape-string-regexp';
-import 'mlly';
-import 'node:fs';
-import 'pkg-types';
-import 'silgi/kit';
-import 'silgi/runtime/meta';
-import 'ufo';
-import 'defu';
+import { loadOptions } from "./loader.mjs";
+import { silgiGenerateType } from "./types.mjs";
+
+export { loadOptions, silgiGenerateType };

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

@@ -0,0 +1,6 @@
+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 as loadOptions$1 };

package/dist/cli/config/loader.mjs

@@ -0,0 +1,71 @@
+import { SilgiCLIDefaults } from "./defaults.mjs";
+import { fallbackCompatibilityDate, resolveCompatibilityOptions } from "./resolvers/compatibility.mjs";
+import { resolveImportsOptions } from "./resolvers/imports.mjs";
+import { resolvePathOptions } from "./resolvers/paths.mjs";
+import { resolveStorageOptions } from "./resolvers/storage.mjs";
+import { resolveURLOptions } from "./resolvers/url.mjs";
+import { loadConfig, watchConfig } from "c12";
+import { resolveCompatibilityDates } from "compatx";
+import { klona } from "klona/full";
+
+//#region src/cli/config/loader.ts
+const configResolvers = [
+	resolveCompatibilityOptions,
+	resolvePathOptions,
+	resolveImportsOptions,
+	resolveURLOptions,
+	resolveStorageOptions
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+	const options = await _loadUserConfig(configOverrides, opts);
+	for (const resolver of configResolvers) await resolver(options);
+	return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+	const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
+	if (configOverrides.dev) {}
+	configOverrides = klona(configOverrides);
+	globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
+	let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE;
+	const { resolvePreset } = await import("silgi/presets");
+	const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+		name: "silgi",
+		cwd: configOverrides.rootDir,
+		dotenv: configOverrides.dev,
+		extend: { extendKey: ["extends", "preset"] },
+		overrides: {
+			...configOverrides,
+			preset: presetOverride
+		},
+		async defaultConfig({ configs }) {
+			const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
+			if (!compatibilityDate) compatibilityDate = getConf("compatibilityDate");
+			return { preset: presetOverride || (await resolvePreset("", {
+				static: getConf("static"),
+				compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+			}))?._meta?.name };
+		},
+		defaults: SilgiCLIDefaults,
+		jitiOptions: { alias: { "silgi/config": "silgi/config" } },
+		async resolve(id) {
+			const preset = await resolvePreset(id, {
+				static: configOverrides.static,
+				compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+			});
+			if (preset) return { config: klona(preset) };
+		},
+		...opts.c12
+	});
+	delete globalThis.defineSilgiConfig;
+	const options = klona(loadedConfig.config);
+	options._config = configOverrides;
+	options._c12 = loadedConfig;
+	const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
+	options.preset = _presetName;
+	options.package.present = _presetName;
+	options.compatibilityDate = resolveCompatibilityDates(compatibilityDate, options.compatibilityDate);
+	return options;
+}
+
+//#endregion
+export { loadOptions };

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

@@ -0,0 +1,71 @@
+import consola from "consola";
+import { relative } from "pathe";
+import { formatDate, resolveCompatibilityDatesFromEnv } from "compatx";
+import { colors } from "consola/utils";
+
+//#region src/cli/config/resolvers/compatibility.ts
+const fallbackCompatibilityDate = "2025-02-04";
+async function resolveCompatibilityOptions(options) {
+	options.compatibilityDate = resolveCompatibilityDatesFromEnv(options.compatibilityDate);
+	if (!options.compatibilityDate.default) options.compatibilityDate.default = await _resolveDefault(options);
+}
+let _fallbackInfoShown = false;
+let _promptedUserToUpdate = false;
+async function _resolveDefault(options) {
+	const _todayDate = formatDate(new Date());
+	const consola$2 = consola.withTag("silgi");
+	consola$2.warn(`No valid compatibility date is specified.`);
+	const onFallback = () => {
+		if (!_fallbackInfoShown) {
+			consola$2.info([
+				`Using \`${fallbackCompatibilityDate}\` as fallback.`,
+				`  Please specify compatibility date to avoid unwanted behavior changes:`,
+				`     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
+				`     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
+				``
+			].join("\n"));
+			_fallbackInfoShown = true;
+		}
+		return fallbackCompatibilityDate;
+	};
+	const shallUpdate = !_promptedUserToUpdate && await consola$2.prompt(`Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`, {
+		type: "confirm",
+		default: true
+	});
+	_promptedUserToUpdate = true;
+	if (!shallUpdate) return onFallback();
+	const { updateConfig } = await import("c12/update");
+	const updateResult = await updateConfig({
+		configFile: "silgi.config",
+		cwd: options.rootDir,
+		async onCreate({ configFile }) {
+			const shallCreate = await consola$2.prompt(`Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`, {
+				type: "confirm",
+				default: true
+			});
+			if (shallCreate !== true) return false;
+			return _getDefaultNitroConfig();
+		},
+		async onUpdate(config) {
+			config.compatibilityDate = _todayDate;
+		}
+	}).catch((error) => {
+		consola$2.error(`Failed to update config: ${error.message}`);
+		return null;
+	});
+	if (updateResult?.configFile) {
+		consola$2.success(`Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``);
+		return _todayDate;
+	}
+	return onFallback();
+}
+function _getDefaultNitroConfig() {
+	return `
+import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({})
+  `;
+}
+
+//#endregion
+export { fallbackCompatibilityDate, resolveCompatibilityOptions };

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

@@ -0,0 +1,35 @@
+import { join } from "pathe";
+import escapeRE from "escape-string-regexp";
+import { resolveModuleExportNames } from "mlly";
+
+//#region src/cli/config/resolvers/imports.ts
+async function resolveImportsOptions(options) {
+	if (options.imports === false) return;
+	options.imports.presets ??= [];
+	options.imports.presets.push(...getSilgiImportsPreset());
+	if (options.preset === "h3") {
+		const h3Exports = await resolveModuleExportNames("h3", { url: import.meta.url });
+		options.imports.presets ??= [];
+		options.imports.presets.push({
+			from: "h3",
+			imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+		});
+	}
+	options.imports.dirs ??= [];
+	options.imports.dirs.push(...options.scanDirs.map((dir) => join(dir, "utils/**/*")));
+	if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+		options.imports.exclude.push(/[/\\]\.git[/\\]/);
+		options.imports.exclude.push(options.build.dir);
+		const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+		options.imports.exclude.push(scanDirsInNodeModules.length > 0 ? new RegExp(`node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`) : /[/\\]node_modules[/\\]/);
+	}
+}
+function getSilgiImportsPreset() {
+	return [{
+		from: "silgi",
+		imports: ["useSilgiStorage"]
+	}];
+}
+
+//#endregion
+export { resolveImportsOptions };

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

@@ -0,0 +1,98 @@
+import { SilgiCLIDefaults } from "../defaults.mjs";
+import { join, resolve } from "pathe";
+import { resolveSilgiPath } from "silgi/kit";
+import { pkgDir, runtimeDir } from "silgi/runtime/meta";
+import { existsSync } from "node:fs";
+import { findWorkspaceDir, readPackageJSON } from "pkg-types";
+
+//#region src/cli/config/resolvers/paths.ts
+async function resolvePathOptions(options) {
+	options.rootDir = resolve(options.rootDir || ".");
+	options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(() => options.rootDir);
+	options.srcDir = resolve(options.srcDir || options.rootDir);
+	for (const key of ["srcDir"]) options[key] = resolve(options.rootDir, options[key]);
+	options.build.dir = resolve(options.rootDir, options.build.dir);
+	options.build.typesDir = resolveSilgiPath(options.build.typesDir || SilgiCLIDefaults.build.typesDir, options, options.rootDir);
+	if (options.preset === "npm-package") {
+		const packageJsonPath = resolve(options.rootDir, "package.json");
+		const packageJson = await readPackageJSON(packageJsonPath);
+		if (packageJson.name === void 0) throw new Error("Package name is undefined");
+		options.alias ||= {};
+		options.alias[packageJson.name] = join(options.rootDir, "src/module");
+		options.alias[`${packageJson.name}/runtime`] = join(options.rootDir, "src/runtime");
+		options.alias[`${packageJson.name}/data`] = join(options.rootDir, "src/data");
+		options.alias[`${packageJson.name}/data/*`] = join(options.rootDir, "src/data/*");
+		options.alias[`${packageJson.name}/runtime/*`] = join(options.rootDir, "src/runtime/*");
+		options.alias[`${packageJson.name}/types`] = join(options.rootDir, "src/types");
+	}
+	if (options.stub) options.alias = {
+		...options.alias,
+		"silgi/runtime": join(runtimeDir),
+		"silgi/runtime/*": join(runtimeDir, "*")
+	};
+	options.alias = {
+		...options.alias,
+		"#server/*": join(options.silgi.serverDir, "/*"),
+		"#silgi/*": join(options.build.dir, "/*"),
+		"#types/*": join(options.build.typesDir, "/*")
+	};
+	if (options.preset === "npm-package") options.alias = { ...options.alias };
+	if (options.alias && typeof options.alias === "object") {
+		((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+		const paths = options.typescript.tsConfig.compilerOptions.paths;
+		for (const [key, value] of Object.entries(options.alias)) if (typeof paths === "object") paths[key] = [value];
+	}
+	if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
+		((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+		const paths = options.typescript.tsConfig.compilerOptions.paths;
+		for (const [key, value] of Object.entries(options.alias)) if (typeof paths === "object") paths[key] = [value];
+	}
+	options.modulesDir = [resolve(options.rootDir, "node_modules")];
+	options.output.dir = resolveSilgiPath(options.output.dir || SilgiCLIDefaults.output.dir, options, options.rootDir);
+	options.output.publicDir = resolveSilgiPath(options.output.publicDir || SilgiCLIDefaults.output.publicDir, options, options.rootDir);
+	options.output.serverDir = resolveSilgiPath(options.output.serverDir || SilgiCLIDefaults.output.serverDir, options, options.rootDir);
+	options.serverDir = resolveSilgiPath(options.serverDir || SilgiCLIDefaults.serverDir, options, options.rootDir);
+	options.clientDir = resolveSilgiPath(options.clientDir || SilgiCLIDefaults.clientDir, options, options.rootDir);
+	options.silgi.serverDir = resolveSilgiPath(options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir, options, options.rootDir);
+	options.silgi.clientDir = resolveSilgiPath(options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir, options, options.rootDir);
+	options.silgi.publicDir = resolveSilgiPath(options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir, options, options.rootDir);
+	options.silgi.utilsDir = resolveSilgiPath(options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir, options, options.rootDir);
+	options.silgi.vfsDir = resolveSilgiPath(options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir, options, options.rootDir);
+	options.silgi.typesDir = resolveSilgiPath(options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir, options, options.rootDir);
+	options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+	options.nodeModulesDirs = [...new Set(options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir)))];
+	options.scanDirs.unshift(options.srcDir);
+	options.scanDirs = options.scanDirs.map((dir) => resolve(options.srcDir, dir));
+	options.scanDirs = [...new Set(options.scanDirs)];
+	options.appConfigFiles ??= [];
+	options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
+	for (const dir of options.scanDirs) {
+		const configFile = _tryResolve("app.config", dir);
+		if (configFile && !options.appConfigFiles.includes(configFile)) options.appConfigFiles.push(configFile);
+	}
+	options.watchOptions.ignored ??= [];
+	options.watchOptions.ignoreInitial = true;
+	if (Array.isArray(options.watchOptions.ignored)) options.watchOptions.ignored.push(`!${join(options.silgi.serverDir, "config")}`, `${join(options.silgi.serverDir, "permission.ts")}`, `${join(options.silgi.serverDir, "core.ts")}`, `${join(options.silgi.serverDir, "meta.ts")}`, `${join(options.silgi.serverDir, "configs.ts")}`, `${join(options.silgi.serverDir, "vfs")}`, `${join(options.silgi.serverDir, "scan.ts")}`);
+	options.devServer.watch.push(join(options.serverDir, "services"), join(options.serverDir, "schemas"), join(options.serverDir, "shared"), join(options.serverDir, "utils"), join(options.serverDir, "types"), join(options.silgi.serverDir, "config"), join(options.silgi.serverDir, "modules"), join(options.rootDir, "silgi.config.ts"));
+}
+function _tryResolve(path, base = ".", extensions = [
+	"",
+	".js",
+	".ts",
+	".mjs",
+	".cjs",
+	".json"
+]) {
+	path = resolve(base, path);
+	if (existsSync(path)) return path;
+	for (const ext of extensions) {
+		const p = path + ext;
+		if (existsSync(p)) return p;
+	}
+}
+
+//#endregion
+export { resolvePathOptions };

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

@@ -0,0 +1,23 @@
+import { resolve } from "pathe";
+
+//#region src/cli/config/resolvers/storage.ts
+async function resolveStorageOptions(options) {
+	const fsMounts = {
+		root: resolve(options.rootDir),
+		src: resolve(options.srcDir),
+		build: resolve(options.build.dir),
+		cache: resolve(options.build.dir, "cache")
+	};
+	for (const p in fsMounts) options.devStorage[p] = options.devStorage[p] || {
+		driver: "fs",
+		readOnly: p === "root" || p === "src",
+		base: fsMounts[p]
+	};
+	if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) options.devStorage.data = {
+		driver: "fs",
+		base: resolve(options.rootDir, ".data/kv")
+	};
+}
+
+//#endregion
+export { resolveStorageOptions };

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

@@ -0,0 +1,9 @@
+import { withLeadingSlash, withTrailingSlash } from "ufo";
+
+//#region src/cli/config/resolvers/url.ts
+async function resolveURLOptions(options) {
+	options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+//#endregion
+export { resolveURLOptions };

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

@@ -0,0 +1,14 @@
+import { TSConfig } from "pkg-types";
+import { SilgiCLI } from "silgi/types";
+
+//#region src/cli/config/types.d.ts
+
+// const EXTENSION_RE = /\b\.\w+$/g
+// Exclude bridge alias types to support Volar
+// const excludedAlias = [/^@vue\/.*$/, /^#internal\/nuxt/]
+declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
+  declarations: string[];
+  tsConfig: TSConfig;
+}>;
+//#endregion
+export { silgiGenerateType as silgiGenerateType$1 };