@azure-net/cli 5.1.1 → 6.0.0-next.2

package/src/checks/checkDomain.js

@@ -1,171 +1,141 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-import { normalizeContexts } from '../init/initAliases.js';
+import ts from 'typescript';
+import { appRoot, directories, exportOnly, parseSource } from './architecture.js';
 const DOMAIN_FILE_EXTENSIONS = new Set(['.ts']);
-const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
-const INTERFACE_DECLARATION_PATTERN = /(?:^|\n)\s*(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/g;
-const TYPE_DECLARATION_PATTERN = /(?:^|\n)\s*(?:export\s+)?type\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=/g;
-const EXPORT_STAR_PATTERN = /export\s+\*\s+from\s*['"][^'"]+['"]\s*;?/g;
-const EXPORT_FROM_PATTERN = /export\s+(?:type\s+)?\{[\s\S]*?\}\s+from\s*['"][^'"]+['"]\s*;?/g;
-const EXPORT_LOCAL_PATTERN = /export\s+(?:type\s+)?\{[\s\S]*?\}\s*;?/g;
+const IGNORED_DIRS = new Set(['.backup', 'node_modules', 'dist', '.svelte-kit', '.git']);
 const toPosixPath = (value) => value.split(path.sep).join('/');
-const stripComments = (content) => content.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^\\])\/\/.*$/gm, '$1');
-const stripExportStatements = (content) =>
-	content.replace(EXPORT_STAR_PATTERN, '').replace(EXPORT_FROM_PATTERN, '').replace(EXPORT_LOCAL_PATTERN, '');
-const findLineByIndex = (content, index) => {
-	let line = 1;
-	for (let i = 0; i < index; i += 1) {
-		if (content[i] === '\n') line += 1;
-	}
-	return line;
-};
 const getRelativeFilePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
-const isEnumsPath = (filePath) => {
-	const normalized = toPosixPath(filePath);
-	return normalized.includes('/enums/');
-};
 const isIndexFile = (filePath) => path.basename(filePath) === 'index.ts';
 const startsWithInterfacePrefix = (filePath) => /^I[A-Z]/.test(path.basename(filePath, '.ts'));
-const isExportOnlyIndex = (content) => {
-	const withoutComments = stripComments(content);
-	const withoutExports = stripExportStatements(withoutComments);
-	return withoutExports.trim().length === 0;
-};
+const isExportOnlyIndex = exportOnly;
 const validateName = (declaration) => {
-	if (declaration.kind === 'interface') {
-		return /^I[A-Z]/.test(declaration.name) ? null : `Interface "${declaration.name}" must start with "I" and have uppercase second letter`;
-	}
-	return /^[IT][A-Z]/.test(declaration.name)
-		? null
-		: `Type "${declaration.name}" must start with "I" or "T" and have uppercase second letter`;
+    if (declaration.kind === 'interface') {
+        return /^I[A-Z]/.test(declaration.name) ? null : `Interface "${declaration.name}" must start with "I" and have uppercase second letter`;
+    }
+    return /^[IT][A-Z]/.test(declaration.name)
+        ? null
+        : `Type "${declaration.name}" must start with "I" or "T" and have uppercase second letter`;
 };
 const extractDeclarations = (content) => {
-	const cleaned = stripComments(content);
-	const declarations = [];
-	const interfaceRegex = new RegExp(INTERFACE_DECLARATION_PATTERN.source, 'g');
-	let interfaceMatch;
-	while ((interfaceMatch = interfaceRegex.exec(cleaned)) !== null) {
-		const name = interfaceMatch[1];
-		if (!name) continue;
-		declarations.push({
-			kind: 'interface',
-			name,
-			line: findLineByIndex(cleaned, interfaceMatch.index)
-		});
-	}
-	const typeRegex = new RegExp(TYPE_DECLARATION_PATTERN.source, 'g');
-	let typeMatch;
-	while ((typeMatch = typeRegex.exec(cleaned)) !== null) {
-		const name = typeMatch[1];
-		if (!name) continue;
-		declarations.push({
-			kind: 'type',
-			name,
-			line: findLineByIndex(cleaned, typeMatch.index)
-		});
-	}
-	return declarations.sort((a, b) => a.line - b.line);
+    const source = parseSource(content);
+    const declarations = [];
+    const visit = (node) => {
+        if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node))
+            declarations.push({
+                kind: ts.isInterfaceDeclaration(node) ? 'interface' : 'type',
+                name: node.name.text,
+                line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1
+            });
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return declarations;
 };
 const listDomainFiles = async (domainRoot) => {
-	const files = [];
-	const stack = [domainRoot];
-	while (stack.length) {
-		const current = stack.pop();
-		if (!current) continue;
-		let entries = [];
-		try {
-			entries = await fs.readdir(current, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			if (entry.isDirectory()) {
-				if (!IGNORED_DIRS.has(entry.name)) {
-					stack.push(path.join(current, entry.name));
-				}
-				continue;
-			}
-			if (!entry.isFile()) continue;
-			const filePath = path.join(current, entry.name);
-			if (!DOMAIN_FILE_EXTENSIONS.has(path.extname(filePath))) continue;
-			files.push(filePath);
-		}
-	}
-	return files;
+    const files = [];
+    const stack = [domainRoot];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries = [];
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name)) {
+                    stack.push(path.join(current, entry.name));
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const filePath = path.join(current, entry.name);
+            if (!DOMAIN_FILE_EXTENSIONS.has(path.extname(filePath)))
+                continue;
+            files.push(filePath);
+        }
+    }
+    return files;
 };
 const collectIssuesForFile = (filePath, content) => {
-	const issues = [];
-	if (isIndexFile(filePath) && !isExportOnlyIndex(content)) {
-		issues.push({
-			file: filePath,
-			line: 1,
-			message: 'index.ts must contain only exports. Move declarations to separate files'
-		});
-	}
-	if (isEnumsPath(filePath)) {
-		return issues;
-	}
-	if (!isIndexFile(filePath) && startsWithInterfacePrefix(filePath)) {
-		issues.push({
-			file: filePath,
-			line: 1,
-			message: 'Domain file names must not start with "I". Keep "I" only in interface/type names'
-		});
-	}
-	const declarations = extractDeclarations(content);
-	if (declarations.length > 5) {
-		issues.push({
-			file: filePath,
-			line: declarations[5]?.line ?? 1,
-			message: `Too many declarations in one file (${declarations.length}). Maximum is 5`
-		});
-	}
-	for (const declaration of declarations) {
-		const validationError = validateName(declaration);
-		if (!validationError) continue;
-		issues.push({
-			file: filePath,
-			line: declaration.line,
-			message: validationError
-		});
-	}
-	return issues;
+    const issues = [];
+    if (isIndexFile(filePath) && !isExportOnlyIndex(content)) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            message: 'index.ts must contain only exports. Move declarations to separate files'
+        });
+    }
+    if (!isIndexFile(filePath) && startsWithInterfacePrefix(filePath)) {
+        issues.push({
+            file: filePath,
+            line: 1,
+            message: 'Domain file names must not start with "I". Keep "I" only in interface/type names'
+        });
+    }
+    const declarations = extractDeclarations(content);
+    if (declarations.length > 5) {
+        issues.push({
+            file: filePath,
+            line: declarations[5]?.line ?? 1,
+            message: `Too many declarations in one file (${declarations.length}). Maximum is 5`
+        });
+    }
+    for (const declaration of declarations) {
+        const validationError = validateName(declaration);
+        if (!validationError)
+            continue;
+        issues.push({
+            file: filePath,
+            line: declaration.line,
+            message: validationError
+        });
+    }
+    return issues;
 };
 export default async function checkDomain() {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts);
-	if (!contexts.length) {
-		console.error('❌ No contexts found in azure-net.config.ts/js. Fill `contexts` first.');
-		process.exitCode = 1;
-		return;
-	}
-	const issues = [];
-	for (const context of contexts) {
-		const domainRoot = path.join(process.cwd(), 'src', 'app', context.name, 'layers', 'domain');
-		try {
-			await fs.access(domainRoot);
-		} catch {
-			issues.push({
-				file: domainRoot,
-				line: 1,
-				message: `Domain folder not found for context "${context.name}"`
-			});
-			continue;
-		}
-		const files = await listDomainFiles(domainRoot);
-		for (const filePath of files) {
-			const content = await fs.readFile(filePath, 'utf-8');
-			issues.push(...collectIssuesForFile(filePath, content));
-		}
-	}
-	if (!issues.length) {
-		console.log('✅ Domain check passed: naming, per-file limits and index exports are valid.');
-		return;
-	}
-	console.error('❌ Domain check failed:');
-	for (const issue of issues) {
-		console.error(`• ${getRelativeFilePath(issue.file)}:${issue.line} — ${issue.message}`);
-	}
-	process.exitCode = 1;
+    const issues = [];
+    let contexts;
+    try {
+        contexts = await directories(path.join(appRoot(), 'Contexts'));
+    }
+    catch {
+        console.error('Contexts folder not found in src/app.');
+        process.exitCode = 1;
+        return;
+    }
+    for (const context of contexts) {
+        const domainRoot = path.join(appRoot(), 'Contexts', context, 'Domain');
+        try {
+            await fs.access(domainRoot);
+        }
+        catch {
+            issues.push({
+                file: domainRoot,
+                line: 1,
+                message: `Domain folder not found for context "${context}"`
+            });
+            continue;
+        }
+        const files = await listDomainFiles(domainRoot);
+        for (const filePath of files) {
+            const content = await fs.readFile(filePath, 'utf-8');
+            issues.push(...collectIssuesForFile(filePath, content));
+        }
+    }
+    if (!issues.length) {
+        console.log('✅ Domain check passed: naming, per-file limits and index exports are valid.');
+        return;
+    }
+    console.error('❌ Domain check failed:');
+    for (const issue of issues) {
+        console.error(`• ${getRelativeFilePath(issue.file)}:${issue.line} — ${issue.message}`);
+    }
+    process.exitCode = 1;
 }

package/src/checks/checkFoldersStructure.js

@@ -1,56 +1,68 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-import { normalizeContexts } from '../init/initAliases.js';
-const ALLOWED_LAYERS_FOLDERS = new Set(['domain', 'presentation', 'infrastructure', 'application']);
-const ALLOWED_UI_FOLDERS = new Set(['components', 'widgets', 'design', 'style']);
-const ALLOWED_COMPONENTS_FOLDERS = new Set(['page', 'layout', 'shared']);
-const toPosixPath = (value) => value.split(path.sep).join('/');
-const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
-const getDirectories = async (dirPath) => {
-	try {
-		const entries = await fs.readdir(dirPath, { withFileTypes: true });
-		return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	} catch {
-		return null;
-	}
-};
-const checkOnlyAllowedFolders = async (basePath, allowed, scopeLabel, issues) => {
-	const directories = await getDirectories(basePath);
-	if (!directories) return;
-	for (const dir of directories) {
-		if (allowed.has(dir)) continue;
-		issues.push({
-			file: basePath,
-			message: `${scopeLabel} can contain only: ${Array.from(allowed).join(', ')}. Found: ${dir}`
-		});
-	}
-};
+import { appRoot, directories, report } from './architecture.js';
 export default async function checkFoldersStructure() {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts);
-	if (!contexts.length) {
-		console.error('❌ No contexts found in azure-net.config.ts/js. Fill `contexts` first.');
-		process.exitCode = 1;
-		return;
-	}
-	const issues = [];
-	for (const context of contexts) {
-		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
-		const layersPath = path.join(contextRoot, 'layers');
-		const uiPath = path.join(contextRoot, 'ui');
-		const componentsPath = path.join(uiPath, 'components');
-		await checkOnlyAllowedFolders(layersPath, ALLOWED_LAYERS_FOLDERS, `layers (${context.name})`, issues);
-		await checkOnlyAllowedFolders(uiPath, ALLOWED_UI_FOLDERS, `ui (${context.name})`, issues);
-		await checkOnlyAllowedFolders(componentsPath, ALLOWED_COMPONENTS_FOLDERS, `ui/components (${context.name})`, issues);
-	}
-	if (!issues.length) {
-		console.log('✅ Folders structure check passed.');
-		return;
-	}
-	console.error('❌ Folders structure check failed:');
-	for (const issue of issues) {
-		console.error(`• ${getRelativePath(issue.file)} — ${issue.message}`);
-	}
-	process.exitCode = 1;
+    const issues = [];
+    const issue = (file, message) => {
+        issues.push({ file, line: 1, message });
+    };
+    const allowed = async (root, names) => {
+        for (const name of await directories(root))
+            if (!names.includes(name))
+                issue(path.join(root, name), `Allowed folders: ${names.join(', ')}`);
+    };
+    const walk = async (root) => {
+        for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+            if (entry.name === '.backup' && root === appRoot())
+                continue;
+            const file = path.join(root, entry.name);
+            const routes = file === path.join(appRoot(), 'Presentation', 'routes');
+            const name = entry.isDirectory() ? entry.name : entry.name.split('.')[0];
+            if (!routes && !(entry.isFile() && entry.name === 'index.ts') && !/^[A-Z][A-Za-z0-9]*$/.test(name))
+                issue(file, 'Folders and files under src/app must use PascalCase (except index.ts)');
+            if (entry.isDirectory())
+                await walk(file);
+        }
+    };
+    try {
+        await allowed(appRoot(), ['Contexts', 'Presentation', 'Platform']);
+        for (const root of ['Contexts', 'Presentation', 'Platform']) {
+            if (!(await fs.stat(path.join(appRoot(), root)).catch(() => null))?.isDirectory())
+                issue(path.join(appRoot(), root), 'Required application root is missing');
+        }
+        for (const context of await directories(path.join(appRoot(), 'Contexts'))) {
+            const root = path.join(appRoot(), 'Contexts', context);
+            await allowed(root, ['Domain', 'Application', 'Infrastructure']);
+            for (const [layer, children] of Object.entries({
+                Domain: ['Entities', 'Ports', 'Enums'],
+                Application: ['UseCases'],
+                Infrastructure: ['Repositories']
+            })) {
+                const layerRoot = path.join(root, layer);
+                if (!(await fs.stat(layerRoot).catch(() => null))?.isDirectory()) {
+                    issue(layerRoot, 'Required context layer is missing');
+                    continue;
+                }
+                await allowed(layerRoot, children);
+            }
+        }
+        const presentation = path.join(appRoot(), 'Presentation');
+        const folders = await directories(presentation);
+        const flat = ['Ui', 'Scopes', 'Shell'];
+        for (const folder of folders) {
+            const canonical = [...flat, 'Shared'].find((name) => name.toLowerCase() === folder.toLowerCase());
+            if (canonical && canonical !== folder)
+                issue(path.join(presentation, folder), `Use the canonical folder name "${canonical}"`);
+        }
+        const workspaces = folders.filter((name) => ![...flat, 'routes', 'Routes'].includes(name));
+        if (folders.some((name) => flat.includes(name)) && workspaces.length)
+            issue(presentation, 'Presentation cannot mix flat Ui/Scopes/Shell folders with workspaces');
+        for (const workspace of workspaces)
+            await allowed(path.join(presentation, workspace), flat);
+        await walk(appRoot());
+    }
+    catch (error) {
+        issue(appRoot(), String(error));
+    }
+    report('Folders structure', issues);
 }

package/src/checks/checkHooks.js

@@ -2,16 +2,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 const forbiddenHooks = ['hooks.server.ts', 'hooks.server.js', 'hooks.client.ts', 'hooks.client.js'];
 export default async function checkHooks() {
-	const srcPath = path.join(process.cwd(), 'src');
-	const found = forbiddenHooks.map((filename) => path.join(srcPath, filename)).filter((filepath) => fs.existsSync(filepath));
-	if (!found.length) {
-		console.log('✅ No manual SvelteKit hooks found.');
-		return;
-	}
-	console.error('❌ Manual SvelteKit hooks are not allowed with @azure-net/kit AzureNetPlugin.');
-	console.error('Move lifecycle code to src/program.ts through createApp(). Found:');
-	for (const filepath of found) {
-		console.error(` - ${path.relative(process.cwd(), filepath)}`);
-	}
-	process.exitCode = 1;
+    const srcPath = path.join(process.cwd(), 'src');
+    const found = forbiddenHooks.map((filename) => path.join(srcPath, filename)).filter((filepath) => fs.existsSync(filepath));
+    if (!found.length) {
+        console.log('✅ No manual SvelteKit hooks found.');
+        return;
+    }
+    console.error('❌ Manual SvelteKit hooks are not allowed with @azure-net/kit AzureNetPlugin.');
+    console.error('Move lifecycle code to src/program.ts through createApp(). Found:');
+    for (const filepath of found) {
+        console.error(` - ${path.relative(process.cwd(), filepath)}`);
+    }
+    process.exitCode = 1;
 }

package/src/checks/checkImports.js

@@ -1,146 +1,30 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
-const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
-const IMPORT_DECLARATION_PATTERN = /(^|\n)\s*import\s+(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]\s*;?/g;
-const EXPORT_DECLARATION_PATTERN = /(^|\n)\s*export\s+(?:type\s+)?(?:[\s\S]*?\s+from\s*)['"]([^'"]+)['"]\s*;?/g;
-const FORBIDDEN_IMPORT_EXTENSION_PATTERN = /\.(?:ts|js)(?:$|[?#])/;
-const toPosixPath = (value) => value.split(path.sep).join('/');
-const getRelativePath = (filePath) => toPosixPath(path.relative(process.cwd(), filePath));
-const findLineByIndex = (content, index) => {
-	let line = 1;
-	for (let i = 0; i < index; i += 1) {
-		if (content[i] === '\n') line += 1;
-	}
-	return line;
-};
-const listFiles = async (rootDir) => {
-	const files = [];
-	const stack = [rootDir];
-	while (stack.length) {
-		const current = stack.pop();
-		if (!current) continue;
-		let entries = [];
-		try {
-			entries = await fs.readdir(current, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			if (entry.isDirectory()) {
-				if (!IGNORED_DIRS.has(entry.name)) {
-					stack.push(path.join(current, entry.name));
-				}
-				continue;
-			}
-			if (!entry.isFile()) continue;
-			const filePath = path.join(current, entry.name);
-			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
-			files.push(filePath);
-		}
-	}
-	return files;
-};
-const getImportKind = (raw) => {
-	const normalized = raw.trim();
-	if (/^import\s+type\b/.test(normalized)) return 'type';
-	if (/^import\s*['"]/.test(normalized)) return 'side-effect';
-	return 'value';
-};
-const getKindOrder = (kind) => {
-	if (kind === 'value') return 0;
-	if (kind === 'type') return 1;
-	return 2;
-};
-const extractImports = (content) => {
-	const imports = [];
-	const regex = new RegExp(IMPORT_DECLARATION_PATTERN.source, 'g');
-	let match;
-	while ((match = regex.exec(content)) !== null) {
-		const raw = match[0].trim();
-		const source = match[2];
-		if (!source) continue;
-		imports.push({
-			kind: getImportKind(raw),
-			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0)),
-			source,
-			raw
-		});
-	}
-	return imports.sort((a, b) => a.line - b.line);
-};
-const extractExportSources = (content) => {
-	const exports = [];
-	const regex = new RegExp(EXPORT_DECLARATION_PATTERN.source, 'g');
-	let match;
-	while ((match = regex.exec(content)) !== null) {
-		const source = match[2];
-		if (!source) continue;
-		exports.push({
-			source,
-			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0))
-		});
-	}
-	return exports;
-};
-const hasForbiddenExtension = (source) => {
-	const sourceWithoutQuery = source.split('?')[0] ?? source;
-	return FORBIDDEN_IMPORT_EXTENSION_PATTERN.test(sourceWithoutQuery);
-};
-const collectIssuesForFile = (filePath, content) => {
-	const issues = [];
-	const imports = extractImports(content);
-	let lastKindOrder = 0;
-	for (const importEntry of imports) {
-		if (hasForbiddenExtension(importEntry.source)) {
-			issues.push({
-				file: filePath,
-				line: importEntry.line,
-				message: `Import "${importEntry.source}" must not include .ts/.js extension`
-			});
-		}
-		const currentOrder = getKindOrder(importEntry.kind);
-		if (currentOrder < lastKindOrder) {
-			issues.push({
-				file: filePath,
-				line: importEntry.line,
-				message: 'Import order violation: value imports first, then type imports, then side-effect imports'
-			});
-		}
-		lastKindOrder = Math.max(lastKindOrder, currentOrder);
-	}
-	for (const exportEntry of extractExportSources(content)) {
-		if (!hasForbiddenExtension(exportEntry.source)) continue;
-		issues.push({
-			file: filePath,
-			line: exportEntry.line,
-			message: `Export source "${exportEntry.source}" must not include .ts/.js extension`
-		});
-	}
-	return issues;
-};
+import { dependencies, sourceFiles, report } from './architecture.js';
 export default async function checkImports() {
-	const srcRoot = path.join(process.cwd(), 'src');
-	try {
-		await fs.access(srcRoot);
-	} catch {
-		console.error('❌ src folder not found.');
-		process.exitCode = 1;
-		return;
-	}
-	const issues = [];
-	const files = await listFiles(srcRoot);
-	for (const filePath of files) {
-		const content = await fs.readFile(filePath, 'utf-8');
-		issues.push(...collectIssuesForFile(filePath, content));
-	}
-	if (!issues.length) {
-		console.log('✅ Imports check passed: extensions and import groups are valid.');
-		return;
-	}
-	console.error('❌ Imports check failed:');
-	for (const issue of issues) {
-		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
-	}
-	process.exitCode = 1;
+    const issues = [];
+    const src = path.join(process.cwd(), 'src');
+    try {
+        for (const file of await sourceFiles(src)) {
+            let previous = 0;
+            for (const entry of dependencies(await fs.readFile(file, 'utf8'), file)) {
+                if (/\.(?:ts|js)(?:$|[?#])/.test(entry.source))
+                    issues.push({ file, line: entry.line, message: `Import "${entry.source}" must not include .ts/.js extension` });
+                if (['export', 'dynamic'].includes(entry.kind))
+                    continue;
+                const order = entry.kind === 'type' ? 1 : entry.kind === 'side-effect' ? 2 : 0;
+                if (order < previous)
+                    issues.push({
+                        file,
+                        line: entry.line,
+                        message: 'Import order violation: value imports first, then type imports, then side-effect imports'
+                    });
+                previous = Math.max(previous, order);
+            }
+        }
+    }
+    catch (error) {
+        issues.push({ file: src, line: 1, message: String(error) });
+    }
+    report('Imports', issues);
 }