@vobs/cli 0.1.0 → 0.2.0

package/dist/inspect.js

@@ -0,0 +1,576 @@
+/** @license MIT
+ * Copyright (c) 2026 vobsjs
+ * @vobs/cli
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { analyzeView, checkViewProject } from '@vobs/compiler-dom';
+const ignoredDirectories = new Set(['.git', '.cache', '.tmp', 'coverage', 'dist', 'node_modules']);
+export function inspectVobsProject(options) {
+    const tsconfigPath = path.resolve(options.tsconfigPath);
+    const projectRoot = path.dirname(tsconfigPath);
+    const workspaceRoot = findWorkspaceRoot(projectRoot);
+    const rootPackage = readJsonFile(path.join(workspaceRoot, 'package.json'));
+    const projectPackage = readJsonFile(path.join(projectRoot, 'package.json'));
+    const config = readTsConfig(tsconfigPath, projectRoot);
+    const files = collectProjectFiles(projectRoot);
+    const routeRoot = path.join(projectRoot, 'src', 'pages');
+    const routes = collectRoutes(routeRoot, projectRoot);
+    const checkResult = checkViewProject({ tsconfigPath });
+    return {
+        schemaVersion: '0.1',
+        generatedBy: 'vobs inspect',
+        workspace: {
+            root: manifestPath(workspaceRoot, workspaceRoot),
+            ...(typeof rootPackage?.packageManager === 'string'
+                ? { packageManager: rootPackage.packageManager }
+                : {}),
+        },
+        project: {
+            root: manifestPath(projectRoot, workspaceRoot),
+            ...(typeof projectPackage?.name === 'string' ? { name: projectPackage.name } : {}),
+            ...(typeof projectPackage?.name === 'string' ? { packageName: projectPackage.name } : {}),
+            ...(typeof projectPackage?.version === 'string'
+                ? { packageVersion: projectPackage.version }
+                : {}),
+        },
+        tsconfig: {
+            path: manifestPath(tsconfigPath, workspaceRoot),
+            rootNames: config.fileNames.map((fileName) => manifestPath(fileName, workspaceRoot)),
+            references: (config.projectReferences ?? []).map((reference) => manifestPath(reference.path, workspaceRoot)),
+        },
+        packages: collectPackages(workspaceRoot),
+        files: {
+            views: files.views.map((view) => manifestPath(view.file, workspaceRoot)),
+            routes: routes.map((route) => toManifestRoute(route, workspaceRoot)),
+            components: files.components.map((component) => toManifestComponent(component, workspaceRoot)),
+            globalComponents: checkResult.globalComponentTags ?? [],
+            viewContracts: files.views.map((view) => toManifestView(view, workspaceRoot)),
+            authorization: files.authorization.map((file) => toManifestPermission(file, workspaceRoot)),
+        },
+        diagnostics: checkResult.diagnostics.map((diagnostic) => toManifestDiagnostic(diagnostic, workspaceRoot)),
+    };
+}
+export function writeInspectOutput(manifest, outputPath) {
+    const workingDirectory = path.resolve(process.cwd());
+    const target = path.resolve(workingDirectory, outputPath);
+    const relativeTarget = path.relative(workingDirectory, target);
+    if (relativeTarget === '' ||
+        relativeTarget.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeTarget)) {
+        throw new Error(`Refusing to write inspect output outside the current directory: ${target}`);
+    }
+    const fileName = path.basename(target).toLowerCase();
+    if (fileName === '' || /(?:^|[._-])(?:env|secret|token|credential|password)/u.test(fileName)) {
+        throw new Error(`Refusing to write inspect output to a sensitive filename: ${target}`);
+    }
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+function collectProjectFiles(root) {
+    const views = [];
+    const components = [];
+    const authorization = [];
+    for (const fileName of walkFiles(root)) {
+        if (fileName.endsWith('.html')) {
+            views.push({ file: fileName, ...analyzeView(readFileSync(fileName, 'utf8'), fileName) });
+        }
+        if (!isTypeScriptFile(fileName))
+            continue;
+        const source = readFileSync(fileName, 'utf8');
+        const component = readComponentFile(fileName, source);
+        if (component !== undefined)
+            components.push(component);
+        const permission = readPermissionFile(fileName, source);
+        if (permission !== undefined)
+            authorization.push(permission);
+    }
+    views.sort((left, right) => left.file.localeCompare(right.file));
+    components.sort((left, right) => left.file.localeCompare(right.file));
+    authorization.sort((left, right) => left.file.localeCompare(right.file));
+    return { views, components, authorization };
+}
+function readComponentFile(fileName, source) {
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const definition = findDefinitionCall(sourceFile);
+    if (definition === undefined)
+        return undefined;
+    const viewRequest = readHtmlImport(sourceFile);
+    const view = viewRequest === undefined ? undefined : path.resolve(path.dirname(fileName), viewRequest);
+    return {
+        kind: definition.kind,
+        file: fileName,
+        ...(view === undefined ? {} : { view }),
+        exports: readExportNames(source),
+        props: readStaticArrayProperty(definition.options, 'props'),
+        emits: readStaticArrayProperty(definition.options, 'emits'),
+        exposed: readSetupExposedNames(definition.options, sourceFile),
+        registeredComponents: readStaticObjectKeys(definition.options, 'components'),
+    };
+}
+function findDefinitionCall(sourceFile) {
+    let result;
+    const visit = (node) => {
+        if (result === undefined &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            (node.expression.text === 'definePage' || node.expression.text === 'defineComponent')) {
+            const options = node.arguments[0];
+            if (options !== undefined && ts.isObjectLiteralExpression(options)) {
+                result = {
+                    kind: node.expression.text === 'definePage' ? 'page' : 'component',
+                    options,
+                };
+                return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return result;
+}
+function readHtmlImport(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text.endsWith('.html')) {
+            return statement.moduleSpecifier.text;
+        }
+    }
+    return undefined;
+}
+function readStaticArrayProperty(options, name) {
+    const expression = readPropertyExpression(options, name);
+    const array = expression === undefined ? undefined : unwrapExpression(expression);
+    if (array === undefined || !ts.isArrayLiteralExpression(array))
+        return [];
+    return array.elements
+        .map((element) => (ts.isStringLiteral(element) ? element.text : undefined))
+        .filter((value) => value !== undefined)
+        .sort();
+}
+function readStaticObjectKeys(options, name) {
+    const expression = readPropertyExpression(options, name);
+    const object = expression === undefined ? undefined : unwrapExpression(expression);
+    if (object === undefined || !ts.isObjectLiteralExpression(object))
+        return [];
+    return object.properties
+        .map(readObjectElementName)
+        .filter((value) => value !== undefined)
+        .sort();
+}
+function readSetupExposedNames(options, sourceFile) {
+    const setup = findSetupFunction(options, sourceFile);
+    const body = setup !== undefined && 'body' in setup ? setup.body : undefined;
+    if (body === undefined)
+        return [];
+    const names = new Set();
+    if (!ts.isBlock(body)) {
+        const expression = unwrapExpression(body);
+        if (ts.isObjectLiteralExpression(expression))
+            collectObjectKeys(expression, names);
+    }
+    const visit = (node) => {
+        if (node !== body && ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression !== undefined) {
+            const expression = unwrapExpression(node.expression);
+            if (ts.isObjectLiteralExpression(expression))
+                collectObjectKeys(expression, names);
+        }
+        if (ts.isCallExpression(node) && isExposeCall(node.expression)) {
+            const argument = node.arguments[0];
+            if (argument !== undefined) {
+                const expression = unwrapExpression(argument);
+                if (ts.isObjectLiteralExpression(expression))
+                    collectObjectKeys(expression, names);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    if (ts.isBlock(body))
+        visit(body);
+    return [...names].sort();
+}
+function findSetupFunction(options, sourceFile) {
+    for (const property of options.properties) {
+        if (readPropertyName(property.name) !== 'setup')
+            continue;
+        if (ts.isMethodDeclaration(property))
+            return property;
+        if (ts.isShorthandPropertyAssignment(property)) {
+            return findTopLevelFunction(sourceFile, property.name.text);
+        }
+        if (ts.isPropertyAssignment(property)) {
+            const initializer = unwrapExpression(property.initializer);
+            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+                return initializer;
+            }
+            if (ts.isIdentifier(initializer))
+                return findTopLevelFunction(sourceFile, initializer.text);
+        }
+    }
+    return undefined;
+}
+function findTopLevelFunction(sourceFile, name) {
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name?.text === name)
+            return statement;
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name)
+                continue;
+            const initializer = declaration.initializer === undefined
+                ? undefined
+                : unwrapExpression(declaration.initializer);
+            if (initializer !== undefined &&
+                (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) {
+                return initializer;
+            }
+        }
+    }
+    return undefined;
+}
+function isExposeCall(expression) {
+    return ((ts.isIdentifier(expression) && expression.text === 'expose') ||
+        (ts.isPropertyAccessExpression(expression) && expression.name.text === 'expose'));
+}
+function collectObjectKeys(object, names) {
+    for (const property of object.properties) {
+        const name = readObjectElementName(property);
+        if (name !== undefined)
+            names.add(name);
+    }
+}
+function readPropertyExpression(object, name) {
+    for (const property of object.properties) {
+        if (readPropertyName(property.name) !== name)
+            continue;
+        if (ts.isPropertyAssignment(property))
+            return property.initializer;
+    }
+    return undefined;
+}
+function readPropertyName(name) {
+    if (name === undefined)
+        return undefined;
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function readObjectElementName(property) {
+    return ts.isSpreadAssignment(property) ? undefined : readPropertyName(property.name);
+}
+function unwrapExpression(expression) {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function readPermissionFile(fileName, source) {
+    const exportedSymbols = readExportNames(source);
+    const kinds = [];
+    const authorizerOptions = readAuthorizerOptionNames(fileName, source);
+    if (authorizerOptions !== undefined ||
+        exportedSymbols.some((name) => /authorization|authorizer|permission/iu.test(name))) {
+        kinds.push('authorization');
+    }
+    if (authorizerOptions?.has('roles') === true ||
+        exportedSymbols.some((name) => /^roles?$/iu.test(name) || /^AuthorizationRole/u.test(name))) {
+        kinds.push('role');
+    }
+    if (authorizerOptions?.has('policies') === true ||
+        exportedSymbols.some((name) => /^polic(?:y|ies)$/iu.test(name) || /^AuthorizationPolicy/u.test(name))) {
+        kinds.push('policy');
+    }
+    if (kinds.length === 0)
+        return undefined;
+    return {
+        file: fileName,
+        kinds,
+        symbols: exportedSymbols.filter((name) => /authorization|authorizer|permission|roles?|polic(?:y|ies)/iu.test(name)),
+    };
+}
+function readAuthorizerOptionNames(fileName, source) {
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    let options;
+    const visit = (node) => {
+        if (options === undefined &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'createAuthorizer') {
+            options = new Set();
+            const argument = node.arguments[0];
+            if (argument !== undefined && ts.isObjectLiteralExpression(argument)) {
+                for (const property of argument.properties) {
+                    if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+                        ts.isIdentifier(property.name)) {
+                        options.add(property.name.text);
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return options;
+}
+function readExportNames(source) {
+    const names = new Set();
+    if (/\bexport\s+default\b/u.test(source))
+        names.add('default');
+    for (const match of source.matchAll(/\bexport\s+(?:const|let|var|function|class|interface|type)\s+([\w$]+)/gu)) {
+        const name = match[1];
+        if (name !== undefined)
+            names.add(name);
+    }
+    for (const match of source.matchAll(/\bexport\s*\{([^}]*)\}/gu)) {
+        for (const entry of (match[1] ?? '').split(',')) {
+            const exported = /\bas\s+([\w$]+)/u.exec(entry)?.[1] ?? entry.trim();
+            if (exported !== '')
+                names.add(exported);
+        }
+    }
+    return [...names].sort();
+}
+function collectRoutes(root, projectRoot) {
+    if (!existsSync(root) || !statSync(root).isDirectory())
+        return [];
+    const routes = [];
+    walkRouteDirectory(root, root, [], undefined, routes);
+    const notFound = path.join(root, '_404.ts');
+    if (existsSync(notFound)) {
+        routes.push({
+            kind: 'not-found',
+            path: '*',
+            file: notFound,
+            layouts: [],
+            hasGuard: false,
+            hasLoader: false,
+        });
+    }
+    const error = path.join(root, '_error.ts');
+    if (existsSync(error)) {
+        routes.push({
+            kind: 'error',
+            path: 'error',
+            file: error,
+            layouts: [],
+            hasGuard: false,
+            hasLoader: false,
+        });
+    }
+    return routes
+        .filter((route) => route.file.startsWith(projectRoot))
+        .sort((left, right) => left.path.localeCompare(right.path) || left.file.localeCompare(right.file));
+}
+function walkRouteDirectory(directory, pagesRoot, parentLayouts, parentError, routes) {
+    const layout = path.join(directory, '_layout.ts');
+    const layouts = existsSync(layout) ? [...parentLayouts, layout] : parentLayouts;
+    const localError = path.join(directory, '_error.ts');
+    const error = existsSync(localError) ? localError : parentError;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walkRouteDirectory(entryPath, pagesRoot, layouts, error, routes);
+            continue;
+        }
+        if (!entry.name.endsWith('.ts') || entry.name.endsWith('.d.ts') || entry.name.startsWith('_')) {
+            continue;
+        }
+        const source = readFileSync(entryPath, 'utf8');
+        routes.push({
+            kind: 'page',
+            path: routePathForFile(entryPath, pagesRoot),
+            file: entryPath,
+            layouts,
+            ...(error === undefined ? {} : { error }),
+            hasGuard: hasExportedRouteMember(source, 'guard'),
+            hasLoader: hasExportedRouteMember(source, 'loader'),
+        });
+    }
+}
+function routePathForFile(fileName, pagesRoot) {
+    const relative = path.relative(pagesRoot, fileName).replaceAll(path.sep, '/');
+    const segments = relative
+        .slice(0, -'.ts'.length)
+        .split('/')
+        .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];
+    });
+    return segments.length === 0 ? '/' : `/${segments.join('/')}`;
+}
+function hasExportedRouteMember(source, name) {
+    return new RegExp(`^\\s*export\\s+(?:(?:async\\s+)?function|const|let|var)\\s+${name}\\b`, 'mu').test(source);
+}
+function walkFiles(root) {
+    const files = [];
+    walk(root, files);
+    return files;
+}
+function walk(directory, files) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (!ignoredDirectories.has(entry.name) && entry.name !== '__tests__') {
+                walk(path.join(directory, entry.name), files);
+            }
+            continue;
+        }
+        const fileName = path.join(directory, entry.name);
+        if (!entry.name.endsWith('.test.ts') &&
+            !entry.name.endsWith('.spec.ts') &&
+            (entry.name.endsWith('.html') || isTypeScriptFile(fileName))) {
+            files.push(fileName);
+        }
+    }
+}
+function isTypeScriptFile(fileName) {
+    return (fileName.endsWith('.ts') || fileName.endsWith('.tsx')) && !fileName.endsWith('.d.ts');
+}
+function collectPackages(workspaceRoot) {
+    const roots = [];
+    for (const groupName of ['packages', 'plugins']) {
+        const group = path.join(workspaceRoot, groupName);
+        if (!existsSync(group) || !statSync(group).isDirectory())
+            continue;
+        for (const entry of readdirSync(group, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const direct = path.join(group, entry.name);
+            if (existsSync(path.join(direct, 'package.json'))) {
+                roots.push(direct);
+                continue;
+            }
+            for (const nested of readdirSync(direct, { withFileTypes: true })) {
+                if (nested.isDirectory() && existsSync(path.join(direct, nested.name, 'package.json'))) {
+                    roots.push(path.join(direct, nested.name));
+                }
+            }
+        }
+    }
+    return roots
+        .map((root) => {
+        const packageJson = readJsonFile(path.join(root, 'package.json'));
+        return {
+            name: typeof packageJson?.name === 'string'
+                ? packageJson.name
+                : manifestPath(root, workspaceRoot),
+            ...(typeof packageJson?.version === 'string' ? { version: packageJson.version } : {}),
+            path: manifestPath(root, workspaceRoot),
+            ...(typeof packageJson?.private === 'boolean' ? { private: packageJson.private } : {}),
+        };
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function readTsConfig(tsconfigPath, projectRoot) {
+    const read = ts.readConfigFile(tsconfigPath, (fileName) => ts.sys.readFile(fileName));
+    if (read.error !== undefined)
+        throw new Error(formatTsDiagnostic(read.error));
+    return ts.parseJsonConfigFileContent(read.config, ts.sys, projectRoot, undefined, tsconfigPath);
+}
+function readJsonFile(fileName) {
+    try {
+        const value = JSON.parse(readFileSync(fileName, 'utf8'));
+        return typeof value === 'object' && value !== null && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function findWorkspaceRoot(start) {
+    let current = path.resolve(start);
+    while (true) {
+        if (existsSync(path.join(current, 'pnpm-workspace.yaml')))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return path.resolve(start);
+        current = parent;
+    }
+}
+function manifestPath(fileName, workspaceRoot) {
+    const relative = path.relative(workspaceRoot, fileName).replaceAll(path.sep, '/');
+    return relative === '' ? '.' : relative;
+}
+function toManifestRoute(route, workspaceRoot) {
+    return {
+        kind: route.kind,
+        path: route.path,
+        file: manifestPath(route.file, workspaceRoot),
+        layouts: route.layouts.map((fileName) => manifestPath(fileName, workspaceRoot)),
+        ...(route.error === undefined ? {} : { error: manifestPath(route.error, workspaceRoot) }),
+        hasGuard: route.hasGuard,
+        hasLoader: route.hasLoader,
+    };
+}
+function toManifestComponent(component, workspaceRoot) {
+    return {
+        kind: component.kind,
+        file: manifestPath(component.file, workspaceRoot),
+        ...(component.view === undefined ? {} : { view: manifestPath(component.view, workspaceRoot) }),
+        exports: component.exports,
+        props: component.props,
+        emits: component.emits,
+        exposed: component.exposed,
+        registeredComponents: component.registeredComponents,
+    };
+}
+function toManifestView(view, workspaceRoot) {
+    return {
+        file: manifestPath(view.file, workspaceRoot),
+        bindings: view.bindings,
+        events: view.events,
+        directives: view.directives,
+        components: view.components,
+        includes: view.includes
+            .map((request) => path.resolve(path.dirname(view.file), request))
+            .filter((fileName) => isPathInside(workspaceRoot, fileName))
+            .map((fileName) => manifestPath(fileName, workspaceRoot)),
+        refs: view.refs,
+        slots: view.slots,
+    };
+}
+function toManifestPermission(file, workspaceRoot) {
+    return {
+        file: manifestPath(file.file, workspaceRoot),
+        kinds: file.kinds,
+        symbols: file.symbols,
+    };
+}
+function toManifestDiagnostic(diagnostic, workspaceRoot) {
+    return {
+        code: diagnostic.code,
+        message: diagnostic.message,
+        severity: diagnostic.severity,
+        phase: diagnostic.phase,
+        ...(diagnostic.sourceId === undefined
+            ? {}
+            : { source: manifestPath(diagnostic.sourceId, workspaceRoot) }),
+        ...(diagnostic.start === undefined ? {} : { start: diagnostic.start }),
+        ...(diagnostic.end === undefined ? {} : { end: diagnostic.end }),
+    };
+}
+function formatTsDiagnostic(diagnostic) {
+    return ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+}
+function isPathInside(root, fileName) {
+    const relative = path.relative(root, fileName);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}

package/dist/scaffold.js

@@ -43,7 +43,7 @@ export function isScaffoldTemplate(value) {
         value === 'lib-di');
 }
 export function scaffoldSuccessText(result) {
-    const command = isAppTemplate(result.template) ? 'npm run dev' : 'npm run build';
+    const command = isAppTemplate(result.template) ? 'pnpm run dev' : 'pnpm run build';
     const diLine = result.template === 'app-di' || result.template === 'enterprise' || result.template === 'lib-di'
         ? '\nDI integration included.\n'
         : '\n';
@@ -51,7 +51,7 @@ export function scaffoldSuccessText(result) {
         `Created ${result.name}`,
         '',
         `  cd ${result.name}`,
-        '  npm install',
+        '  pnpm install',
         `  ${command}`,
         diLine,
     ].join('\n');
@@ -136,7 +136,7 @@ function libFiles(withDi) {
         { path: 'README.md', content: withDi ? libReadmeWithDi : libReadme },
     ];
 }
-function appPackageJson(withDi) {
+function appPackageJson(_withDi) {
     return `{
   "name": "{{packageName}}",
   "version": "0.1.0",
@@ -149,8 +149,7 @@ function appPackageJson(withDi) {
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-${withDi ? '    "@vobs/di": "latest",\n' : ''}    "@vobs/reactivity": "latest",
-    "@vobs/runtime-dom": "latest"
+    "vobs": "latest"
   },
   "devDependencies": {
     "@vobs/vite-plugin": "latest",
@@ -192,7 +191,7 @@ import './styles/global.css';
 
 await app.mount('#app');
 `;
-const appModule = `import { createVobsApp } from '@vobs/runtime-dom';
+const appModule = `import { createVobsApp } from 'vobs';
 import router from 'vobs:routes';
 
 const reportAppError = (error: unknown): void => {
@@ -210,8 +209,7 @@ const app = createVobsApp({
 
 export { app };
 `;
-const appModuleWithDi = `import { createInjectionScope } from '@vobs/di';
-import { createVobsApp } from '@vobs/runtime-dom';
+const appModuleWithDi = `import { createInjectionScope, createVobsApp } from 'vobs';
 import router from 'vobs:routes';
 import { registerServices } from './app/di.js';
 
@@ -237,7 +235,7 @@ export { app };
 const appDiFiles = [
     {
         path: 'src/app/di.ts',
-        content: `import type { InjectionScope } from '@vobs/di';
+        content: `import type { InjectionScope } from 'vobs';
 import { createToastService, ToastServiceKey } from '../services/toast.js';
 
 export function registerServices(scope: InjectionScope): void {
@@ -252,7 +250,7 @@ export function registerServices(scope: InjectionScope): void {
     },
     {
         path: 'src/services/toast.ts',
-        content: `import { createInjectionKey, inject } from '@vobs/di';
+        content: `import { createInjectionKey, inject } from 'vobs';
 
 export interface ToastService {
   success(message: string): void;
@@ -274,8 +272,7 @@ export function useToast(): ToastService {
 `,
     },
 ];
-const indexPage = `import { signal } from '@vobs/reactivity';
-import { definePage } from '@vobs/runtime-dom';
+const indexPage = `import { definePage, signal } from 'vobs';
 import template from './index.html';
 
 export default definePage({
@@ -291,8 +288,7 @@ export default definePage({
   },
 });
 `;
-const indexPageWithDi = `import { signal } from '@vobs/reactivity';
-import { definePage } from '@vobs/runtime-dom';
+const indexPageWithDi = `import { definePage, signal } from 'vobs';
 import { useToast } from '../services/toast.js';
 import template from './index.html';