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

package/dist/src/generate/module/generateSchemaFromType.d.ts

@@ -0,0 +1,9 @@
+type InterfaceField = {
+    name: string;
+    optional: boolean;
+    type: string;
+};
+export declare const extractInterfaceFields: (body: string) => InterfaceField[];
+export declare const updateRulesObject: (content: string, fields: InterfaceField[]) => string | null;
+export default function generateSchemaFromType(): Promise<void>;
+export {};

package/dist/src/generate/module/generateStore.d.ts

@@ -0,0 +1 @@
+export default function generateStore(): Promise<void>;

package/dist/src/generate/module/generateTypesJson.d.ts

@@ -0,0 +1,2 @@
+export declare const parseObjectInput: (rawValue: unknown) => Record<string, unknown>;
+export default function generateTypesJson(): Promise<void>;

package/dist/src/generate/module/generateUseCases.d.ts

@@ -0,0 +1 @@
+export default function generateUseCases(): Promise<void>;

package/dist/src/generate/module/repositoryModuleShared.d.ts

@@ -0,0 +1,89 @@
+type ContextConfig = {
+    name: string;
+    alias: string;
+};
+type TypeLayer = 'Ports' | 'Entities' | 'Enums';
+type ResponseKind = 'domain' | 'primitive';
+type RepositoryMeta = {
+    className: string;
+    baseName: string;
+    repositoryInterfaceName: string;
+    useCasesClassName: string;
+    repositoryDependencyName: string;
+};
+type DomainType = {
+    name: string;
+    layer: TypeLayer;
+    fileName?: string;
+};
+type MethodTypeRef = {
+    name: string;
+    layer: TypeLayer;
+};
+type MethodResponseRef = {
+    kind: ResponseKind;
+    type: string;
+    layer: TypeLayer | null;
+};
+type RepositoryMethod = {
+    name: string;
+    httpMethod: string;
+    route: string;
+    response: MethodResponseRef;
+    queryType: MethodTypeRef | null;
+    bodyType: MethodTypeRef | null;
+    pathParamType: string | null;
+};
+type DatasourceInfo = {
+    name: string;
+    importPath: string;
+};
+export declare const ensureRepositoryName: (rawName: unknown) => string;
+export declare const getRepositoryMeta: (repositoryName: unknown) => RepositoryMeta;
+export declare const getConfigState: () => Promise<{
+    contexts: ContextConfig[];
+    sharedAlias: string;
+    sharedContextName: string;
+}>;
+export declare const selectContext: (message?: string) => Promise<string | null>;
+export declare const resolveContextAlias: (_contexts: ContextConfig[], contextName: string) => string;
+export declare const resolveRepositoriesPath: (contextName: string) => string;
+export declare const resolveDatasourcesPath: (...compatibility: [contextName?: string]) => string;
+export declare const resolveSharedDatasourcesPath: () => Promise<string>;
+export declare const resolveDomainRootPath: (contextName: string, ...compatibility: [domainName?: string]) => string;
+export declare const resolveUseCasesPath: (contextName: string) => string;
+export declare const getAvailableTsNames: (targetPath: string) => Promise<string[]>;
+export declare const selectDatasource: (...compatibility: [contextName?: string]) => Promise<DatasourceInfo | null>;
+export declare const selectDomain: (contextName: string) => Promise<string>;
+export declare const getDomainTypes: (contextName: string, domainName?: string) => Promise<DomainType[]>;
+export declare const promptMethodDefinition: (domainTypes: DomainType[]) => Promise<RepositoryMethod | null>;
+export declare const buildRepositoryMethodCode: (method: RepositoryMethod) => string;
+export declare const buildRepositoryContent: ({ meta, contextAlias, datasource, domainTypes, methods }: {
+    meta: RepositoryMeta;
+    contextAlias: string;
+    domainName: string;
+    domainTypes?: DomainType[];
+    datasource: DatasourceInfo;
+    methods: RepositoryMethod[];
+}) => string;
+export declare const writeRepositoryInterface: ({ contextName, domainName, meta, methods }: {
+    contextName: string;
+    domainName: string;
+    meta: RepositoryMeta;
+    methods: RepositoryMethod[];
+}) => Promise<boolean>;
+export declare const createUseCasesForRepository: ({ contextName, contextAlias, domainName, repositoryName }: {
+    contextName: string;
+    contextAlias: string;
+    domainName: string;
+    repositoryName: string;
+}) => Promise<boolean>;
+export declare const resolveDomainForRepository: ({ contextName, contextAlias, repositoryName }: {
+    contextName: string;
+    contextAlias: string;
+    repositoryName: string;
+}) => Promise<string | null>;
+export declare const promptMethodsBatch: (domainTypes: DomainType[], count: number) => Promise<RepositoryMethod[] | null>;
+export declare const ensureDomainScaffold: (contextName: string) => Promise<void>;
+export declare const printApplicationProviderWiring: (contextName: string, repositoryName: string, datasourceName: string) => void;
+export {};

package/dist/src/generate/routes/generateRoutes.d.ts

@@ -0,0 +1,14 @@
+export type RouteGenerationMeta = {
+    url: string;
+    routeDir: string;
+    relativeDir: string;
+    segments: string[];
+    dynamicParams: string[];
+    rootGroup?: string;
+    groupStack: string[];
+    depth: number;
+    hasChildren: boolean;
+    hasPage: boolean;
+    hasServer: boolean;
+};
+export default function generateRoutes(): Promise<void>;

package/dist/src/generate/ui/generateComponent.d.ts

@@ -0,0 +1 @@
+export default function generateComponent(): Promise<void>;

package/dist/src/generate/ui/generateDesignComponent.d.ts

@@ -0,0 +1 @@
+export default function generateDesignComponent(): Promise<void>;

package/dist/src/generate/ui/generateWidget.d.ts

@@ -0,0 +1 @@
+export default function generateWidget(): Promise<void>;

package/dist/src/git/commit.d.ts

@@ -0,0 +1,23 @@
+import prompts from 'prompts';
+import { type GitRunner } from './runGit.js';
+export declare const commitTypes: {
+    value: string;
+    title: string;
+}[];
+export declare class CommitCancelledError extends Error {
+    constructor();
+}
+export declare function validateSubject(value: string): true | string;
+export interface CommitAnswers {
+    type: string;
+    subject: string;
+    body?: string;
+    breaking?: string;
+    footer?: string;
+}
+export declare function formatCommitMessage(answers: CommitAnswers): string;
+export interface CommitDependencies {
+    prompt?: typeof prompts;
+    git?: GitRunner;
+}
+export default function commit(dependencies?: CommitDependencies): Promise<void>;

package/dist/src/git/push.d.ts

@@ -0,0 +1,11 @@
+import { type CommitDependencies } from './commit.js';
+export interface PushOptions {
+    check?: boolean;
+}
+export interface PushDependencies extends CommitDependencies {
+    loadConfig?: () => Promise<{
+        runChecksBeforePush?: unknown;
+    }>;
+    checkProject?: () => Promise<void>;
+}
+export default function push(options?: PushOptions, dependencies?: PushDependencies): Promise<void>;

package/dist/src/git/runGit.d.ts

@@ -0,0 +1,2 @@
+export type GitRunner = (args: string[]) => Promise<void>;
+export declare const runGit: GitRunner;

package/dist/src/init/initAliases.d.ts

@@ -0,0 +1,12 @@
+type ContextConfig = {
+    name: string;
+    alias: string;
+};
+/** Compatibility only: architecture discovery never reads configured contexts. */
+export declare function normalizeContexts(raw: unknown): ContextConfig[];
+export declare function generateAliases(): {
+    contexts: ContextConfig[];
+    aliases: Record<string, string>;
+};
+export { mergeAliasesInSvelteConfig } from '../utils/legacyAliases.js';
+export default function initAliases(): Promise<void>;

package/dist/src/init/initEdges.d.ts

@@ -0,0 +1,2 @@
+export declare function configureAzureNetPlugin(content: string): string;
+export default function initEdges(): Promise<void>;

package/dist/src/init/initStructure.d.ts

@@ -0,0 +1 @@
+export default function initStructure(): Promise<void>;

package/dist/src/install/configureCommitTools.d.ts

@@ -0,0 +1 @@
+export { default } from '../plugins/addLint.js';

package/dist/src/install/installFresh.d.ts

@@ -0,0 +1 @@
+export default function installFresh(): Promise<void>;

package/dist/src/migrate/migrate.d.ts

@@ -0,0 +1,22 @@
+export type MigrationIssue = {
+    file: string;
+    reason: string;
+};
+export type MigrationPlan = {
+    root: string;
+    moves: {
+        from: string;
+        to: string;
+    }[];
+    issues: MigrationIssue[];
+    writes: Map<string, Buffer>;
+    originals: Map<string, Buffer>;
+    removes: string[];
+    workspaces: string[];
+};
+export declare function planMigration(root?: string): Promise<MigrationPlan>;
+export declare function applyMigration(plan: MigrationPlan): Promise<string>;
+export default function migrate(options?: {
+    dryRun?: boolean;
+    yes?: boolean;
+}): Promise<void>;

package/dist/src/migrate/presenterFactories.d.ts

@@ -0,0 +1,9 @@
+export interface FactoryDefinition {
+    name: string;
+    exportName: string;
+    keys: Set<string>;
+    helpers: Set<string>;
+}
+/** Only evaluate syntax. Never import or execute the application's factory/configuration. */
+export declare function inspectFactories(input: string, file: string): FactoryDefinition[];
+export declare function replaceFactory(input: string, file: string, definition: FactoryDefinition, keepLegacy: boolean): string;

package/dist/src/migrate/presenters.d.ts

@@ -0,0 +1,13 @@
+export declare function migrateAsyncHelpers(input: string, file: string): string;
+export interface PresenterDependencies {
+    source: string;
+    exportName: string;
+    keys: Set<string>;
+    helpers: Set<string>;
+}
+/** Preserve lexical behavior while moving instance creation and dependencies to RegisterProvider. */
+export declare function migratePresenterSource(input: string, file: string, factories: Set<string>, dependencies?: Map<string, PresenterDependencies>): {
+    content: string;
+    converted: Map<string, string>;
+    issues: string[];
+};

package/dist/src/migrate/translations.d.ts

@@ -0,0 +1,8 @@
+/** A conservative migration of known translation wiring, never a project-wide textual replacement. */
+export declare function migrateTranslationsSources(sources: Map<string, string>, resolve: (from: string, specifier: string) => string | undefined): {
+    updates: Map<string, string>;
+    issues: {
+        file: string;
+        reason: string;
+    }[];
+};

package/dist/src/plugins/addLint.d.ts

@@ -0,0 +1,5 @@
+interface AddLintOptions {
+    manager?: 'pnpm' | 'npm' | 'yarn' | 'bun';
+}
+export default function addLint(_options?: AddLintOptions): Promise<void>;
+export {};

package/dist/src/scaffolds/createCoreSchema.d.ts

@@ -0,0 +1 @@
+export default function createCoreSchema(): Promise<void>;

package/dist/src/scaffolds/createDatasource.d.ts

@@ -0,0 +1 @@
+export default function createDatasource(): Promise<void>;

package/dist/src/scaffolds/createProgram.d.ts

@@ -0,0 +1 @@
+export default function createProgram(): Promise<void>;

package/dist/src/scaffolds/createResponse.d.ts

@@ -0,0 +1 @@
+export default function createResponse(): Promise<void>;

package/dist/src/scaffolds/createSchemaRule.d.ts

@@ -0,0 +1 @@
+export default function createSchemaRule(): Promise<void>;

package/dist/src/scaffolds/createTranslationManager.d.ts

@@ -0,0 +1 @@
+export default function createTranslationManager(): Promise<void>;

package/{src/scaffolds/index.ts → dist/src/scaffolds/index.d.ts}

@@ -1,8 +1,6 @@
 export { default as createCoreSchema } from './createCoreSchema.js';
 export { default as createTranslationManager } from './createTranslationManager.js';
-export { default as createPresenterFactory } from './createPresenterFactory.js';
 export { default as createSchemaRule } from './createSchemaRule.js';
 export { default as createResponse } from './createResponse.js';
 export { default as createDatasource } from './createDatasource.js';
-export { default as createDatasourceProvider } from './createDatasourceProvider.js';
 export { default as createProgram } from './createProgram.js';

package/dist/src/scaffolds/registerDatasource.d.ts

@@ -0,0 +1,2 @@
+/** Only initialize an empty generated DI; never replace application-specific registrations. */
+export declare function registerDatasource(className: string): Promise<void>;

package/dist/src/scaffolds/updateDefaultFactoryConfig.d.ts

@@ -0,0 +1 @@
+export declare function updateDefaultFactoryConfig(content: string, key: 'defaultSchemaFactory', name: string): string;

package/dist/src/utils/architecture.d.ts

@@ -0,0 +1,31 @@
+export declare const SHARED_CONTEXT = "SharedKernel";
+export declare const SHARED_WORKSPACE = "Shared";
+export declare const ARCHITECTURE_ALIASES: {
+    readonly '#contexts': "./src/app/Contexts";
+    readonly '#presentation': "./src/app/Presentation";
+    readonly '#platform': "./src/app/Platform";
+};
+export declare const CONTEXT_DIRS: readonly ["Domain/Entities", "Domain/Ports", "Domain/Enums", "Application/UseCases", "Infrastructure/Repositories"];
+export declare const PRESENTATION_DIRS: readonly ["Ui", "Scopes", "Shell"];
+export declare function normalizePascalName(value: string): string;
+export declare const getAppPath: (cwd?: string) => string;
+export declare const getContextsPath: (cwd?: string) => string;
+export declare const getContextPath: (context: string, cwd?: string) => string;
+export declare const getPresentationPath: (workspace?: string, cwd?: string) => string;
+export declare const getPlatformPath: (cwd?: string) => string;
+export declare const getContextImportPath: (context: string) => string;
+export declare const getPresentationImportPath: (workspace?: string) => string;
+export declare const discoverContexts: (cwd?: string) => Promise<string[]>;
+export declare const discoverPresentationWorkspaces: (cwd?: string) => Promise<string[]>;
+export declare function ensureContextStructure(context: string, cwd?: string): Promise<string>;
+export declare function ensurePresentationStructure(workspace?: string, cwd?: string): Promise<void>;
+export declare function selectContext(message?: string): Promise<string | null>;
+/** null means cancelled; undefined means the flat Presentation layout. */
+export declare function selectPresentationWorkspace(message?: string): Promise<string | null | undefined>;
+export type PresentationWorkspace = {
+    name: string;
+    path: string;
+    alias: string;
+};
+export declare function selectWorkspace(): Promise<PresentationWorkspace | null>;
+export declare function selectScope(workspace: PresentationWorkspace): Promise<string | null>;

package/dist/src/utils/contextUtils.d.ts

@@ -0,0 +1,6 @@
+export { getContextPath, selectContext, selectPresentationWorkspace, discoverContexts, discoverPresentationWorkspaces, normalizePascalName } from './architecture.js';
+export declare function getAvailableFiles(dir: string, pattern?: string): Promise<string[]>;
+export declare function getApplicationProviderServices(): Promise<string[]>;
+export declare function toPascalCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function toKebabCase(str: string): string;

package/dist/src/utils/fileUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function writeIfNotExists(filepath: string, content: string): Promise<boolean>;
+export declare function appendBarrelExports(filepath: string, sources: string[]): Promise<void>;
+export declare function updateIndexTs(dir: string, filePattern?: string, ignore?: string[]): Promise<void>;
+export declare function ensureIndexExports(layerPath: string): Promise<void>;
+export declare function injectIntoFile(filepath: string, searchPattern: string, newContent: string, position?: 'after' | 'before'): Promise<boolean>;

package/dist/src/utils/flattenConfig.d.ts

@@ -0,0 +1,2 @@
+/** Flatten literal-only spreads without evaluating user configuration or duplicating effects. */
+export declare function flattenConfigLiterals(content: string): string;

package/dist/src/utils/legacyAliases.d.ts

@@ -0,0 +1 @@
+export declare function mergeAliasesInSvelteConfig(content: string, aliases: Record<string, string>): string;

package/dist/src/utils/loadConfig.d.ts

@@ -0,0 +1,16 @@
+export type AzureNetConfig = {
+    presentationWorkspaces?: string[];
+    runChecksBeforePush?: boolean;
+    packageManager?: string;
+    defaultSchemaFactory?: string;
+    groupRoutesFunc?: unknown;
+    [key: string]: unknown;
+};
+export declare function resolveConfigFile(cwd?: string): {
+    exists: boolean;
+    filepath: string;
+    type: 'ts' | 'js';
+};
+export declare function loadUserConfig(cwd?: string): Promise<AzureNetConfig>;
+/** Add the default without rewriting or dropping legacy/user configuration. */
+export declare function initializeConfigDefaults(cwd?: string): Promise<void>;

package/dist/src/utils/packageImports.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGE_IMPORTS: any;
+export declare function mergePackageImports(content: string): Promise<string>;
+export declare function initializePackageImports(): Promise<void>;
+export declare function resolvePackageImport(imports: Record<string, unknown>, specifier: string, root: string): string | null;

package/dist/src/utils/sharedFoundation.d.ts

@@ -0,0 +1,20 @@
+export type FoundationConstruct = 'datasource' | 'presenter' | 'provider' | 'response' | 'schema';
+export type ContextConfig = {
+    name: string;
+    alias: string;
+};
+export declare const SHARED_ESSENTIALS_DIR_NAME = "Platform";
+export declare function getSharedState(): Promise<{
+    contexts: ContextConfig[];
+    sharedAlias: string;
+    sharedContext: ContextConfig;
+}>;
+export declare const hasSharedAliasConfig: () => Promise<boolean>;
+export declare const getSharedContextRootPath: (name?: string) => string;
+export declare const getSharedEssentialsPath: (...compatibility: [name?: string]) => string;
+export declare const getFoundationRootPath: (...compatibility: [name?: string]) => string;
+export declare const getFoundationConstructPath: (name: string, construct: FoundationConstruct) => string;
+export declare const getFoundationConstructImportPath: (_alias: string, construct: FoundationConstruct) => string;
+export declare const getLocalizationPath: (...compatibility: [name?: string]) => string;
+export declare const getLocalizationImportPath: (...compatibility: [alias?: string]) => string;
+export declare const getConfigFileLabel: () => string;

package/dist/src/utils/viteConfig.d.ts

@@ -0,0 +1,9 @@
+export declare const VITE_CONFIGS: string[];
+export declare const SVELTE_CONFIGS: string[];
+/** Pure config edit; never evaluates a project's configuration. */
+export declare function mergeKitViteConfig(content: string, aliases: Record<string, string>, legacy?: string): string;
+export declare function formatConfig(content: string, file: string): Promise<string>;
+export declare function configureKitProject(): Promise<void>;
+export declare function readStaticAliases(content: string): Record<string, string>;
+/** Hydratable needs Svelte async mode. Preserve all unrelated literal options. */
+export declare function enableHydratable(content: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "5.1.1",
+  "version": "6.0.0-next.3",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"
@@ -12,11 +12,13 @@
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
-    "@azure-net/kit": ">=5.0.0-4"
+    "@azure-net/kit": ">=6.0.0-next.1"
   },
   "dependencies": {
     "commander": "^11",
-    "prompts": "^2"
+    "prompts": "^2",
+    "typescript": "^5",
+    "prettier": "^3.6.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.31.0",
@@ -24,14 +26,22 @@
     "@types/prompts": "^2.4.9",
     "env-cmd": "^11.0.0",
     "eslint": "^9.31.0",
-    "prettier": "^3.6.2",
-    "typescript": "^5",
     "typescript-eslint": "^8.36.0"
   },
+  "files": [
+    "bin/*.js",
+    "src/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.15.0"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node scripts/clean-build.mjs && tsc -p tsconfig.json && node scripts/sync-build.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "lint": "eslint \"bin/**/*.ts\" \"src/**/*.ts\"",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "test": "pnpm build && node --test tests/*.test.mjs"
   }
 }

package/src/checks/architecture.js

@@ -0,0 +1,154 @@
+import { resolvePackageImport } from '../utils/packageImports.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readStaticAliases, VITE_CONFIGS, SVELTE_CONFIGS } from '../utils/viteConfig.js';
+import ts from 'typescript';
+export const appRoot = () => path.join(process.cwd(), 'src', 'app');
+export const directories = async (root) => (await fs.readdir(root, { withFileTypes: true }))
+    .filter((entry) => entry.isDirectory() && entry.name !== '.backup')
+    .map((entry) => entry.name);
+export async function sourceFiles(root) {
+    const files = [];
+    for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+        if (['.backup', 'node_modules', '.git', '.svelte-kit', 'dist'].includes(entry.name))
+            continue;
+        const file = path.join(root, entry.name);
+        if (entry.isDirectory())
+            files.push(...(await sourceFiles(file)));
+        else if (/\.(?:[cm]?[jt]sx?|svelte)$/.test(entry.name))
+            files.push(file);
+    }
+    return files;
+}
+export function parseSource(content, filename = 'Source.ts') {
+    // Mask markup while retaining offsets for accurate Svelte script diagnostics.
+    if (filename.endsWith('.svelte')) {
+        const pieces = [];
+        let end = 0;
+        const scripts = /<!--[^]*?-->|<script\b[^>]*>([^]*?)<\/script\s*>/gi;
+        for (const match of content.matchAll(scripts)) {
+            if (match[1] === undefined)
+                continue;
+            const start = match.index + match[0].indexOf('>') + 1;
+            pieces.push(content.slice(end, start).replace(/[^\r\n]/g, ' '), match[1]);
+            end = start + match[1].length;
+        }
+        pieces.push(content.slice(end).replace(/[^\r\n]/g, ' '));
+        content = pieces.join('');
+    }
+    return ts.createSourceFile(filename, content, ts.ScriptTarget.Latest, true, /\.[jt]sx$/.test(filename) ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+}
+export function dependencies(content, filename = 'Source.ts') {
+    const result = [];
+    const sourceFile = parseSource(content, filename);
+    const add = (literal, node, kind) => {
+        if (!literal || (!ts.isStringLiteral(literal) && !ts.isNoSubstitutionTemplateLiteral(literal)))
+            return;
+        result.push({ source: literal.text, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1, kind });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const clause = node.importClause;
+            const bindings = clause?.namedBindings;
+            const inlineTypes = !clause?.name &&
+                bindings &&
+                ts.isNamedImports(bindings) &&
+                bindings.elements.length > 0 &&
+                bindings.elements.every((element) => element.isTypeOnly);
+            add(node.moduleSpecifier, node, !clause ? 'side-effect' : clause.isTypeOnly || inlineTypes ? 'type' : 'value');
+        }
+        else if (ts.isExportDeclaration(node))
+            add(node.moduleSpecifier, node, 'export');
+        else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword)
+            add(node.arguments[0], node, 'dynamic');
+        else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument))
+            add(node.argument.literal, node, 'dynamic');
+        else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference))
+            add(node.moduleReference.expression, node, node.isTypeOnly ? 'type' : 'value');
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return result;
+}
+export function exportOnly(content) {
+    return parseSource(content).statements.every((node) => ts.isExportDeclaration(node) || ts.isEmptyStatement(node));
+}
+export async function importResolver() {
+    const aliases = {
+        '#contexts': 'src/app/Contexts',
+        '#presentation': 'src/app/Presentation',
+        '#platform': 'src/app/Platform',
+        $lib: 'src/lib',
+        '#lib': 'src/lib'
+    };
+    for (const name of [...VITE_CONFIGS, ...SVELTE_CONFIGS]) {
+        const configPath = path.join(process.cwd(), name);
+        try {
+            await fs.access(configPath);
+        }
+        catch {
+            continue;
+        }
+        Object.assign(aliases, readStaticAliases(await fs.readFile(configPath, 'utf8')));
+        break;
+    }
+    let imports = {};
+    try {
+        imports = JSON.parse(await fs.readFile(path.join(process.cwd(), 'package.json'), 'utf8')).imports ?? {};
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const entries = Object.entries(aliases).sort(([a], [b]) => b.length - a.length);
+    return (file, source) => {
+        const clean = source[0] + source.slice(1).split(/[?#]/)[0];
+        const imported = resolvePackageImport(imports, clean, process.cwd());
+        if (imported)
+            return imported;
+        if (clean.startsWith('.'))
+            return path.resolve(path.dirname(file), clean);
+        if (path.isAbsolute(clean))
+            return path.resolve(clean);
+        for (const [key, target] of entries) {
+            const alias = key.replace(/\/\*$/, '');
+            if (clean !== alias && !clean.startsWith(`${alias}/`))
+                continue;
+            return path.resolve(process.cwd(), target.replace(/\/\*$/, ''), clean.slice(alias.length).replace(/^\//, ''));
+        }
+        return null;
+    };
+}
+export function location(file) {
+    return path.relative(appRoot(), file).split(path.sep);
+}
+export function report(label, issues) {
+    if (!issues.length) {
+        console.log(`${label} check passed.`);
+        return;
+    }
+    console.error(`${label} check failed:`);
+    for (const issue of issues)
+        console.error(`${path.relative(process.cwd(), issue.file)}:${issue.line} - ${issue.message}`);
+    process.exitCode = 1;
+}
+export async function checkDependencies(label, rule) {
+    const issues = [];
+    try {
+        const resolve = await importResolver();
+        for (const file of await sourceFiles(appRoot())) {
+            for (const entry of dependencies(await fs.readFile(file, 'utf8'), file)) {
+                const target = resolve(file, entry.source);
+                if (!target)
+                    continue;
+                const message = rule(location(file), location(target));
+                if (message)
+                    issues.push({ file, line: entry.line, message: `${message} (${entry.source})` });
+            }
+        }
+    }
+    catch (error) {
+        issues.push({ file: appRoot(), line: 1, message: String(error) });
+    }
+    report(label, issues);
+}