silgi 0.42.5 → 0.43.0

package/dist/cli/scan/prepareCoreFile.mjs

@@ -0,0 +1,118 @@
+import { addImports, baseHeaderBannerComment, hash, toArray } from "silgi/kit";
+import { genImport, genObjectFromRawEntries, genTypeImport } from "knitwork";
+
+//#region src/cli/scan/prepareCoreFile.ts
+async function prepareCoreFile(silgi) {
+	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
+		imports: [
+			{
+				specifier: "silgi/runtime",
+				imports: [{ name: "mergeDeep" }]
+			},
+			{
+				specifier: "silgi",
+				imports: [{ name: "createSilgi" }]
+			},
+			{
+				specifier: "./scan",
+				imports: [
+					{ name: "services" },
+					{ name: "shareds" },
+					{ name: "schemas" },
+					{ name: "middlewares" },
+					{ name: "resolvers" }
+				]
+			},
+			{
+				specifier: "./configs",
+				imports: [{ name: "cliConfigs" }]
+			},
+			{
+				specifier: "./meta",
+				imports: [{ name: "meta" }]
+			}
+		],
+		typeImports: [{
+			specifier: "silgi/types",
+			imports: [{ name: "SilgiRuntimeOptions" }, { name: "BuildSilgi" }]
+		}]
+	});
+	const before = [];
+	const after = [];
+	const _data = {
+		silgiConfigs: [],
+		addImportItem,
+		addImportItemType,
+		addBuildFunction: (data) => {
+			for (const item of toArray(data)) {
+				if (item.where === "after") if (item.custom) after.push(item.custom);
+				else after.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
+				if (item.where === "before") if (item.custom) before.push(item.custom);
+				else before.push(item.params?.length ? ` await ${item.name}(option, ${item.params.join(",")})` : ` await ${item.name}(option)`);
+			}
+		}
+	};
+	await silgi.callHook("before:core.ts", _data);
+	const plugins = [];
+	for (const plugin of silgi.options.plugins) {
+		const pluginImportName = hash(plugin.packageImport);
+		addImportItem({
+			specifier: plugin.packageImport,
+			imports: pluginImportName
+		});
+		plugins.push(pluginImportName);
+	}
+	const importsContent = [
+		...genImports.map(({ specifier, imports, options }) => {
+			return genImport(specifier, imports, options);
+		}),
+		...genTypeImports.map(({ specifier, imports }) => {
+			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
+		}),
+		""
+	];
+	const importData = [
+		"",
+		"export async function buildSilgi(option?: BuildSilgi) {",
+		"",
+		"// buildSilgiBefore",
+		...before,
+		"",
+		"const silgi = await createSilgi({",
+		" framework: option?.framework,",
+		" shared: shareds,",
+		" services: services,",
+		" middlewares: middlewares,",
+		" schemas: schemas,",
+		" resolvers: resolvers,",
+		` plugins: [${plugins.join(", ")}],`,
+		"",
+		_data.silgiConfigs.length > 0 ? _data.silgiConfigs.map((item) => {
+			const code = genObjectFromRawEntries(Object.entries(item));
+			return ` ${code.slice(1, -1).trim()},`;
+		}).filter(Boolean).join("\n") : "",
+		"",
+		" options: mergeDeep(cliConfigs, {",
+		"   runtimeConfig: {} as SilgiRuntimeOptions,",
+		"   meta: meta,",
+		`   present: '${silgi.options.preset}',`,
+		"   ...option?.modules,",
+		"   ...option?.options,",
+		"   }) as any,",
+		" })",
+		"",
+		"// buildSilgiAfter",
+		...after,
+		"",
+		"  return silgi",
+		"}",
+		""
+	];
+	await silgi.callHook("after:core.ts", importData);
+	importData.unshift(...importsContent);
+	importData.unshift(...baseHeaderBannerComment);
+	return importData;
+}
+
+//#endregion
+export { prepareCoreFile };

package/dist/cli/scan/prepareScanFile.mjs

@@ -0,0 +1,59 @@
+import { resolve } from "pathe";
+import { addImports, baseHeaderBannerComment, writeFile } from "silgi/kit";
+import { genImport, genTypeImport } from "knitwork";
+
+//#region src/cli/scan/prepareScanFile.ts
+async function prepareScanFile(silgi) {
+	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({});
+	const scanned = {
+		services: [],
+		shareds: [],
+		resolvers: [],
+		schemas: [],
+		middlewares: [],
+		addImportItem,
+		addImportItemType
+	};
+	await silgi.callHook("before:scan.ts", scanned);
+	const importsContent = [
+		...genImports.map(({ specifier, imports, options }) => {
+			return genImport(specifier, imports, options);
+		}),
+		...genTypeImports.map(({ specifier, imports }) => {
+			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
+		}),
+		""
+	];
+	const generateExport = (name, items, defaultEmpty = "{}", asArray = false) => {
+		const hasItems = items.length > 0;
+		if (asArray) return [
+			`export const ${name} = [`,
+			...items.map((item) => `  ${item},`),
+			"]",
+			""
+		];
+		if (hasItems) return [
+			`export const ${name} = {`,
+			...items.map((item) => `  ...${item},`),
+			"}",
+			""
+		];
+		else return [`export const ${name} = ${defaultEmpty}`, ""];
+	};
+	const importData = [
+		"",
+		...generateExport("schemas", scanned.schemas),
+		...generateExport("services", scanned.services),
+		...generateExport("shareds", scanned.shareds, "undefined"),
+		...generateExport("resolvers", scanned.resolvers, "[]", true),
+		...generateExport("middlewares", scanned.middlewares)
+	];
+	await silgi.callHook("after:scan.ts", importData);
+	importData.unshift(...importsContent);
+	importData.unshift(...baseHeaderBannerComment);
+	await writeFile(resolve(silgi.options.silgi.serverDir, "scan.ts"), importData.join("\n"));
+	return importData;
+}
+
+//#endregion
+export { prepareScanFile };

package/dist/cli/scan/prepareSchema.mjs

@@ -0,0 +1,140 @@
+import { addImports, getServicePath, relativeWithDot } from "silgi/kit";
+import { genAugmentation, genImport, genTypeImport } from "knitwork";
+import { generateTypes, resolveSchema } from "untyped";
+
+//#region src/cli/scan/prepareSchema.ts
+async function prepareSchema(silgi) {
+	const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
+		imports: [],
+		typeImports: [{
+			specifier: "silgi/types",
+			imports: [{ name: "URIsTypes" }, { name: "SilgiRuntimeContext" }]
+		}]
+	});
+	const data = {
+		addImportItem,
+		addImportItemType,
+		options: [],
+		contexts: [],
+		setupModuleOption: [],
+		shareds: [],
+		resolvers: [],
+		events: [],
+		hooks: [],
+		runtimeHooks: [],
+		runtimeOptions: [],
+		methods: [],
+		routeRules: [],
+		metaDatas: []
+	};
+	await silgi.callHook("before:schema.ts", data);
+	const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
+	let addSilgiContext = false;
+	const importsContent = [
+		...genImports.map(({ specifier, imports, options }) => {
+			return genImport(specifier, imports, options);
+		}),
+		...genTypeImports.map(({ specifier, imports }) => {
+			return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
+		}),
+		""
+	];
+	const importData = [
+		"",
+		`type SchemaExtends = typeof import('${silgiScanTS}')['schemas']`,
+		`type BaseServices = typeof import('${silgiScanTS}')['services']`,
+		`type ResolversExtend = ${data.resolvers?.length ? data.resolvers.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		"",
+		`type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
+		"",
+		data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${data.events.map((item) => {
+			if (item.isSilgiContext) addSilgiContext = true;
+			return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiRuntimeContext" : "";
+		}).join(",\n")}
+}` : "interface SilgiModuleEventsExtends {}",
+		"",
+		`type SetupModuleOptionExtend = ${data.setupModuleOption?.length ? data.setupModuleOption.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type RuntimeMethodExtends = ${data.methods?.length ? data.methods.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type SilgiModuleSharedExtends = ${data.shareds.length ? data.shareds.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type SilgiModuleOptionExtend = ${data.options?.length ? data.options.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type SilgiRuntimeOptionExtends = ${data.runtimeOptions?.length ? data.runtimeOptions.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type RouteRulesExtend = ${data.routeRules?.length ? data.routeRules.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type MetaDataExtend = ${data.metaDatas?.length ? data.metaDatas.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		silgi.options.typescript.generateRuntimeConfigTypes ? generateTypes(await resolveSchema({ ...Object.fromEntries(Object.entries(silgi.options.runtimeConfig).filter(([key]) => ![
+			"app",
+			"nitro",
+			"nuxt"
+		].includes(key))) }), {
+			interfaceName: "SilgiRuntimeConfigExtends",
+			addExport: false,
+			addDefaults: false,
+			allowExtraKeys: false,
+			indentation: 0
+		}) : "",
+		"",
+		generateTypes(await resolveSchema({ ...Object.fromEntries(Object.entries(silgi.options.runtimeConfig).filter(([key]) => ![
+			"app",
+			"nitro",
+			"nuxt"
+		].includes(key))) }), {
+			interfaceName: "SilgiRuntimeConfigExtends",
+			addExport: false,
+			addDefaults: false,
+			allowExtraKeys: false,
+			indentation: 0
+		}),
+		"",
+		generateTypes(await resolveSchema({ ...silgi.services ? Object.values(silgi.services).reduce((acc, service) => {
+			const { route } = getServicePath(service.path);
+			if (route) acc[route] = "";
+			return acc;
+		}, {}) : {} }), {
+			interfaceName: "RoutersExtend",
+			addExport: false,
+			addDefaults: false,
+			allowExtraKeys: false,
+			indentation: 0
+		}),
+		"",
+		`type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		`type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+		"",
+		genAugmentation("silgi/types", {
+			SilgiSchema: [{}, { extends: ["SchemaExtends"] }],
+			ServicesObject: [{}, { extends: ["BaseServices"] }],
+			SilgiStorageBase: [{}, { extends: ["SilgiStorageBaseExtends"] }],
+			SilgiRuntimeContext: [{}, { extends: ["SilgiModuleContextExtends"] }],
+			SilgiEvent: [{}, { extends: ["SilgiModuleEventsExtends"] }],
+			SilgiRuntimeSharedsExtend: [{}, { extends: ["SilgiModuleSharedExtends"] }],
+			SetupModuleOption: [{}, { extends: ["SetupModuleOptionExtend"] }],
+			SilgiRuntimeOptions: [{}, { extends: ["SilgiRuntimeOptionExtends"] }],
+			SilgiRuntimeHooks: [{}, { extends: ["SilgiRuntimeHooksExtends"] }],
+			SilgiRuntimeConfig: [{}, { extends: ["SilgiRuntimeConfigExtends"] }],
+			SilgiHooks: [{}, { extends: ["ModuleHooksExtend"] }],
+			SilgiRuntimeMethods: [{}, { extends: ["RuntimeMethodExtends"] }],
+			Resolvers: [{}, { extends: ["ResolversExtend"] }],
+			SilgiModuleOptions: [{}, { extends: ["SilgiModuleOptionExtend"] }],
+			RouteRules: [{}, { extends: ["RouteRulesExtend"] }],
+			MetaData: [{}, { extends: ["MetaDataExtend"] }],
+			Routers: [{}, { extends: ["RoutersExtend"] }]
+		}).replace(/,\s*/g, "\n"),
+		"",
+		"export {}"
+	];
+	await silgi.callHook("after:schema.ts", importData);
+	importData.unshift(...importsContent);
+	return importData;
+}
+
+//#endregion
+export { prepareSchema };

package/dist/cli/scan/scanExportFile.mjs

@@ -0,0 +1,312 @@
+import { isIgnored } from "../utils/ignore.mjs";
+import { consola as consola$1 } from "consola";
+import { basename, dirname, extname, join, relative, resolve } from "pathe";
+import { useSilgiCLI } from "silgi";
+import { hash, relativeWithDot, removeExtension } from "silgi/kit";
+import { withTrailingSlash } from "ufo";
+import { readFile, readdir } from "node:fs/promises";
+import micromatch from "micromatch";
+import { parseAsync } from "oxc-parser";
+import { glob } from "tinyglobby";
+
+//#region src/cli/scan/scanExportFile.ts
+const DEFAULT_FUNCTION_EXPORT_NAMES = [
+	"createSchema",
+	"createService",
+	"createWebSocket",
+	"createResolver",
+	"createShared",
+	"createMiddleware"
+];
+const DEFAULT_INTERFACE_EXTENDS_NAMES = ["ExtendShared", "ExtendContext"];
+/**
+* Generate a unique identifier for an export based on its file path and name
+* Used to prevent naming collisions when registering exports
+*
+* @param filePath - Path to the file containing the export
+* @param exportName - Name of the exported entity
+* @returns A unique string identifier
+*/
+function generateUniqueIdentifier(filePath, exportName) {
+	const fileBaseName = basename(filePath);
+	const uniqueString = `${fileBaseName}${exportName}`;
+	return hash(uniqueString);
+}
+/**
+* Process extracted exports and categorize them for use in Silgi
+* Separates exports into runtime (scannable) and type-only (schema) groups
+*
+* @param exportedEntities - List of entities exported from a file
+* @param filePath - Path to the source file
+* @param functionExportCategories - Map of function names to categories
+* @param interfaceExportCategories - Map of interface extends names to categories
+* @returns Object containing runtime exports and type-only exports
+*/
+function categorizeExports(exportedEntities, filePath, functionExportCategories = {
+	createService: "service",
+	createWebSocket: "websocket",
+	createSchema: "schema",
+	createShared: "shared",
+	createResolver: "resolver",
+	createMiddleware: "middleware"
+}, interfaceExportCategories = {
+	ExtendShared: "shared",
+	ExtendContext: "context"
+}) {
+	const runtimeExports = [];
+	const typeExports = [];
+	for (const [functionName, category] of Object.entries(functionExportCategories)) {
+		const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
+		for (const exportEntity of matchingExports) {
+			if (!exportEntity.name) continue;
+			runtimeExports.push({
+				exportName: exportEntity.name,
+				path: filePath,
+				uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
+				category
+			});
+		}
+	}
+	for (const [extensionName, category] of Object.entries(interfaceExportCategories)) {
+		const matchingExports = exportedEntities.filter((entity) => entity.declaration === "interface" && entity.extends?.includes(extensionName));
+		for (const exportEntity of matchingExports) {
+			if (!exportEntity.name) continue;
+			typeExports.push({
+				exportName: exportEntity.name,
+				path: filePath,
+				uniqueId: generateUniqueIdentifier(filePath, exportEntity.name),
+				category
+			});
+		}
+	}
+	return {
+		runtimeExports,
+		typeExports
+	};
+}
+/**
+* Transform an import path based on package information
+* If a package name is provided, replace dist and preceding directories with the package name
+*
+* @param path - Original file path
+* @param packageName - Optional package name to use in import path
+* @param relativeTo - Directory to make the path relative to if no package name
+* @returns Transformed import path
+*/
+function transformImportPath(path, packageName, relativeTo) {
+	let importPath = path;
+	if (packageName) {
+		const distMatch = importPath.match(/.*?(\/dist\/.*)/);
+		if (distMatch && distMatch[1]) {
+			importPath = packageName + distMatch[1].substring(5);
+			importPath = removeExtension(importPath, true);
+		}
+	} else if (relativeTo) importPath = removeExtension(relativeWithDot(relativeTo, path));
+	return importPath;
+}
+/**
+* Register discovered exports with the Silgi CLI via hooks
+* This enables Silgi to use these exports in code generation
+*
+* @param silgiInstance - The Silgi CLI instance
+* @param runtimeExports - Runtime exports to register
+* @param typeExports - Type-only exports to register
+* @param packageName - Optional package name for imports
+*/
+function registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName) {
+	silgiInstance.hook("before:scan.ts", (options) => {
+		const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
+		for (const { exportName, path, uniqueId, category } of runtimeExports) {
+			if (!isWatchedPath(path, ignored)) silgiInstance.options.devServer.watch.push(path);
+			switch (category) {
+				case "service":
+					options.services.push(uniqueId);
+					break;
+				case "websocket":
+					options.services?.push?.(uniqueId);
+					break;
+				case "shared":
+					options.shareds.push(uniqueId);
+					break;
+				case "schema":
+					options.schemas.push(uniqueId);
+					break;
+				case "resolver":
+					options.resolvers.push(uniqueId);
+					break;
+				case "middleware":
+					options.middlewares?.push?.(uniqueId);
+					break;
+			}
+			options.addImportItem({
+				specifier: transformImportPath(path, packageName, silgiInstance.options.silgi.serverDir),
+				imports: [{
+					name: exportName,
+					as: uniqueId
+				}]
+			});
+		}
+	});
+	silgiInstance.hook("before:schema.ts", (options) => {
+		const ignored = Array.isArray(silgiInstance.options.watchOptions?.ignored) ? silgiInstance.options.watchOptions.ignored : [];
+		for (const { exportName, path, uniqueId, category } of typeExports) {
+			if (!isWatchedPath(path, ignored)) silgiInstance.options.devServer.watch.push(path);
+			if (category === "shared" || category === "context") {
+				const targetCollection = category === "shared" ? options.shareds : options.contexts;
+				targetCollection.push({
+					key: uniqueId,
+					value: uniqueId
+				});
+			}
+			options.addImportItem({
+				imports: [{
+					name: exportName,
+					as: uniqueId
+				}],
+				specifier: transformImportPath(path, packageName, silgiInstance.options.build.typesDir)
+			});
+		}
+	});
+}
+/**
+* Check for case sensitivity issues in directory paths
+* This helps users identify path issues on case-insensitive file systems
+*
+* @param directoryPath - The directory path to verify
+* @param rootDirectory - The root directory for relative path calculation
+*/
+async function verifyDirectoryCaseSensitivity(directoryPath, rootDirectory) {
+	const directoryName = basename(directoryPath);
+	const parentDirectory = dirname(directoryPath);
+	try {
+		const siblingEntries = await readdir(parentDirectory);
+		if (!siblingEntries.includes(directoryName)) {
+			const directoryNameLowerCase = directoryName.toLowerCase();
+			const caseInsensitiveMatch = siblingEntries.find((sibling) => sibling.toLowerCase() === directoryNameLowerCase);
+			if (caseInsensitiveMatch) {
+				const originalRelative = relative(rootDirectory, directoryPath);
+				const correctedRelative = relative(rootDirectory, join(parentDirectory, caseInsensitiveMatch));
+				consola$1.warn(`Components not scanned from \`~/${correctedRelative}\`. Did you mean to name the directory \`~/${originalRelative}\` instead?`);
+			}
+		}
+	} catch {}
+}
+/**
+* Parse a file and extract exported entities (interfaces and function exports)
+* @param absoluteFilePath - Absolute path to the file
+* @param functionExportNames - Function export names to look for
+* @param interfaceExtendsNames - Interface extends names to look for
+* @returns Array of ExportedEntity
+*/
+async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNames = DEFAULT_FUNCTION_EXPORT_NAMES, interfaceExtendsNames = DEFAULT_INTERFACE_EXTENDS_NAMES) {
+	const exportEntities = [];
+	const fileContent = await readFile(absoluteFilePath, "utf-8");
+	const parsed = await parseAsync(absoluteFilePath, fileContent);
+	for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "TSInterfaceDeclaration") {
+		const decl = node.declaration;
+		if (Array.isArray(decl.extends) && decl.extends.some((dec) => dec.type === "TSInterfaceHeritage" && dec.expression.type === "Identifier" && interfaceExtendsNames.includes(dec.expression.name))) exportEntities.push({
+			name: decl.id?.name,
+			type: "interface",
+			declaration: "interface",
+			extends: decl.extends.filter((e) => e.type === "TSInterfaceHeritage" && e.expression.type === "Identifier").map((e) => e.expression.type === "Identifier" ? e.expression.name : false).filter((name) => Boolean(name))
+		});
+	}
+	for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+		const decls = node.declaration.declarations;
+		if (Array.isArray(decls)) {
+			for (const decl of decls) if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier" && decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier" && functionExportNames.includes(decl.init.callee.name)) {
+				let servicePath;
+				let serviceMethod;
+				if (decl.init.callee.name === "createService" || decl.init.callee.name === "createWebSocket") {
+					const firstArg = decl.init.arguments?.[0];
+					if (firstArg && firstArg.type === "ObjectExpression" && Array.isArray(firstArg.properties)) {
+						for (const prop of firstArg.properties) if (prop.type === "Property" && prop.key.type === "Identifier") {
+							if (prop.key.name === "path" && prop.value.type === "Literal" && typeof prop.value.value === "string") servicePath = prop.value.value;
+							if (prop.key.name === "method" && prop.value.type === "Literal" && typeof prop.value.value === "string") serviceMethod = prop.value.value;
+						}
+					}
+				}
+				exportEntities.push({
+					name: decl.id.name,
+					type: "function",
+					funcName: decl.init.callee.name,
+					servicePath,
+					serviceMethod
+				});
+			}
+		}
+	}
+	return exportEntities;
+}
+/**
+* Main function to scan files for exports and register them with the Silgi CLI
+* This enables automatic discovery and registration of services, schemas, etc.
+*
+* @param path - The path to scan for exports
+* @param packageName - Optional package name for import path transformation
+* @param silgiInstance - The Silgi CLI instance
+* @param scanOptions - Options for scanning
+*/
+async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
+	const processedFilePaths = new Set();
+	const alreadyScannedPaths = [];
+	const serverDirectory = path || silgiInstance.options.serverDir;
+	const functionExportNames = scanOptions.functionExportNames ?? DEFAULT_FUNCTION_EXPORT_NAMES;
+	const interfaceExtendsNames = scanOptions.interfaceExtendsNames ?? DEFAULT_INTERFACE_EXTENDS_NAMES;
+	const functionExportCategories = {};
+	functionExportNames.forEach((name) => {
+		if (name === "createService") functionExportCategories[name] = "service";
+		else if (name === "createWebSocket") functionExportCategories[name] = "websocket";
+		else if (name === "createSchema") functionExportCategories[name] = "schema";
+		else if (name === "createShared") functionExportCategories[name] = "shared";
+		else if (name === "createResolver") functionExportCategories[name] = "resolver";
+		else if (name === "createMiddleware") functionExportCategories[name] = "middleware";
+		else functionExportCategories[name] = name;
+	});
+	const interfaceExportCategories = {};
+	interfaceExtendsNames.forEach((name) => {
+		if (name === "ExtendShared") interfaceExportCategories[name] = "shared";
+		else if (name === "ExtendContext") interfaceExportCategories[name] = "context";
+		else interfaceExportCategories[name] = name;
+	});
+	if (!serverDirectory) {
+		consola$1.warn("No server directory specified for scanning");
+		return;
+	}
+	try {
+		const matchedFiles = await glob(serverDirectory, {
+			cwd: silgiInstance.options.rootDir,
+			ignore: silgiInstance.options.ignore
+		});
+		if (matchedFiles.length) await verifyDirectoryCaseSensitivity(serverDirectory, silgiInstance.options.rootDir);
+		for (const relativeFilePath of matchedFiles.sort()) {
+			const absoluteFilePath = resolve(silgiInstance.options.rootDir, relativeFilePath);
+			if (alreadyScannedPaths.find((path$1) => absoluteFilePath.startsWith(withTrailingSlash(path$1))) || isIgnored(absoluteFilePath, silgiInstance) || processedFilePaths.has(absoluteFilePath)) continue;
+			processedFilePaths.add(absoluteFilePath);
+			const fileExtension = extname(absoluteFilePath);
+			if (!silgiInstance.options.extensions?.includes(fileExtension)) continue;
+			try {
+				const exportEntities = await extractExportEntitiesFromFile(absoluteFilePath, functionExportNames, interfaceExtendsNames);
+				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.`);
+					seenServiceSignatures.set(key, absoluteFilePath);
+				}
+				const allExportedEntities = exportEntities;
+				const { runtimeExports, typeExports } = categorizeExports(allExportedEntities, absoluteFilePath, functionExportCategories, interfaceExportCategories);
+				registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName);
+			} catch (error) {
+				consola$1.error(`Error processing file ${absoluteFilePath}:`, error);
+			}
+		}
+	} catch (error) {
+		consola$1.error("Error scanning export files:", error);
+	}
+}
+function isWatchedPath(path, ignoredPatterns) {
+	return micromatch.isMatch(path, ignoredPatterns);
+}
+
+//#endregion
+export { scanSilgiExports };

package/dist/cli/scan/writeCoreFile.mjs

@@ -0,0 +1,22 @@
+import { prepareCoreFile } from "./prepareCoreFile.mjs";
+import { join, resolve } from "pathe";
+import { writeFile } from "silgi/kit";
+
+//#region src/cli/scan/writeCoreFile.ts
+async function writeCoreFile(silgi) {
+	const coreContent = await prepareCoreFile(silgi);
+	const silgiDir = resolve(silgi.options.silgi.serverDir);
+	const buildFiles = [];
+	buildFiles.push({
+		path: join(silgiDir, "core.ts"),
+		contents: coreContent.join("\n")
+	});
+	buildFiles.push({
+		path: join(silgiDir, "meta.ts"),
+		contents: `export const meta = ${JSON.stringify(silgi.meta, null, 2)}`
+	});
+	for await (const file of buildFiles) if (!silgi.errors.length) await writeFile(resolve(silgi.options.build.dir, file.path), file.contents);
+}
+
+//#endregion
+export { writeCoreFile };