silgi 0.43.28 → 0.50.0

package/dist/cli/config/defaults.mjs

@@ -1,117 +0,0 @@
-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,3 +0,0 @@
-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,4 +0,0 @@
-import { loadOptions } from "./loader.mjs";
-import { silgiGenerateType } from "./types.mjs";
-
-export { loadOptions, silgiGenerateType };

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

@@ -1,6 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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 };

package/dist/cli/config/types.mjs

@@ -1,147 +0,0 @@
-import { dirname, isAbsolute, join, relative, resolve } from "pathe";
-import { isPresents, relativeWithDot, resolveSilgiModule } from "silgi/kit";
-import { existsSync, lstatSync, promises } from "node:fs";
-import { readPackageJSON } from "pkg-types";
-import { withTrailingSlash } from "ufo";
-import { defu } from "defu";
-
-//#region src/cli/config/types.ts
-function getDirectory(p) {
-	try {
-		return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-	} catch {}
-	return p;
-}
-function renderAttrs(obj) {
-	const attrs = [];
-	for (const key in obj) attrs.push(renderAttr(key, obj[key]));
-	return attrs.join(" ");
-}
-function renderAttr(key, value) {
-	return value ? `${key}="${value}"` : "";
-}
-async function silgiGenerateType(silgi) {
-	const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
-	const tsConfigPath = resolve(silgi.options.rootDir, silgi.options.typescript.tsconfigPath);
-	const tsconfigDir = dirname(tsConfigPath);
-	const include = new Set([
-		relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-config.d.ts")).replace(/^(?=[^.])/, "./"),
-		join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
-		...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
-	]);
-	const exclude = new Set([relativeWithDot(tsconfigDir, "node_modules"), relativeWithDot(tsconfigDir, "dist")]);
-	for (const dir of silgi.options.modulesDir) exclude.add(relativeWithDot(silgi.options.build.dir, dir));
-	const moduleEntryPaths = [];
-	for (const m of silgi.scanModules) if (m.entryPath) moduleEntryPaths.push(getDirectory(m.entryPath));
-	const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
-	for (const path of modulePaths) {
-		const relative$1 = relativeWithDot(tsconfigDir, path);
-		include.add(join(relative$1, "runtime"));
-		exclude.add(join(relative$1, "runtime/server"));
-		include.add(join(relative$1, "dist/runtime"));
-		exclude.add(join(relative$1, "dist/runtime/server"));
-	}
-	let tsConfig = silgi.options.typescript?.tsConfig || {};
-	const defaultConfig = defu(tsConfig, {
-		compilerOptions: {
-			esModuleInterop: true,
-			allowSyntheticDefaultImports: true,
-			skipLibCheck: true,
-			allowImportingTsExtensions: true,
-			target: "ESNext",
-			allowJs: true,
-			resolveJsonModule: true,
-			moduleDetection: "force",
-			isolatedModules: true,
-			verbatimModuleSyntax: true,
-			strict: true,
-			noUncheckedIndexedAccess: true,
-			noImplicitOverride: true,
-			forceConsistentCasingInFileNames: true,
-			noEmit: true,
-			module: "Preserve",
-			moduleResolution: "bundler",
-			useDefineForClassFields: true,
-			noImplicitThis: true,
-			jsx: "preserve",
-			customConditions: silgi.options.typescript.customConditions,
-			paths: {}
-		},
-		include: [...include],
-		exclude: [...exclude]
-	});
-	tsConfig = defaultConfig;
-	if (isPresents(["hono"])) tsConfig = defu(defaultConfig, { compilerOptions: {
-		jsx: "react-jsx",
-		jsxImportSource: "hono/jsx"
-	} });
-	if (isPresents(["npm-package"])) tsConfig = defu(tsConfig, {
-		compilerOptions: {
-			target: "es2022",
-			lib: [
-				"es2022",
-				"webworker",
-				"dom.iterable"
-			],
-			moduleDetection: "force",
-			module: "preserve",
-			paths: {},
-			resolveJsonModule: true,
-			allowJs: true,
-			strict: true,
-			noImplicitOverride: true,
-			noEmit: true,
-			allowSyntheticDefaultImports: true,
-			esModuleInterop: false,
-			forceConsistentCasingInFileNames: true,
-			isolatedModules: true,
-			verbatimModuleSyntax: true,
-			skipLibCheck: true
-		},
-		include: [...include],
-		exclude: [...exclude]
-	});
-	tsConfig.compilerOptions ||= {};
-	tsConfig.compilerOptions.paths ||= {};
-	tsConfig.include ||= [];
-	for (const alias in tsConfig.compilerOptions.paths) {
-		const paths = tsConfig.compilerOptions.paths[alias];
-		tsConfig.compilerOptions.paths[alias] = await Promise.all(paths.map(async (path) => {
-			if (!isAbsolute(path)) return path;
-			const stats = await promises.stat(path).catch(() => null);
-			return relativeWithDot(tsconfigDir, stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path);
-		}));
-	}
-	const references = [];
-	await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-		if (typeof id !== "string") return;
-		if (id === "./src" && silgi.options.preset === "npm-package") id = resolve(silgi.options.rootDir);
-		const pkg = await readPackageJSON(id, { url: silgi.options.rootDir }).catch(() => null);
-		references.push({ types: pkg?.name || id });
-	}));
-	const declarations = [];
-	await silgi.callHook("prepare:types", {
-		references,
-		declarations,
-		tsConfig
-	});
-	tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-	tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-	const _declarations = [
-		...references.map((ref) => {
-			if ("path" in ref && isAbsolute(ref.path)) ref.path = relative(silgi.options.build.dir, ref.path);
-			return `/// <reference ${renderAttrs(ref)} />`;
-		}),
-		...declarations,
-		"",
-		"export {}",
-		""
-	];
-	return {
-		declarations: _declarations,
-		tsConfig
-	};
-}
-
-//#endregion
-export { silgiGenerateType };

package/dist/cli/core/apiful.mjs

@@ -1,36 +0,0 @@
-import { consola as consola$1 } from "consola";
-import { join, resolve } from "pathe";
-import { hasSilgiModule, writeTemplate } from "silgi/kit";
-import { generateDTS } from "apiful/openapi";
-
-//#region src/cli/core/apiful.ts
-async function generateApiFul(silgi) {
-	const config = silgi.options.apiFul;
-	if (!hasSilgiModule("openapi")) {
-		silgi.options.dev || silgi.logger.info("Silgi OpenAPI module not found, if you want to use it, please install it @silgi/openapi");
-		return;
-	}
-	if (!config.services || hasSilgiModule("openapi")) {
-		config.services ??= {};
-		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) {
-		consola$1.info("No OpenAPI schemas found, skipping generation");
-		return;
-	}
-	for (const service of Object.values(resolvedOpenAPIServices)) if (typeof service.schema === "string" && !service.schema.startsWith("http")) service.schema = resolve(silgi.options.rootDir, service.schema);
-	const types = await generateDTS(resolvedOpenAPIServices);
-	silgi.hook("prepare:types", (opts) => {
-		opts.references.push({ path: "./apiful.d.ts" });
-	});
-	writeTemplate({
-		filename: "types/apiful.d.ts",
-		where: ".silgi",
-		write: true,
-		getContents: () => types
-	});
-}
-
-//#endregion
-export { generateApiFul };

package/dist/cli/core/devServer.mjs

@@ -1,10 +0,0 @@
-import { useSilgiCLI } from "silgi";
-
-//#region src/cli/core/devServer.ts
-async function reloadScan(path, _stats) {
-	const silgi = useSilgiCLI();
-	await silgi.callHook("reload:scan", path, _stats);
-}
-
-//#endregion
-export { reloadScan };