@vobs/vite-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vobsjs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/vite-plugin
+ */
+declare module '*.html' {
+    const template: import('@vobs/runtime-dom').CompiledTemplate<object>;
+    export default template;
+}
+declare module '*?vobs-image' {
+    export interface VobsImageMetadata {
+        readonly src: string;
+        readonly width: number;
+        readonly height: number;
+        readonly format: 'jpeg' | 'png' | 'svg' | 'webp';
+    }
+    const metadata: VobsImageMetadata;
+    export default metadata;
+}
+declare module '*.svg?raw' {
+    const source: string;
+    export default source;
+}
+declare module 'vobs:icons' {
+    const icons: import('@vobs/icons').IconRegistry;
+    export { icons };
+    export default icons;
+}
+declare module 'vobs:routes' {
+    import type { RouteComponent, RouteRecord, RouterOptions } from '@vobs/router';
+    import type { RouterPort } from '@vobs/runtime-core';
+    export interface GeneratedRoutePathMap {
+    }
+    export type RoutePath = keyof GeneratedRoutePathMap extends never ? string : Extract<keyof GeneratedRoutePathMap, string>;
+    const generatedRoutes: readonly RouteRecord[];
+    const generatedRoutePaths: readonly RoutePath[];
+    const generatedNotFound: RouteComponent | undefined;
+    const generatedError: RouteComponent | undefined;
+    export type GeneratedRoutingManifest = {
+        readonly routes: typeof generatedRoutes;
+        readonly routePaths: typeof generatedRoutePaths;
+        readonly notFound: typeof generatedNotFound;
+        readonly error: typeof generatedError;
+    };
+    export function createRoutingRouter(options?: Omit<RouterOptions, 'routes' | 'notFound' | 'error'>): RouterPort | undefined;
+    const router: RouterPort | undefined;
+    export { generatedError as error, generatedNotFound as notFound, generatedRoutePaths as routePaths, generatedRoutes as routes, };
+    export default router;
+}

package/dist/client.js

@@ -0,0 +1,5 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/vite-plugin
+ */
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/vite-plugin
+ */
+export interface VobsVitePlugin {
+    readonly name: 'vobs-vite-plugin';
+    readonly enforce: 'pre';
+    /** Vite/Rollup binds this hook helper at call time. */
+    addWatchFile?(fileName: string): void;
+    configResolved(config: {
+        readonly root: string;
+    }): void;
+    buildStart(this: VobsBuildStartContext): void;
+    closeWatcher(): void;
+    resolveId(id: string, importer?: string): string | null;
+    load(this: VobsLoadContext, id: string): Promise<string | {
+        readonly code: string;
+        readonly map: object;
+    } | null>;
+    transform(this: VobsTransformContext, code: string, id: string): {
+        readonly code: string;
+        readonly map: object;
+    } | null;
+}
+interface VobsTransformContext {
+    addWatchFile?(fileName: string): void;
+}
+interface VobsLoadContext {
+    addWatchFile?(fileName: string): void;
+}
+interface VobsBuildStartContext {
+    addWatchFile?(fileName: string): void;
+}
+export interface VobsVitePluginOptions {
+    readonly runtimeModule?: string;
+    readonly check?: boolean | VobsViteCheckOptions;
+    readonly routes?: boolean | VobsViteRoutesOptions;
+    readonly images?: boolean;
+    readonly icons?: boolean | VobsViteIconsOptions;
+}
+export interface VobsViteCheckOptions {
+    readonly tsconfigPath?: string;
+    readonly rootNames?: readonly string[];
+    readonly viewFiles?: readonly string[];
+}
+export interface VobsViteRoutesOptions {
+    readonly pagesDir?: string;
+    readonly typesFile?: string;
+}
+export interface VobsViteIconsOptions {
+    readonly config?: string;
+}
+export declare function vobs(options?: VobsVitePluginOptions): VobsVitePlugin;
+export default vobs;

package/dist/index.js

@@ -0,0 +1,1127 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/vite-plugin
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { compileView, createViewProjectChecker, transformOwnerAutoExpose, } from '@vobs/compiler-dom';
+const routesModuleId = 'vobs:routes';
+const resolvedRoutesModuleId = '\0vobs:routes';
+const iconsModuleId = 'vobs:icons';
+const resolvedIconsModuleId = '\0vobs:icons';
+const imageMetadataQuery = 'vobs-image';
+const resolvedImageMetadataPrefix = '\0vobs:image:';
+const resolvedHtmlViewPrefix = '\0vobs:view:';
+export function vobs(options = {}) {
+    let root = process.cwd();
+    let projectChecker;
+    return {
+        name: 'vobs-vite-plugin',
+        enforce: 'pre',
+        configResolved(config) {
+            projectChecker?.dispose();
+            projectChecker = undefined;
+            root = config.root;
+        },
+        buildStart() {
+            if (options.check !== false) {
+                projectChecker ??= createViewProjectChecker(createCheckOptions(root, options.check, options));
+                const result = projectChecker.check();
+                const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'error');
+                const warnings = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'warning');
+                if (warnings.length > 0) {
+                    console.warn(`vobs check warnings\n${formatDiagnostics(warnings)}`);
+                }
+                if (errors.length > 0) {
+                    throw new Error(`vobs check failed\n${formatDiagnostics(errors)}`);
+                }
+            }
+            validateIconProject(root, options, (fileName) => this.addWatchFile?.(fileName));
+        },
+        closeWatcher() {
+            projectChecker?.dispose();
+            projectChecker = undefined;
+        },
+        resolveId(id, importer) {
+            if (id === routesModuleId)
+                return resolvedRoutesModuleId;
+            if (id === iconsModuleId && iconSupportEnabled(options))
+                return resolvedIconsModuleId;
+            const viewFilePath = resolveHtmlViewRequest(id, root, importer);
+            if (viewFilePath !== undefined)
+                return `${resolvedHtmlViewPrefix}${encodeViewModuleId(viewFilePath)}`;
+            const imageFilePath = resolveImageMetadataRequest(id, root, importer, options.images);
+            return imageFilePath === undefined ? null : `${resolvedImageMetadataPrefix}${imageFilePath}`;
+        },
+        async load(id) {
+            if (id.startsWith(resolvedHtmlViewPrefix)) {
+                const filePath = decodeViewModuleId(id.slice(resolvedHtmlViewPrefix.length));
+                const code = await readFile(filePath, 'utf8');
+                this.addWatchFile?.(filePath);
+                return compileHtmlView(code, filePath, options, (dependency) => this.addWatchFile?.(dependency));
+            }
+            if (id.startsWith(resolvedImageMetadataPrefix)) {
+                const filePath = id.slice(resolvedImageMetadataPrefix.length);
+                const metadata = readImageMetadata(filePath, await readFile(filePath));
+                this.addWatchFile?.(filePath);
+                return emitImageMetadataModule(root, filePath, metadata);
+            }
+            if (id === resolvedIconsModuleId) {
+                return emitIconsModule(root, options, (fileName) => this.addWatchFile?.(fileName));
+            }
+            if (id !== resolvedRoutesModuleId)
+                return null;
+            if (options.routes === false)
+                return 'export const routes=[];\nexport const routePaths=[];\nexport const notFound=undefined;\nexport const error=undefined;\n/** @satisfies {import("@vobs/router").RouterOptions} */\nexport function createRoutingRouter(options={}){return undefined;}\nexport default undefined;';
+            const manifest = await collectFileRoutes(root, options.routes);
+            await writeRoutesTypesFile(root, options.routes, manifest);
+            const watchedFiles = new Set();
+            for (const route of manifest.routes) {
+                watchedFiles.add(route.filePath);
+                for (const layout of route.layouts) {
+                    watchedFiles.add(layout);
+                }
+                if (route.error !== undefined) {
+                    watchedFiles.add(route.error);
+                }
+            }
+            if (manifest.notFound !== undefined) {
+                watchedFiles.add(manifest.notFound.filePath);
+            }
+            if (manifest.error !== undefined) {
+                watchedFiles.add(manifest.error);
+            }
+            for (const filePath of watchedFiles) {
+                this.addWatchFile?.(filePath);
+            }
+            return emitRoutesModule(manifest, root);
+        },
+        transform(code, id) {
+            if (id.startsWith(resolvedHtmlViewPrefix))
+                return null;
+            const cleanId = id.split('?')[0];
+            if (cleanId === undefined)
+                return null;
+            if (isTypeScriptModule(cleanId)) {
+                const result = transformOwnerAutoExpose(code, {
+                    sourceId: cleanId,
+                    readFile: readFileIfExists,
+                    globalComponentTags: iconComponentTags(options),
+                });
+                if (!result.changed)
+                    return null;
+                for (const dependency of result.dependencies) {
+                    this.addWatchFile?.(dependency);
+                }
+                return {
+                    code: result.code,
+                    map: result.map,
+                };
+            }
+            if (!cleanId.endsWith('.html'))
+                return null;
+            if (isViteHtmlEntry(cleanId, root))
+                return null;
+            return compileHtmlView(code, cleanId, options, (dependency) => this.addWatchFile?.(dependency));
+        },
+    };
+}
+export default vobs;
+function isTypeScriptModule(id) {
+    return (id.endsWith('.ts') || id.endsWith('.tsx')) && !id.endsWith('.d.ts');
+}
+function resolveHtmlViewRequest(id, root, importer) {
+    if (importer === undefined)
+        return undefined;
+    const request = splitModuleRequest(id);
+    if (request.query !== '')
+        return undefined;
+    if (!request.path.endsWith('.html'))
+        return undefined;
+    const importerPath = importer.split('?')[0];
+    const base = importerPath === undefined ? root : path.dirname(importerPath);
+    const filePath = path.resolve(path.isAbsolute(request.path) ? request.path : path.join(base, request.path));
+    if (!isPathInsideRoot(root, filePath))
+        return undefined;
+    if (isViteHtmlEntry(filePath, root))
+        return undefined;
+    return filePath;
+}
+function encodeViewModuleId(filePath) {
+    return Buffer.from(filePath, 'utf8').toString('base64url');
+}
+function decodeViewModuleId(value) {
+    return Buffer.from(value, 'base64url').toString('utf8');
+}
+function compileHtmlView(code, sourceId, options, addWatchFile) {
+    const result = compileView(code, options.runtimeModule === undefined
+        ? { sourceId }
+        : {
+            sourceId,
+            runtimeModule: options.runtimeModule,
+        });
+    const errors = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'error');
+    const warnings = result.diagnostics.filter((diagnostic) => diagnostic.severity === 'warning');
+    if (warnings.length > 0) {
+        console.warn(formatDiagnostics(warnings));
+    }
+    if (errors.length > 0) {
+        throw new Error(errors.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join('\n'));
+    }
+    for (const dependency of result.dependencies) {
+        if (dependency !== sourceId) {
+            addWatchFile(dependency);
+        }
+    }
+    // HMR (P1-5): template module accept — .html change -> recompile -> notify the runtime to replace the template and remount the page
+    // (hydratePage is registered automatically; standalone page.mount scenarios must call registerPageHmr explicitly).
+    // import.meta.hot is injected by Vite; outside Vite (Node tests) the condition is false, leaving the artifact unaffected.
+    const templateIdMatch = result.code.match(/templateId: "([^"]+)"/);
+    const templateId = templateIdMatch?.[1] ?? sourceId;
+    const hmrBlock = `
+if (import.meta.hot) {
+  import.meta.hot.accept((mod) => {
+    void import(${JSON.stringify(options.runtimeModule ?? '@vobs/runtime-dom')}).then((rt) => {
+      void rt.reloadHmrTemplate(${JSON.stringify(templateId)}, mod?.default);
+    });
+  });
+}`;
+    return {
+        code: `${result.code}\n${hmrBlock}`,
+        map: result.map,
+    };
+}
+function resolveImageMetadataRequest(id, root, importer, enabled) {
+    if (enabled === false)
+        return undefined;
+    const request = splitModuleRequest(id);
+    if (!hasQueryFlag(request.query, imageMetadataQuery))
+        return undefined;
+    if (!isSupportedImageFile(request.path)) {
+        throw new Error(`vobs image metadata only supports PNG, JPEG, WebP, and SVG: ${id}`);
+    }
+    const importerPath = importer?.split('?')[0];
+    const base = importerPath === undefined ? root : path.dirname(importerPath);
+    const filePath = path.resolve(path.isAbsolute(request.path) ? request.path : path.join(base, request.path));
+    if (!isPathInsideRoot(root, filePath)) {
+        throw new Error(`vobs image metadata import must stay inside the Vite root: ${id}`);
+    }
+    return filePath;
+}
+function splitModuleRequest(id) {
+    const queryStart = id.indexOf('?');
+    if (queryStart < 0)
+        return { path: id, query: '' };
+    return { path: id.slice(0, queryStart), query: id.slice(queryStart + 1) };
+}
+function hasQueryFlag(query, flag) {
+    return new URLSearchParams(query).has(flag);
+}
+function isSupportedImageFile(filePath) {
+    return /\.(?:png|jpe?g|webp|svg)$/iu.test(filePath);
+}
+function isPathInsideRoot(root, filePath) {
+    const relative = path.relative(root, filePath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function readImageMetadata(filePath, data) {
+    if (isPng(data)) {
+        return {
+            format: 'png',
+            width: data.readUInt32BE(16),
+            height: data.readUInt32BE(20),
+        };
+    }
+    if (isJpeg(data)) {
+        return readJpegMetadata(filePath, data);
+    }
+    if (isWebp(data)) {
+        return readWebpMetadata(filePath, data);
+    }
+    if (filePath.toLowerCase().endsWith('.svg')) {
+        return readSvgMetadata(filePath, data.toString('utf8'));
+    }
+    throw new Error(`vobs image metadata could not read dimensions for ${filePath}`);
+}
+function isPng(data) {
+    return (data.length >= 24 &&
+        data[0] === 0x89 &&
+        data[1] === 0x50 &&
+        data[2] === 0x4e &&
+        data[3] === 0x47 &&
+        data.toString('ascii', 12, 16) === 'IHDR');
+}
+function isJpeg(data) {
+    return data.length > 4 && data[0] === 0xff && data[1] === 0xd8;
+}
+function readJpegMetadata(filePath, data) {
+    let offset = 2;
+    while (offset + 8 < data.length) {
+        if (data[offset] !== 0xff)
+            break;
+        const marker = data[offset + 1];
+        offset += 2;
+        if (marker === undefined || marker === 0xd9 || marker === 0xda)
+            break;
+        const length = data.readUInt16BE(offset);
+        if (length < 2 || offset + length > data.length)
+            break;
+        if (isJpegStartOfFrame(marker)) {
+            return {
+                format: 'jpeg',
+                height: data.readUInt16BE(offset + 3),
+                width: data.readUInt16BE(offset + 5),
+            };
+        }
+        offset += length;
+    }
+    throw new Error(`vobs image metadata could not read JPEG dimensions for ${filePath}`);
+}
+function isJpegStartOfFrame(marker) {
+    return ((marker >= 0xc0 && marker <= 0xc3) ||
+        (marker >= 0xc5 && marker <= 0xc7) ||
+        (marker >= 0xc9 && marker <= 0xcb) ||
+        (marker >= 0xcd && marker <= 0xcf));
+}
+function isWebp(data) {
+    return (data.length >= 30 &&
+        data.toString('ascii', 0, 4) === 'RIFF' &&
+        data.toString('ascii', 8, 12) === 'WEBP');
+}
+function readWebpMetadata(filePath, data) {
+    const chunk = data.toString('ascii', 12, 16);
+    if (chunk === 'VP8X') {
+        return {
+            format: 'webp',
+            width: 1 + readUInt24LE(data, 24),
+            height: 1 + readUInt24LE(data, 27),
+        };
+    }
+    if (chunk === 'VP8L' && data[20] === 0x2f) {
+        return {
+            format: 'webp',
+            width: 1 + data[21] + ((data[22] & 0x3f) << 8),
+            height: 1 + ((data[22] & 0xc0) >> 6) + (data[23] << 2) + ((data[24] & 0x0f) << 10),
+        };
+    }
+    if (chunk === 'VP8 ' && data.toString('hex', 23, 26) === '9d012a') {
+        return {
+            format: 'webp',
+            width: data.readUInt16LE(26) & 0x3fff,
+            height: data.readUInt16LE(28) & 0x3fff,
+        };
+    }
+    throw new Error(`vobs image metadata could not read WebP dimensions for ${filePath}`);
+}
+function readUInt24LE(data, offset) {
+    return data[offset] + (data[offset + 1] << 8) + (data[offset + 2] << 16);
+}
+function readSvgMetadata(filePath, source) {
+    const width = readSvgNumericAttribute(source, 'width');
+    const height = readSvgNumericAttribute(source, 'height');
+    if (width !== undefined && height !== undefined) {
+        return { format: 'svg', width, height };
+    }
+    const viewBox = /\bviewBox\s*=\s*["']\s*[-\d.]+\s+[-\d.]+\s+([-\d.]+)\s+([-\d.]+)/u.exec(source);
+    if (viewBox?.[1] !== undefined && viewBox[2] !== undefined) {
+        return {
+            format: 'svg',
+            width: Number(viewBox[1]),
+            height: Number(viewBox[2]),
+        };
+    }
+    throw new Error(`vobs image metadata could not read SVG dimensions for ${filePath}`);
+}
+function readSvgNumericAttribute(source, name) {
+    const match = new RegExp(`\\b${name}\\s*=\\s*["']([\\d.]+)(?:px)?["']`, 'u').exec(source);
+    return match?.[1] === undefined ? undefined : Number(match[1]);
+}
+function emitImageMetadataModule(root, filePath, metadata) {
+    const source = `/${normalizeSlash(path.relative(root, filePath))}`;
+    return `import src from ${JSON.stringify(source)};\nexport default {src,width:${metadata.width},height:${metadata.height},format:${JSON.stringify(metadata.format)}};`;
+}
+function readFileIfExists(fileName) {
+    try {
+        return readFileSync(fileName, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function createCheckOptions(root, options, pluginOptions) {
+    const globalComponentTags = iconComponentTags(pluginOptions);
+    if (options === undefined || typeof options === 'boolean') {
+        return {
+            tsconfigPath: path.join(root, 'tsconfig.json'),
+            ...(globalComponentTags.length === 0 ? {} : { globalComponentTags }),
+        };
+    }
+    return {
+        ...options,
+        tsconfigPath: options.tsconfigPath === undefined
+            ? path.join(root, 'tsconfig.json')
+            : path.resolve(root, options.tsconfigPath),
+        ...(globalComponentTags.length === 0 ? {} : { globalComponentTags }),
+    };
+}
+function iconComponentTags(options) {
+    const tags = ['k-app-shell'];
+    if (iconSupportEnabled(options))
+        tags.push('k-icon');
+    return tags;
+}
+function iconSupportEnabled(options) {
+    return options?.icons !== undefined && options.icons !== false;
+}
+function emitIconsModule(root, options, addWatchFile) {
+    const config = readIconConfig(root, options);
+    addWatchFile(config.filePath);
+    const templateIcons = collectTemplateIconNames(root, options, config, addWatchFile);
+    const iconNames = Array.from(new Set([...config.shellIcons, ...templateIcons])).sort();
+    const imports = [
+        "import { createIconRegistry } from '@vobs/icons';",
+        "import { defineIconFromSvg } from '@vobs/icons/svg';",
+    ];
+    const entries = [];
+    iconNames.forEach((iconName, index) => {
+        const source = resolveConfiguredIcon(root, config, iconName);
+        addWatchFile(source.filePath);
+        const importName = `__vobsIcon${index}`;
+        imports.push(`import ${importName} from ${JSON.stringify(source.importRequest)};`);
+        entries.push(`${JSON.stringify(iconName)}: defineIconFromSvg(${JSON.stringify(iconName)}, ${importName})`);
+    });
+    return `${imports.join('\n')}\n\nconst definitions = {\n  ${entries.join(',\n  ')}\n};\n\nexport const icons = createIconRegistry(definitions);\nexport default icons;`;
+}
+function validateIconProject(root, options, addWatchFile) {
+    if (!iconSupportEnabled(options))
+        return;
+    const config = readIconConfig(root, options);
+    addWatchFile(config.filePath);
+    const templateIcons = collectTemplateIconNames(root, options, config, addWatchFile);
+    const iconNames = Array.from(new Set([...config.shellIcons, ...templateIcons]));
+    for (const iconName of iconNames) {
+        const source = resolveConfiguredIcon(root, config, iconName);
+        addWatchFile(source.filePath);
+    }
+}
+function readIconConfig(root, options) {
+    const filePath = iconConfigPath(root, options);
+    const source = readFileIfExists(filePath);
+    if (source === undefined) {
+        throw new Error(`vobs icon config not found: ${filePath}`);
+    }
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+    const configObject = findDefaultIconConfigObject(sourceFile);
+    if (configObject === undefined) {
+        throw new Error(`vobs icon config must export default defineIconConfig({...}): ${filePath}`);
+    }
+    return {
+        filePath,
+        sources: readIconSources(configObject, filePath),
+        ...readShellIconManifest(configObject, filePath),
+    };
+}
+function iconConfigPath(root, options) {
+    const configured = typeof options.icons === 'object' ? options.icons.config : undefined;
+    return path.resolve(root, configured ?? 'vobs.icons.ts');
+}
+function findDefaultIconConfigObject(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement))
+            continue;
+        const expression = unwrapExpression(statement.expression);
+        if (ts.isCallExpression(expression) && expression.arguments.length === 1) {
+            const argument = expression.arguments[0];
+            if (argument !== undefined && ts.isObjectLiteralExpression(argument))
+                return argument;
+        }
+        if (ts.isObjectLiteralExpression(expression))
+            return expression;
+    }
+    return undefined;
+}
+function readIconSources(configObject, filePath) {
+    const sources = readObjectProperty(configObject, 'sources');
+    if (sources === undefined || !ts.isObjectLiteralExpression(sources)) {
+        throw new Error(`vobs icon config requires a static sources object: ${filePath}`);
+    }
+    const result = {};
+    for (const property of sources.properties) {
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const sourceName = readPropertyName(property.name);
+        if (sourceName === undefined)
+            continue;
+        result[sourceName] = readSvgIconSource(property.initializer, filePath, sourceName);
+    }
+    return result;
+}
+function readSvgIconSource(expression, filePath, sourceName) {
+    const call = unwrapExpression(expression);
+    if (!ts.isCallExpression(call)) {
+        throw new Error(`Icon source "${sourceName}" must use svgIconSource(...): ${filePath}`);
+    }
+    const packageName = readStringLiteral(call.arguments[0]);
+    if (packageName === undefined) {
+        throw new Error(`Icon source "${sourceName}" requires a static package name: ${filePath}`);
+    }
+    const options = call.arguments[1];
+    return {
+        packageName,
+        ...(options === undefined ? {} : readSvgIconSourceOptions(options, filePath, sourceName)),
+    };
+}
+function readSvgIconSourceOptions(expression, filePath, sourceName) {
+    const options = unwrapExpression(expression);
+    if (!ts.isObjectLiteralExpression(options)) {
+        throw new Error(`Icon source "${sourceName}" options must be a static object: ${filePath}`);
+    }
+    const size = readOptionalNumberProperty(options, 'size', filePath, sourceName);
+    const variant = readOptionalStringProperty(options, 'variant', filePath, sourceName);
+    const customPath = readOptionalStringProperty(options, 'path', filePath, sourceName);
+    return {
+        ...(size === undefined ? {} : { size }),
+        ...(variant === undefined ? {} : { variant }),
+        ...(customPath === undefined ? {} : { path: customPath }),
+    };
+}
+function readShellIconManifest(configObject, filePath) {
+    const shell = readObjectProperty(configObject, 'shell');
+    if (shell === undefined)
+        return { shellIcons: [], shellGroups: new Set() };
+    if (!ts.isObjectLiteralExpression(shell)) {
+        throw new Error(`vobs icon shell manifest must be a static object: ${filePath}`);
+    }
+    const icons = [];
+    const groups = new Set();
+    for (const property of shell.properties) {
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const propertyName = readPropertyName(property.name);
+        if (propertyName === undefined)
+            continue;
+        groups.add(`shell.${propertyName}`);
+        collectStringArrayValues(property.initializer, icons, filePath);
+    }
+    return { shellIcons: icons, shellGroups: groups };
+}
+function collectTemplateIconNames(root, options, config, addWatchFile) {
+    const pagesRoot = path.resolve(root, typeof options.routes === 'object' && options.routes.pagesDir !== undefined
+        ? options.routes.pagesDir
+        : 'src/pages');
+    const htmlFiles = walkHtmlFiles(pagesRoot);
+    const icons = [];
+    for (const file of htmlFiles) {
+        addWatchFile(file);
+        const source = readFileSync(file, 'utf8');
+        for (const tag of source.matchAll(/<k-icon\b[^>]*>/giu)) {
+            const tagSource = tag[0];
+            diagnoseDynamicIconName(file, tagSource, config);
+            const nameMatch = /(?:^|\s)name=(["'])([^"']+)\1/iu.exec(tagSource);
+            const name = nameMatch?.[2];
+            if (name !== undefined)
+                icons.push(name);
+        }
+    }
+    return icons;
+}
+function diagnoseDynamicIconName(filePath, tagSource, config) {
+    if (!/(?:^|\s):name=(["'])([^"']+)\1/iu.test(tagSource))
+        return;
+    const manifest = /(?:^|\s)data-icon-manifest=(["'])([^"']+)\1/iu.exec(tagSource)?.[2];
+    if (manifest === undefined) {
+        throw new Error(`Dynamic k-icon names are not supported. Use static name="source:name" or a declared shell manifest binding: ${filePath}`);
+    }
+    if (!config.shellGroups.has(manifest)) {
+        throw new Error(`Unknown k-icon shell manifest binding "${manifest}": ${filePath}`);
+    }
+}
+function walkHtmlFiles(directory) {
+    let entries;
+    try {
+        entries = readdirSyncCompat(directory);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const filePath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkHtmlFiles(filePath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.html')) {
+            files.push(filePath);
+        }
+    }
+    return files;
+}
+function readdirSyncCompat(directory) {
+    return readdirSync(directory, { withFileTypes: true });
+}
+function resolveConfiguredIcon(root, config, iconName) {
+    const [sourceName, localName] = splitIconName(iconName);
+    const source = config.sources[sourceName];
+    if (source === undefined) {
+        throw new Error(`Icon source is not configured: ${sourceName} (${iconName})`);
+    }
+    const directory = resolveIconSourceDirectory(root, source);
+    const filePath = path.join(directory, `${localName}.svg`);
+    if (readFileIfExists(filePath) === undefined) {
+        throw new Error(`Icon SVG not found: ${iconName} -> ${filePath}`);
+    }
+    return {
+        filePath,
+        importRequest: iconImportRequest(root, source, localName),
+    };
+}
+function splitIconName(iconName) {
+    const match = /^([a-z][a-z0-9-]*):([a-z][a-z0-9-]*)$/u.exec(iconName);
+    if (match?.[1] === undefined || match[2] === undefined) {
+        throw new Error(`Icon name must use source:name format: ${iconName}`);
+    }
+    return [match[1], match[2]];
+}
+function resolveIconSourceDirectory(root, source) {
+    const base = source.packageName.startsWith('.')
+        ? path.resolve(root, source.packageName)
+        : resolvePackageRoot(root, source.packageName);
+    return path.resolve(base, source.path ?? knownIconSourcePath(source));
+}
+function iconImportRequest(root, source, localName) {
+    const sourcePath = source.path ?? knownIconSourcePath(source);
+    const relativeIconPath = normalizeSlash(path.join(sourcePath, `${localName}.svg`));
+    if (!source.packageName.startsWith('.'))
+        return `${source.packageName}/${relativeIconPath}?raw`;
+    const filePath = path.resolve(root, source.packageName, relativeIconPath);
+    return `/${normalizeSlash(path.relative(root, filePath))}?raw`;
+}
+function resolvePackageRoot(root, packageName) {
+    const projectRequire = createRequire(path.join(root, 'package.json'));
+    return path.dirname(projectRequire.resolve(`${packageName}/package.json`));
+}
+function knownIconSourcePath(source) {
+    switch (source.packageName) {
+        case 'heroicons':
+            return `${source.size ?? 24}/${source.variant ?? 'outline'}`;
+        case 'lucide-static':
+        case 'bootstrap-icons':
+        case 'simple-icons':
+            return 'icons';
+        case '@tabler/icons':
+            return `icons/${source.variant ?? 'outline'}`;
+        case '@mdi/svg':
+            return 'svg';
+        case '@carbon/icons':
+            return `svg/${source.size ?? 24}`;
+        default:
+            return source.path ?? '';
+    }
+}
+function collectStringArrayValues(expression, values, filePath) {
+    const array = unwrapExpression(expression);
+    if (!ts.isArrayLiteralExpression(array)) {
+        throw new Error(`vobs icon manifest entries must be static string arrays: ${filePath}`);
+    }
+    for (const element of array.elements) {
+        const value = readStringLiteral(element);
+        if (value === undefined) {
+            throw new Error(`vobs icon manifest entries must be static strings: ${filePath}`);
+        }
+        values.push(value);
+    }
+}
+function readObjectProperty(objectLiteral, name) {
+    for (const property of objectLiteral.properties) {
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        if (readPropertyName(property.name) === name)
+            return property.initializer;
+    }
+    return undefined;
+}
+function readPropertyName(name) {
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+function readStringLiteral(expression) {
+    const unwrapped = expression === undefined ? undefined : unwrapExpression(expression);
+    return unwrapped !== undefined && ts.isStringLiteralLike(unwrapped) ? unwrapped.text : undefined;
+}
+function readOptionalStringProperty(objectLiteral, name, filePath, sourceName) {
+    const property = readObjectProperty(objectLiteral, name);
+    if (property === undefined)
+        return undefined;
+    const value = readStringLiteral(property);
+    if (value === undefined) {
+        throw new Error(`Icon source "${sourceName}" option "${name}" must be a string: ${filePath}`);
+    }
+    return value;
+}
+function readOptionalNumberProperty(objectLiteral, name, filePath, sourceName) {
+    const property = readObjectProperty(objectLiteral, name);
+    if (property === undefined)
+        return undefined;
+    const value = unwrapExpression(property);
+    if (!ts.isNumericLiteral(value)) {
+        throw new Error(`Icon source "${sourceName}" option "${name}" must be a number: ${filePath}`);
+    }
+    return Number(value.text);
+}
+function unwrapExpression(expression) {
+    let current = ts.skipPartiallyEmittedExpressions(expression);
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isTypeAssertionExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current)) {
+        current = ts.skipPartiallyEmittedExpressions(current.expression);
+    }
+    return current;
+}
+function formatDiagnostics(diagnostics) {
+    return diagnostics.map(formatDiagnostic).join('\n');
+}
+function formatDiagnostic(diagnostic) {
+    const source = diagnostic.sourceId ?? 'project';
+    const position = diagnostic.start === undefined ? '' : `:${diagnostic.start.line}:${diagnostic.start.column}`;
+    return `${source}${position} ${diagnostic.severity.toUpperCase()} ${diagnostic.code}: ${diagnostic.message}`;
+}
+async function collectFileRoutes(root, options) {
+    const pagesRoot = path.resolve(root, typeof options === 'object' && options.pagesDir !== undefined ? options.pagesDir : 'src/pages');
+    const [routes, notFound, error] = await Promise.all([
+        walkPages(pagesRoot, pagesRoot).catch((error) => {
+            if (isFileNotFound(error))
+                return [];
+            throw error;
+        }),
+        findNotFoundRoute(pagesRoot),
+        findSpecialPage(pagesRoot, '_error.ts'),
+    ]);
+    validateFileRouteConflicts(routes, pagesRoot);
+    return {
+        routes: routes.sort(compareFileRoutes),
+        ...(notFound === undefined ? {} : { notFound }),
+        ...(error === undefined ? {} : { error }),
+    };
+}
+async function findNotFoundRoute(pagesRoot) {
+    const filePath = await findSpecialPage(pagesRoot, '_404.ts');
+    if (filePath === undefined)
+        return undefined;
+    return {
+        path: '*',
+        filePath,
+        layouts: [],
+        g: false,
+        l: false,
+        score: [2],
+    };
+}
+async function walkPages(directory, pagesRoot, parentLayouts = [], parentError) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const routes = [];
+    const layouts = await layoutChainForDirectory(directory, parentLayouts);
+    const error = (await findSpecialPage(directory, '_error.ts')) ?? parentError;
+    for (const entry of entries) {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            routes.push(...(await walkPages(entryPath, pagesRoot, layouts, error)));
+            continue;
+        }
+        if (!isPageFile(entry.name))
+            continue;
+        const routePath = routePathForFile(entryPath, pagesRoot);
+        if (routePath === undefined)
+            continue;
+        const source = await readFile(entryPath, 'utf8');
+        const meta = readStaticRouteMeta(source);
+        routes.push({
+            path: routePath,
+            filePath: entryPath,
+            layouts,
+            ...(error === undefined ? {} : { error }),
+            ...(meta === undefined ? {} : { meta }),
+            g: hasExportedRouteMember(source, 'guard'),
+            l: hasExportedRouteMember(source, 'loader'),
+            score: scoreRoutePath(routePath),
+        });
+    }
+    return routes;
+}
+async function findSpecialPage(directory, fileName) {
+    const filePath = path.join(directory, fileName);
+    try {
+        await access(filePath);
+    }
+    catch (error) {
+        if (isFileNotFound(error))
+            return undefined;
+        throw error;
+    }
+    return filePath;
+}
+function hasExportedRouteMember(source, name) {
+    const directExportPattern = new RegExp(`^\\s*export\\s+(?:(?:async\\s+)?function|const|let|var)\\s+${name}\\b`, 'mu');
+    if (directExportPattern.test(source)) {
+        return true;
+    }
+    for (const match of source.matchAll(/^\s*export\s*\{([^}]*)\}/gmu)) {
+        const specifiers = match[1]?.split(',') ?? [];
+        if (specifiers.some((specifier) => isRouteMemberExportSpecifier(specifier, name)))
+            return true;
+    }
+    return false;
+}
+function readStaticRouteMeta(source) {
+    const match = /^\s*export\s+(?:const|let|var)\s+meta\s*=\s*/mu.exec(source);
+    if (match === null)
+        return undefined;
+    const objectStart = source.indexOf('{', match.index + match[0].length);
+    if (objectStart < 0) {
+        throw new Error('vobs file route meta must be a static object literal');
+    }
+    const objectEnd = findMatchingBrace(source, objectStart);
+    if (objectEnd < 0) {
+        throw new Error('vobs file route meta must be a static object literal');
+    }
+    return source.slice(objectStart, objectEnd + 1);
+}
+function findMatchingBrace(source, openIndex) {
+    let depth = 0;
+    let state = 'code';
+    for (let index = openIndex; index < source.length; index += 1) {
+        const character = source[index];
+        const next = source[index + 1];
+        if (state === 'line-comment') {
+            if (character === '\n')
+                state = 'code';
+            continue;
+        }
+        if (state === 'block-comment') {
+            if (character === '*' && next === '/') {
+                state = 'code';
+                index += 1;
+            }
+            continue;
+        }
+        if (state === 'single') {
+            if (character === '\\') {
+                index += 1;
+            }
+            else if (character === "'") {
+                state = 'code';
+            }
+            continue;
+        }
+        if (state === 'double') {
+            if (character === '\\') {
+                index += 1;
+            }
+            else if (character === '"') {
+                state = 'code';
+            }
+            continue;
+        }
+        if (state === 'template') {
+            if (character === '\\') {
+                index += 1;
+            }
+            else if (character === '`') {
+                state = 'code';
+            }
+            continue;
+        }
+        if (character === '/' && next === '/') {
+            state = 'line-comment';
+            index += 1;
+            continue;
+        }
+        if (character === '/' && next === '*') {
+            state = 'block-comment';
+            index += 1;
+            continue;
+        }
+        if (character === "'") {
+            state = 'single';
+            continue;
+        }
+        if (character === '"') {
+            state = 'double';
+            continue;
+        }
+        if (character === '`') {
+            state = 'template';
+            continue;
+        }
+        if (character === '{') {
+            depth += 1;
+            continue;
+        }
+        if (character === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function isRouteMemberExportSpecifier(source, name) {
+    const specifier = source.trim().replace(/^type\s+/u, '');
+    if (specifier === name)
+        return true;
+    const [, exported] = /^[$A-Z_a-z][$\w]*\s+as\s+([$A-Z_a-z][$\w]*)$/u.exec(specifier) ?? [];
+    return exported === name;
+}
+async function layoutChainForDirectory(directory, parentLayouts) {
+    const layoutPath = path.join(directory, '_layout.ts');
+    try {
+        await access(layoutPath);
+    }
+    catch (error) {
+        if (isFileNotFound(error))
+            return parentLayouts;
+        throw error;
+    }
+    return [...parentLayouts, layoutPath];
+}
+function isPageFile(fileName) {
+    return fileName.endsWith('.ts') && !fileName.endsWith('.d.ts') && !fileName.startsWith('_');
+}
+function routePathForFile(filePath, pagesRoot) {
+    const relative = normalizeSlash(path.relative(pagesRoot, filePath));
+    const withoutExtension = relative.slice(0, -'.ts'.length);
+    const rawSegments = withoutExtension.split('/');
+    const segments = rawSegments.flatMap((segment) => {
+        if (segment === 'index')
+            return [];
+        if (segment.startsWith('(') && segment.endsWith(')'))
+            return [];
+        if (segment.startsWith('[...') && segment.endsWith(']'))
+            return [`*${segment.slice(4, -1)}`];
+        if (segment.startsWith('[') && segment.endsWith(']'))
+            return [`:${segment.slice(1, -1)}`];
+        return [segment];
+    });
+    if (segments.some((segment) => segment === ':' || segment === '*'))
+        return undefined;
+    return segments.length === 0 ? '/' : `/${segments.join('/')}`;
+}
+function scoreRoutePath(routePath) {
+    if (routePath === '/')
+        return [0];
+    return routePath.split('/').slice(1).map(scoreRouteSegment);
+}
+function scoreRouteSegment(segment) {
+    if (segment.startsWith('*'))
+        return 2;
+    if (segment.startsWith(':'))
+        return 1;
+    return 0;
+}
+function compareFileRoutes(left, right) {
+    const length = Math.max(left.score.length, right.score.length);
+    for (let index = 0; index < length; index += 1) {
+        const scoreDelta = (left.score[index] ?? 0) - (right.score[index] ?? 0);
+        if (scoreDelta !== 0)
+            return scoreDelta;
+    }
+    if (left.score.length !== right.score.length)
+        return left.score.length - right.score.length;
+    return left.path.localeCompare(right.path);
+}
+function validateFileRouteConflicts(routes, pagesRoot) {
+    const exactPathGroups = groupFileRoutes(routes, (route) => route.path);
+    const patternGroups = groupFileRoutes(routes, (route) => routePatternKey(route.path));
+    const diagnostics = [];
+    for (const [routePath, group] of exactPathGroups) {
+        if (group.length < 2)
+            continue;
+        diagnostics.push(formatFileRouteConflict(`Duplicate file route path "${routePath}"`, group, pagesRoot));
+    }
+    for (const [pattern, group] of patternGroups) {
+        if (group.length < 2 || new Set(group.map((route) => route.path)).size < 2)
+            continue;
+        diagnostics.push(formatFileRouteConflict(`Ambiguous file route pattern "${pattern}"`, group, pagesRoot));
+    }
+    if (diagnostics.length === 0)
+        return;
+    throw new Error(`vobs file route conflict\n${diagnostics.sort().join('\n')}`);
+}
+function groupFileRoutes(routes, readKey) {
+    const groups = new Map();
+    for (const route of routes) {
+        const key = readKey(route);
+        const group = groups.get(key);
+        if (group === undefined) {
+            groups.set(key, [route]);
+        }
+        else {
+            group.push(route);
+        }
+    }
+    return groups;
+}
+function routePatternKey(routePath) {
+    if (routePath === '/')
+        return '/';
+    return routePath
+        .split('/')
+        .map((segment) => {
+        if (segment.startsWith(':'))
+            return ':';
+        if (segment.startsWith('*'))
+            return '*';
+        return segment;
+    })
+        .join('/');
+}
+function formatFileRouteConflict(title, routes, pagesRoot) {
+    return [
+        `- ${title}:`,
+        ...[...routes]
+            .sort((left, right) => relativeFileRoutePath(left, pagesRoot).localeCompare(relativeFileRoutePath(right, pagesRoot)))
+            .map((route) => `  - ${route.path} from ${relativeFileRoutePath(route, pagesRoot)}`),
+    ].join('\n');
+}
+function relativeFileRoutePath(route, pagesRoot) {
+    return normalizeSlash(path.relative(pagesRoot, route.filePath));
+}
+function emitRoutesModule(manifest, root) {
+    const lines = [];
+    const routeTree = createFileRouteTree(manifest.routes);
+    const routeNames = new Map();
+    manifest.routes.forEach((route, index) => {
+        const routeName = `__route${index}`;
+        const componentName = `${routeName}Component`;
+        routeNames.set(route, routeName);
+        const importPath = toRootImport(route.filePath, root);
+        lines.push(`const ${componentName}=()=>import(${JSON.stringify(importPath)});`);
+        const layouts = route.layouts.length === 0
+            ? ''
+            : `,layouts:[${route.layouts
+                .map((layout) => `()=>import(${JSON.stringify(toRootImport(layout, root))})`)
+                .join(',')}]`;
+        const error = route.error === undefined
+            ? ''
+            : `,error:()=>import(${JSON.stringify(toRootImport(route.error, root))})`;
+        const meta = route.meta === undefined ? '' : `,meta:${route.meta}`;
+        const guard = route.g ? `,guard:c=>${componentName}().then(m=>m.guard(c))` : '';
+        const loader = route.l ? `,loader:c=>${componentName}().then(m=>m.loader(c))` : '';
+        lines.push(`/** @satisfies {import("@vobs/router").PageRouteRecord<typeof ${componentName}>} */`);
+        lines.push(`const ${routeName}={path:${JSON.stringify(routeTree.emittedPaths.get(route) ?? route.path)},component:${componentName}${layouts}${error}${meta}${guard}${loader}};`);
+    });
+    const rootRouteNames = [];
+    if (routeTree.rootRoute !== undefined) {
+        rootRouteNames.push(routeNames.get(routeTree.rootRoute));
+    }
+    let groupIndex = 0;
+    for (const node of routeTree.nodes) {
+        rootRouteNames.push(emitFileRouteTreeNode(node, true));
+    }
+    lines.push(`export const routes=[${rootRouteNames.join(',')}];`);
+    lines.push(`export const routePaths=[${manifest.routes.map((route) => JSON.stringify(route.path)).join(',')}];`);
+    lines.push('/** @satisfies {import("@vobs/router").RouteComponent | undefined} */');
+    lines.push(manifest.notFound === undefined
+        ? 'export const notFound=undefined;'
+        : `export const notFound=()=>import(${JSON.stringify(toRootImport(manifest.notFound.filePath, root))});`);
+    lines.push('/** @satisfies {import("@vobs/router").RouteComponent | undefined} */');
+    lines.push(manifest.error === undefined
+        ? 'export const error=undefined;'
+        : `export const error=()=>import(${JSON.stringify(toRootImport(manifest.error, root))});`);
+    lines.push("import { createRouter } from '@vobs/router';");
+    lines.push('/** @satisfies {import("@vobs/router").RouterOptions} */');
+    lines.push('export function createRoutingRouter(options={}){return createRouter({routes,notFound,error,...options});}');
+    lines.push('/** @satisfies {import("@vobs/runtime-core").RouterPort} */');
+    lines.push('const router=createRoutingRouter({history:true});');
+    lines.push('export default router;');
+    return lines.join('\n');
+    function emitFileRouteTreeNode(node, rootNode) {
+        if (node.children.length === 0)
+            return routeNames.get(node.route);
+        const children = [
+            ...(node.route === undefined ? [] : [routeNames.get(node.route)]),
+            ...node.children.map((child) => emitFileRouteTreeNode(child, false)),
+        ];
+        const groupName = `__group${groupIndex++}`;
+        lines.push('/** @satisfies {import("@vobs/router").NestedRouteRecord} */');
+        lines.push(`const ${groupName}={path:${JSON.stringify(rootNode ? `/${node.segment}` : node.segment)},children:[${children.join(',')}]};`);
+        return groupName;
+    }
+}
+function createFileRouteTree(routes) {
+    let rootRoute;
+    const nodes = [];
+    const emittedPaths = new Map();
+    for (const route of routes) {
+        if (route.path === '/') {
+            rootRoute = route;
+            emittedPaths.set(route, '/');
+            continue;
+        }
+        let siblings = nodes;
+        let node;
+        for (const segment of splitFileRoutePath(route.path)) {
+            node = siblings.find((candidate) => candidate.segment === segment);
+            if (node === undefined) {
+                node = { segment, children: [] };
+                siblings.push(node);
+            }
+            siblings = node.children;
+        }
+        if (node !== undefined)
+            node.route = route;
+    }
+    for (const node of nodes)
+        assignEmittedFileRoutePaths(node, true, emittedPaths);
+    return {
+        ...(rootRoute === undefined ? {} : { rootRoute }),
+        nodes,
+        emittedPaths,
+    };
+}
+function assignEmittedFileRoutePaths(node, rootNode, emittedPaths) {
+    if (node.route !== undefined) {
+        emittedPaths.set(node.route, node.children.length === 0 ? (rootNode ? `/${node.segment}` : node.segment) : '');
+    }
+    for (const child of node.children)
+        assignEmittedFileRoutePaths(child, false, emittedPaths);
+}
+function splitFileRoutePath(routePath) {
+    return routePath.split('/').filter((segment) => segment !== '');
+}
+async function writeRoutesTypesFile(root, options, manifest) {
+    if (typeof options !== 'object' || options.typesFile === undefined)
+        return;
+    const filePath = path.resolve(root, options.typesFile);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, emitRoutesTypesModule(manifest), 'utf8');
+}
+function emitRoutesTypesModule(manifest) {
+    const lines = [
+        'declare module "vobs:routes" {',
+        '  export interface GeneratedRoutePathMap {',
+        ...manifest.routes.map((route) => `    ${JSON.stringify(route.path)}: true;`),
+        '  }',
+        '}',
+        '',
+    ];
+    return lines.join('\n');
+}
+function toRootImport(filePath, root) {
+    return `/${normalizeSlash(path.relative(root, filePath))}`;
+}
+function normalizeSlash(value) {
+    return value.split(path.sep).join('/');
+}
+function isViteHtmlEntry(filePath, root) {
+    return (normalizeSlash(path.resolve(filePath)) === normalizeSlash(path.resolve(root, 'index.html')));
+}
+function isFileNotFound(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@vobs/vite-plugin",
+  "version": "0.1.0",
+  "description": "Vite integration, HTML transforms and file routes for vobs.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "vobsjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vobsjs/vobs.git",
+    "directory": "plugins/vite"
+  },
+  "bugs": {
+    "url": "https://github.com/vobsjs/vobs/issues"
+  },
+  "homepage": "https://github.com/vobsjs/vobs#readme",
+  "dependencies": {
+    "@vobs/compiler-dom": "0.1.0",
+    "@vobs/runtime-dom": "0.1.0",
+    "@vobs/runtime-core": "0.1.0",
+    "@vobs/icons": "0.1.0",
+    "@vobs/router": "0.1.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "devDependencies": {
+    "vite": "^7.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}