@kosmojs/lib 0.1.8 → 0.2.0

package/pkg/index.js

@@ -1,18 +1,173 @@
 import { builtinModules } from "node:module";
-import { basename, dirname, join, resolve } from "node:path";
 import { styleText } from "node:util";
 import crc from "crc/crc32";
-import { flattener } from "tfusion";
-import { Project, SyntaxKind } from "ts-morph";
+import flattener from "tfusion";
+import { ModuleResolutionKind, Project, SyntaxKind } from "ts-morph";
 import { RequestValidationTargets, defaults } from "@kosmojs/core";
 import { HTTPMethods } from "@kosmojs/core/api";
-import picomatch from "picomatch";
-import { access, constants, mkdir, readFile, writeFile } from "node:fs/promises";
+import { mergeConfig } from "vite";
+import { access, constants, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, parse, resolve } from "node:path";
 import handlebars from "handlebars";
+import picomatch from "picomatch";
 import { glob } from "tinyglobby";
-import { compile, parse } from "path-to-regexp";
-import mimeTypes from "mime-types";
+import { compile, parse as parse$1 } from "path-to-regexp";
+import { lookup } from "mrmime";
 import { Spinner } from "@topcli/spinner";
+//#region src/generic.ts
+var mergeConfigs = (...configs) => {
+	return [{
+		configFile: false,
+		define: {
+			KOSMO_PRODUCTION_BUILD: "false",
+			KOSMO_SERVERSIDE_FETCH: "false"
+		}
+	}, ...configs].reduce((config, prev) => mergeConfig(config || {}, prev || {}), {});
+};
+var escapeTemplateLiterals = (origin) => {
+	return [[/(?<!\\)`/g, "\\`"], [/(?<!\\)\$\{/g, "\\${"]].reduce((text, [a, b]) => text.replace(a, b), origin);
+};
+//#endregion
+//#region src/paths.ts
+var pathResolver = (sourceFolder) => {
+	const createPath = (...a) => {
+		return sourceFolder.root ? resolve(sourceFolder.root, join(...a)) : join(...a);
+	};
+	const createImport = {
+		src(a, { origin }) {
+			return origin === "src" ? join(defaults.srcPrefix, ...a) : join(defaults.appPrefix, defaults.srcDir, sourceFolder.name, ...a);
+		},
+		api(a, o) {
+			return this.src([defaults.apiDir, ...a], o);
+		},
+		entry(a, o) {
+			return this.src([defaults.entryDir, ...a], o);
+		},
+		pages(a, o) {
+			return this.src([defaults.pagesDir, ...a], o);
+		},
+		lib(a, { origin }) {
+			return origin === "src" ? join(defaults.libPrefix, ...a) : join(defaults.appPrefix, defaults.libDir, sourceFolder.name, ...a);
+		},
+		libCore(a, o) {
+			return this.lib(["core", ...a], o);
+		},
+		libApi(a, o) {
+			return this.lib([defaults.apiDir, ...a], o);
+		},
+		libEntry(a, o) {
+			return this.lib([defaults.entryDir, ...a], o);
+		}
+	};
+	return {
+		createPath: {
+			src(...a) {
+				return createPath(defaults.srcDir, sourceFolder.name, ...a);
+			},
+			api(...a) {
+				return this.src(defaults.apiDir, ...a);
+			},
+			pages(...a) {
+				return this.src(defaults.pagesDir, ...a);
+			},
+			entry(...a) {
+				return this.src(defaults.entryDir, ...a);
+			},
+			lib(...a) {
+				return createPath(defaults.libDir, sourceFolder.name, ...a);
+			},
+			libCore(...a) {
+				return this.lib("core", ...a);
+			},
+			libApi(...a) {
+				return this.lib(defaults.apiDir, ...a);
+			},
+			libEntry(...a) {
+				return this.lib(defaults.entryDir, ...a);
+			},
+			libPages(...a) {
+				return this.lib(defaults.pagesDir, ...a);
+			},
+			distDir(...a) {
+				return createPath(sourceFolder.distDir, sourceFolder.name, ...a);
+			}
+		},
+		createImport,
+		createImportHelpers(o) {
+			if (!["src", "lib"].includes(o?.origin)) throw new Error(`createImportHelpers: required exactly one argument of shape { origin: "src|lib" }`);
+			return { createImport(key, ...a) {
+				return createImport[key](a.slice(0, -1), o);
+			} };
+		}
+	};
+};
+var pathExists = async (path) => {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/render.ts
+var render = (template, context, options) => {
+	const { noEscape = true, renderer = handlebars } = { ...options };
+	return renderer.compile(template, { noEscape })(context);
+};
+var renderToFile = async (file, template, context, options) => {
+	const content = render(template, context, options);
+	/**
+	* Two fs calls (exists + read) are worth it to avoid touching the file
+	* and triggering watchers unnecessarily.
+	* */
+	if (await pathExists(file)) {
+		const { overwrite = true } = { ...options };
+		if (overwrite === false) return;
+		const fileContent = await readFile(file, "utf8");
+		if (typeof overwrite === "function" && !overwrite(fileContent)) return;
+		if (crc(content) === crc(fileContent)) return;
+	}
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, content, "utf8");
+};
+var renderFactory = (options) => {
+	const createRenderer = (selfOoptions) => {
+		const renderer = handlebars.create();
+		renderer.registerPartial({
+			...options?.partials,
+			...selfOoptions?.partials
+		});
+		renderer.registerHelper({
+			...options?.helpers,
+			...selfOoptions?.helpers
+		});
+		return renderer;
+	};
+	return {
+		render(template, context, selfOoptions) {
+			return render(template, context, {
+				...options,
+				...selfOoptions,
+				renderer: createRenderer(selfOoptions)
+			});
+		},
+		async renderToFile(file, template, context, selfOoptions) {
+			return renderToFile(options?.outdir ? join(options.outdir, file) : file, template, context, {
+				...options,
+				...selfOoptions,
+				renderer: createRenderer(selfOoptions)
+			});
+		}
+	};
+};
+//#endregion
+//#region src/templates/resolved-types.hbs?raw
+var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
+//#endregion
+//#region src/templates/types.hbs?raw
+var types_default = "{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  \"{{name}}\"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n";
+//#endregion
 //#region src/ast.ts
 var astFactory = () => {
 	const createProject = (opts) => new Project(opts);
@@ -160,7 +315,7 @@ var astFactory = () => {
 					method,
 					target,
 					variants: variants.flatMap((e, i) => {
-						const { status, contentType, body } = extractResponseVariant(e) || {};
+						const { status, contentType, body } = { ...extractResponseVariant(e) };
 						if (!status) return [];
 						if (contentType && typeof contentType !== "string") {
 							console.warn(styleText(["bold", "red"], `✗ The second element of a response variant should specify the Response Content Type`));
@@ -300,11 +455,42 @@ var astFactory = () => {
 	const extractGenerics = (callExpression) => {
 		return callExpression.getTypeArguments();
 	};
-	const typeResolverFactory = ({ root, name }) => {
-		const project = createProject({
-			tsConfigFilePath: resolve(root, join(defaults.srcDir, name, "tsconfig.json")),
-			skipAddingFilesFromTsConfig: true
-		});
+	const typeResolverFactory = (sourceFolder) => {
+		const { createPath } = pathResolver(sourceFolder);
+		const project = createProject({ compilerOptions: {
+			moduleResolution: ModuleResolutionKind.Bundler,
+			types: [],
+			noLib: true,
+			skipLibCheck: true,
+			paths: {
+				[`${defaults.appPrefix}/*`]: [`${sourceFolder.root}/*`],
+				[`${defaults.srcPrefix}/*`]: [createPath.src("*")],
+				[`${defaults.libPrefix}/*`]: [createPath.lib("*")]
+			}
+		} });
+		const withTypeboxSchema = (resolvedTypes) => {
+			const materializedTypes = render(resolved_types_default, { resolvedTypes });
+			const sourceFile = project.createSourceFile(`${crc(materializedTypes)}-${Date.now()}.ts`, materializedTypes, { overwrite: true });
+			const types = resolvedTypes.map((type) => {
+				const typeNode = sourceFile.getTypeAlias(type.name)?.getTypeNode();
+				if (!typeNode) return type;
+				const properties = type.properties ? type.properties.map((prop) => {
+					const propNode = typeNode.isKind(SyntaxKind.TypeLiteral) ? typeNode.getProperty(prop.name)?.getTypeNode() : void 0;
+					if (!propNode) return prop;
+					return {
+						...prop,
+						typeboxSchema: renderTypeboxSchema(propNode)
+					};
+				}) : void 0;
+				return {
+					...type,
+					...properties ? { properties } : {},
+					typeboxSchema: renderTypeboxSchema(typeNode)
+				};
+			});
+			project.removeSourceFile(sourceFile);
+			return types;
+		};
 		const literalTypesResolver = (literalTypes, options) => {
 			const sourceFile = project.createSourceFile(`${crc(literalTypes)}-${Date.now()}.ts`, literalTypes, { overwrite: true });
 			const resolvedTypes = flattener(project, sourceFile, {
@@ -312,7 +498,7 @@ var astFactory = () => {
 				stripComments: true
 			});
 			project.removeSourceFile(sourceFile);
-			return resolvedTypes;
+			return withTypeboxSchema(resolvedTypes);
 		};
 		return {
 			getSourceFile: (fileFullpath) => {
@@ -335,150 +521,61 @@ var astFactory = () => {
 		typeResolverFactory
 	};
 };
-//#endregion
-//#region src/generators.ts
-var defineGenerator = (f) => f;
-var defineGeneratorFactory = (f) => f;
-var createTemplateResolver = (customTemplates, defaultTemplate) => {
-	const templates = Object.entries({ ...customTemplates }).map(([pattern, template]) => [picomatch(pattern), template]);
-	return (pattern, entry) => {
-		const match = templates.find(([isMatch]) => isMatch(pattern));
-		if (!match) return defaultTemplate;
-		return typeof match[1] === "function" ? match[1](entry) : match[1];
-	};
-};
-//#endregion
-//#region src/paths.ts
-var pathResolver = (sourceFolder) => {
-	const createPath = (...a) => {
-		return sourceFolder.root ? resolve(sourceFolder.root, join(...a)) : join(...a);
-	};
-	const createImport = {
-		src(a, { origin }) {
-			return origin === "src" ? join(defaults.srcPrefix, ...a) : join(defaults.appPrefix, defaults.srcDir, sourceFolder.name, ...a);
-		},
-		api(a, o) {
-			return this.src([defaults.apiDir, ...a], o);
-		},
-		pages(a, o) {
-			return this.src([defaults.pagesDir, ...a], o);
-		},
-		lib(a, { origin }) {
-			return origin === "src" ? join(defaults.libPrefix, ...a) : join(defaults.appPrefix, defaults.libDir, sourceFolder.name, ...a);
-		},
-		libCore(a, o) {
-			return this.lib(["core", ...a], o);
-		},
-		libApi(a, o) {
-			return this.lib([defaults.apiDir, ...a], o);
-		},
-		libEntry(a, o) {
-			return this.lib([defaults.entryDir, ...a], o);
+/**
+* Render a ts-morph TypeNode to TypeBox Script text, replacing every VRefine
+* occurrence (at any depth) with the infix `with` form.
+*
+*   VRefine<string, { format: "email" }>            ->  (string with { format: "email" })
+*   VRefine<string, { format: "email" }>[]          ->  (string with { format: "email" })[]
+*   VRefine<Array<string>, { minItems: 1 }>         ->  (Array<string> with { minItems: 1 })
+*   VRefine<Record<string, string>, { maxProperties: 20 }>
+*                                                   ->  (Record<string, string> with { maxProperties: 20 })
+*
+* The parentheses matter: for an array element the `with` clause must bind to
+* the element, not the array, so a VRefine that is the element of an array is
+* wrapped. We wrap unconditionally - harmless when not nested, required when it
+* is.
+*
+* @param typeNode   the node to render
+* @param refineTypeName the configured refine type name
+* */
+var renderTypeboxSchema = (typeNode, refineTypeName = defaults.refineTypeName) => {
+	const traverse = (typeNode) => {
+		if (typeNode.isKind(SyntaxKind.TypeReference) && typeNode.getTypeName().getText() === refineTypeName) {
+			const [inner, opts] = typeNode.getTypeArguments();
+			if (!inner || !opts) return typeNode.getText();
+			return `(${traverse(inner)} with ${opts.getText()})`;
 		}
-	};
-	return {
-		createPath: {
-			src(...a) {
-				return createPath(defaults.srcDir, sourceFolder.name, ...a);
-			},
-			api(...a) {
-				return this.src(defaults.apiDir, ...a);
-			},
-			pages(...a) {
-				return this.src(defaults.pagesDir, ...a);
-			},
-			entry(...a) {
-				return this.src(defaults.entryDir, ...a);
-			},
-			lib(...a) {
-				return createPath(defaults.libDir, sourceFolder.name, ...a);
-			},
-			libCore(...a) {
-				return this.lib("core", ...a);
-			},
-			libApi(...a) {
-				return this.lib(defaults.apiDir, ...a);
-			},
-			libEntry(...a) {
-				return this.lib(defaults.entryDir, ...a);
-			},
-			libPages(...a) {
-				return this.lib(defaults.pagesDir, ...a);
-			},
-			distDir(...a) {
-				return createPath(sourceFolder.distDir, sourceFolder.name, ...a);
-			}
-		},
-		createImport,
-		createImportHelpers(o) {
-			if (!["src", "lib"].includes(o?.origin)) throw new Error(`createImportHelpers: required exactly one argument of shape { origin: "src|lib" }`);
-			return { createImport(key, ...a) {
-				return createImport[key](a.slice(0, -1), o);
-			} };
+		if (typeNode.isKind(SyntaxKind.ArrayType)) return `${traverse(typeNode.getElementTypeNode())}[]`;
+		if (typeNode.isKind(SyntaxKind.TypeLiteral)) {
+			const members = [];
+			for (const member of typeNode.getMembers()) if (member.isKind(SyntaxKind.PropertySignature)) {
+				const name = member.getName();
+				const optional = member.hasQuestionToken() ? "?" : "";
+				const t = member.getTypeNode();
+				const rendered = t ? traverse(t) : "unknown";
+				members.push(`${name}${optional}: ${rendered}`);
+			} else members.push(member.getText());
+			return `{ ${members.join(", ")} }`;
 		}
-	};
-};
-var pathExists = async (path) => {
-	try {
-		await access(path, constants.F_OK);
-		return true;
-	} catch {
-		return false;
-	}
-};
-//#endregion
-//#region src/render.ts
-var render = (template, context, options) => {
-	const { noEscape = true, renderer = handlebars } = { ...options };
-	return renderer.compile(template, { noEscape })(context);
-};
-var renderToFile = async (file, template, context, options) => {
-	const content = render(template, context, options);
-	/**
-	* Two fs calls (exists + read) are worth it to avoid touching the file
-	* and triggering watchers unnecessarily.
-	* */
-	if (await pathExists(file)) {
-		const { overwrite = true } = { ...options };
-		if (overwrite === false) return;
-		const fileContent = await readFile(file, "utf8");
-		if (typeof overwrite === "function" && !overwrite(fileContent)) return;
-		if (crc(content) === crc(fileContent)) return;
-	}
-	await mkdir(dirname(file), { recursive: true });
-	await writeFile(file, content, "utf8");
-};
-var renderFactory = (options) => {
-	const createRenderer = (selfOoptions) => {
-		const renderer = handlebars.create();
-		renderer.registerPartial({
-			...options?.partials,
-			...selfOoptions?.partials
-		});
-		renderer.registerHelper({
-			...options?.helpers,
-			...selfOoptions?.helpers
-		});
-		return renderer;
-	};
-	return {
-		render(template, context, selfOoptions) {
-			return render(template, context, {
-				...options,
-				...selfOoptions,
-				renderer: createRenderer(selfOoptions)
-			});
-		},
-		async renderToFile(file, template, context, selfOoptions) {
-			return renderToFile(options?.outdir ? join(options.outdir, file) : file, template, context, {
-				...options,
-				...selfOoptions,
-				renderer: createRenderer(selfOoptions)
-			});
+		if (typeNode.isKind(SyntaxKind.TupleType)) return `[${typeNode.getElements().map((el) => traverse(el)).join(", ")}]`;
+		if (typeNode.isKind(SyntaxKind.ParenthesizedType)) return `(${traverse(typeNode.getTypeNode())})`;
+		if (typeNode.isKind(SyntaxKind.UnionType)) return typeNode.getTypeNodes().map((t) => traverse(t)).join(" | ");
+		if (typeNode.isKind(SyntaxKind.IntersectionType)) return typeNode.getTypeNodes().map((t) => traverse(t)).join(" & ");
+		if (typeNode.isKind(SyntaxKind.TypeReference)) {
+			const args = typeNode.getTypeArguments();
+			if (args.length === 0) return typeNode.getText();
+			return `${typeNode.getTypeName().getText()}<${args.map((a) => traverse(a)).join(", ")}>`;
 		}
+		return typeNode.getText();
 	};
+	return escapeTemplateLiterals(traverse(typeNode));
 };
 //#endregion
+//#region src/generators.ts
+var defineGenerator = (f) => f;
+var defineGeneratorFactory = (f) => f;
+//#endregion
 //#region src/routes/paths.ts
 /**
 * Parse a filesystem route path into structured PathToken array.
@@ -558,7 +655,7 @@ var pathTokensFactory = (path) => {
 		if (bareParam === ":") throw new Error(`${path} contains colons outside braces, use : only within {}`);
 		else if (bareParam) throw new Error(`${path} contains bare params, use [${bareParam}] instead of :${bareParam}`);
 		const pattern = patternTransforms.reduce((src, fn) => fn(src), orig);
-		const { tokens } = parse(pattern.replace(/\{[^}]*\}|(\+)/g, (m, p1) => p1 ? "\\+" : m));
+		const { tokens } = parse$1(pattern.replace(/\{[^}]*\}|(\+)/g, (m, p1) => p1 ? "\\+" : m));
 		const parts = extractParts(tokens, (val) => {
 			return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc(orig)].join("_") : val;
 		});
@@ -604,7 +701,7 @@ var createHonoPattern = (tokens) => {
 	return tokens.flatMap((token, i) => {
 		if (token.kind === "static") return [token.parts[0].value];
 		if (token.kind === "param") return [paramValue(token.parts[0])];
-		const { tokens } = parse(token.pattern.replace(/\//g, ""));
+		const { tokens } = parse$1(token.pattern.replace(/\//g, ""));
 		return [`:_${i}{${tokensToRegex(tokens)}}`];
 	}).join("/");
 };
@@ -615,9 +712,9 @@ var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
 var API_USE_BASENAME = "use";
 var API_USE_PATTERN = `use.ts`;
 var PAGE_INDEX_BASENAME = "index";
-var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue,mdx,md}`;
+var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue,svelte,mdx,md}`;
 var PAGE_LAYOUT_BASENAME = "layout";
-var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue,mdx}`;
+var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue,svelte,mdx}`;
 var ROUTE_FILE_PATTERNS = [
 	`${defaults.apiDir}/**/${API_INDEX_PATTERN}`,
 	`${defaults.apiDir}/**/${API_USE_PATTERN}`,
@@ -741,12 +838,6 @@ var sortRoutes = (a, b) => {
 	return a.pathPattern.localeCompare(b.pathPattern);
 };
 //#endregion
-//#region src/templates/resolved-types.hbs?raw
-var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
-//#endregion
-//#region src/templates/types.hbs?raw
-var types_default = "{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  \"{{name}}\"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n";
-//#endregion
 //#region src/routes/resolve.ts
 var resolverFactory = (sourceFolder, cacheFactory) => {
 	const { generators = [], refineTypeName = defaults.refineTypeName } = sourceFolder.config;
@@ -831,7 +922,7 @@ var resolverFactory = (sourceFolder, cacheFactory) => {
 						withReferencedFiles: true,
 						sourceFile: getSourceFile(fileFullpath),
 						relpathResolver(path) {
-							return join(sourceFolder.name, defaults.apiDir, dirname(file), path);
+							return join(defaults.srcPrefix, defaults.apiDir, dirname(file), path);
 						}
 					});
 					const validationTypes = validationDefinitions.flatMap((def) => {
@@ -917,8 +1008,8 @@ var resolverFactory = (sourceFolder, cacheFactory) => {
 						variants: def.variants.flatMap((variant, i) => {
 							if (typeof variant.contentType !== "string") return [variant];
 							if (variant.contentType.includes("/")) return [variant];
-							const contentType = mimeTypes.lookup(variant.contentType);
-							if (contentType === false) {
+							const contentType = lookup(variant.contentType);
+							if (!contentType) {
 								console.warn(styleText(["bold", "red"], "✗ Failed resolving Response Content Type"));
 								console.warn(`  Invalid value provided for mime-types lookup - ${variant.contentType}`);
 								console.warn(styleText(["cyan"], `  Response variant #${i} excluded from route schemas`));
@@ -933,8 +1024,8 @@ var resolverFactory = (sourceFolder, cacheFactory) => {
 						})
 					};
 					else if (def.contentType && !def.contentType.includes("/")) {
-						const contentType = mimeTypes.lookup(def.contentType);
-						if (contentType === false) {
+						const contentType = lookup(def.contentType);
+						if (!contentType) {
 							console.warn(styleText(["bold", "red"], "✗ Failed resolving Response Content Type"));
 							console.warn(`  Invalid value provided for mime-types lookup - ${def.contentType}`);
 							console.warn(`  Route: ${name}; Method: ${def.method}`);
@@ -1091,17 +1182,102 @@ var spinnerFactory = (startText) => {
 };
 var withSpinner = (text, pipe, spinner) => pipe(spinner || spinnerFactory(text));
 //#endregion
-//#region src/typebox.ts
-var typeboxLiteralText = (text, sourceFolder) => {
-	const { refineTypeName = defaults.refineTypeName } = sourceFolder.config;
-	return [
-		[/(?<!\\)`/g, "\\`"],
-		[/(?<!\\)\$\{/g, "\\${"],
-		[new RegExp(`\\b${refineTypeName}\\s*<`, "g"), "Options<"]
-	].reduce((text, [a, b]) => text.replace(a, b), text);
-};
-//#endregion
 //#region src/vite.ts
+/**
+* Resolves Kosmo's generated import prefixes to absolute file paths.
+*
+* WHY THIS EXISTS
+* ---------------
+* Every source folder is scaffolded with three tsconfig `paths` prefixes
+* that let generated and user code import across
+* the folder's layout without long relative chains:
+*
+*   appPrefix "@" -> the project root            (<root>/*)
+*   srcPrefix "~" -> the folder's src dir        (<root>/src/<name>/*)
+*   libPrefix "_" -> the folder's lib dir        (<root>/lib/<name>/*)
+*
+* These are the backbone of the generated code: `defineRoute` and friends are
+* emitted with `_/...` imports, pages import layouts and components via `~/...`,
+* and `@/...` reaches shared app-level modules. If a bundler cannot resolve
+* them, nothing the framework generates can be loaded.
+*
+* Historically Vite resolved these through its built-in `resolve.tsconfigPaths: true`,
+* reading the `paths` straight from the generated tsconfig. That option
+* regressed in Vite 8.1.0 (still broken as of 8.1.3): it stops resolving
+* `paths` mappings, especially those defined in an extended / referenced base
+* config - which is exactly Kosmo's structure, where a source folder's
+* tsconfig `extends` `lib/<name>/tsconfig.base.json` and the paths use the
+* TypeScript `${configDir}` variable. The failure surfaces as:
+*
+*   [vite] Failed to resolve import "_/pageSamples/welcome.vue" from
+*   "src/<name>/pages/index/index.vue". Does the file exist?
+*
+* (Upstream: vitejs/vite #22139, #22047, #22371, #21889, #21856.)
+*
+* Rather than pin Vite to 8.0.x indefinitely, or depend on the general-purpose
+* `vite-tsconfig-paths` plugin, this internal plugin resolves ONLY
+* known prefixes against dirs derived from the source folder. That makes it:
+*
+*   - Correct on 8.1.x, where native `tsconfigPaths` is broken.
+*   - Faster: no tsconfig discovery, no `extends` chain walking, no glob
+*     matching - just a prefix check and a handful of `stat` probes,
+*     cached by Vite per specifier.
+*   - Non-blocking: probes via async `fs/promises` `stat`, so `resolveId` never
+*     stalls the event loop.
+*   - `.vue` / `.mdx`-aware: `resolveId` sees every specifier regardless of the
+*     importer's type, so imports from non-JS files resolve without the
+*     `loose` / `allowJs` escape hatches `vite-tsconfig-paths` needs.
+*
+* A project with custom `paths` beyond these three prefixes should install
+* `vite-tsconfig-paths`; this plugin is internal and intentionally narrow.
+*
+* The prefix -> dir bases come from `pathResolver`, the same source of truth the
+* tsconfig generator uses, so alias resolution here can never drift from the
+* paths that were written into the generated tsconfig.
+* */
+var tsconfigPaths = (sourceFolder) => {
+	/**
+	* Candidate extensions for an extensionless specifier, in resolution priority order.
+	* Mirrors the renderable file types the generators emit;
+	* a new page type (e.g. `.svelte`) must be added here or its aliased imports won't resolve.
+	* */
+	const EXTENSIONS = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".vue",
+		".svelte",
+		".md",
+		".mdx",
+		".json"
+	];
+	const { createPath } = pathResolver(sourceFolder);
+	const table = [
+		[`${defaults.srcPrefix}/`, createPath.src()],
+		[`${defaults.libPrefix}/`, createPath.lib()],
+		[`${defaults.appPrefix}/`, sourceFolder.root]
+	];
+	const resolveWithin = async (baseDir, rest) => {
+		const target = join(baseDir, rest);
+		const { ext } = parse(rest);
+		if (EXTENSIONS.includes(ext)) {
+			for (const candidate of [target, `${target}/index${ext}`]) if (await isFile(candidate)) return candidate;
+			return target;
+		}
+		for (const e of EXTENSIONS) for (const candidate of [`${target}${e}`, `${target}/index${e}`]) if (await isFile(candidate)) return candidate;
+		return target;
+	};
+	return {
+		name: "kosmo:tsconfigPaths",
+		enforce: "pre",
+		async resolveId(source) {
+			if (isAbsolute(source) || source.startsWith(".")) return;
+			for (const [prefix, baseDir] of table) if (source.startsWith(prefix)) return resolveWithin(baseDir, source.replace(prefix, ""));
+		}
+	};
+};
 var nodePrefix = () => {
 	return {
 		name: "kosmojs:node-prefix",
@@ -1114,8 +1290,14 @@ var nodePrefix = () => {
 		}
 	};
 };
-var vitePlugins = { nodePrefix };
+var vitePlugins = {
+	tsconfigPaths,
+	nodePrefix
+};
+var isFile = async (path) => {
+	return stat(path).then((e) => e.isFile()).catch(() => false);
+};
 //#endregion
-export { API_INDEX_BASENAME, API_INDEX_PATTERN, API_USE_BASENAME, API_USE_PATTERN, PAGE_INDEX_BASENAME, PAGE_INDEX_PATTERN, PAGE_LAYOUT_BASENAME, PAGE_LAYOUT_PATTERN, astFactory, createHonoPattern, createPathPattern, createRouteEntry, createTemplateResolver, defineGenerator, defineGeneratorFactory, isApiRoute, isApiUse, isPageLayout, isPageRoute, isRouteFile, nestedRoutesFactory, pathExists, pathResolver, pathTokensFactory, render, renderFactory, renderToFile, routesFactory, scanRoutes, sortRoutes, spinnerFactory, typeboxLiteralText, vitePlugins, withSpinner };
+export { API_INDEX_BASENAME, API_INDEX_PATTERN, API_USE_BASENAME, API_USE_PATTERN, PAGE_INDEX_BASENAME, PAGE_INDEX_PATTERN, PAGE_LAYOUT_BASENAME, PAGE_LAYOUT_PATTERN, astFactory, createHonoPattern, createPathPattern, createRouteEntry, defineGenerator, defineGeneratorFactory, escapeTemplateLiterals, isApiRoute, isApiUse, isPageLayout, isPageRoute, isRouteFile, mergeConfigs, nestedRoutesFactory, pathExists, pathResolver, pathTokensFactory, render, renderFactory, renderToFile, routesFactory, scanRoutes, sortRoutes, spinnerFactory, tsconfigPaths, vitePlugins, withSpinner };
 
 //# sourceMappingURL=index.js.map