@open-mova/cli 0.1.20 → 0.1.22

package/dist/application/core-compatibility.d.ts

@@ -0,0 +1,3 @@
+import type { OpenMovaApplicationConfiguration } from '../types.js';
+export declare function areCoreRangesCompatible(first: string, second: string): boolean;
+export declare function findIncompatibleMicrofrontends(configuration: OpenMovaApplicationConfiguration, shellCoreVersion: string): readonly string[];

package/dist/application/core-compatibility.js

@@ -0,0 +1,10 @@
+import { intersects, validRange } from 'semver';
+export function areCoreRangesCompatible(first, second) {
+    return validRange(first) !== null && validRange(second) !== null && intersects(first, second);
+}
+export function findIncompatibleMicrofrontends(configuration, shellCoreVersion) {
+    return configuration.microfrontends
+        .filter((microfrontend) => !areCoreRangesCompatible(shellCoreVersion, microfrontend.compatibility.requiredCoreVersion))
+        .map((microfrontend) => `mova.config.json#microfrontends.${microfrontend.name}.compatibility ` +
+        `(shell ${shellCoreVersion}, MF ${microfrontend.compatibility.requiredCoreVersion})`);
+}

package/dist/application/doctor.d.ts

@@ -0,0 +1,12 @@
+export type DoctorCheckStatus = 'ok' | 'warning' | 'error';
+export interface DoctorCheck {
+    readonly id: string;
+    readonly status: DoctorCheckStatus;
+    readonly message: string;
+    readonly detail?: string;
+}
+export interface DoctorReport {
+    readonly applicationRoot?: string;
+    readonly checks: readonly DoctorCheck[];
+}
+export declare function inspectDevelopmentEnvironment(startDirectory: string): DoctorReport;

package/dist/application/doctor.js

@@ -0,0 +1,304 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { findApplicationRoot, readApplicationConfigurationDocument } from './configuration.js';
+import { npmCommand } from '../utils/platform.js';
+import { areCoreRangesCompatible } from './core-compatibility.js';
+export function inspectDevelopmentEnvironment(startDirectory) {
+    const checks = [];
+    const applicationRoot = findApplicationRoot(resolve(startDirectory));
+    checks.push(checkNodeVersion());
+    checks.push(checkCommand(npmCommand(), ['--version'], 'npm', true, 'npm'));
+    checks.push(checkCommand('git', ['--version'], 'Git', true));
+    if (!applicationRoot) {
+        checks.push({
+            id: 'application',
+            status: 'warning',
+            message: 'No se ha encontrado una aplicación Open Mova.',
+            detail: 'Ejecuta el comando dentro de un directorio que contenga mova.config.json.',
+        });
+        return { checks };
+    }
+    checks.push({
+        id: 'application',
+        status: 'ok',
+        message: `Aplicación encontrada en ${applicationRoot}.`,
+    });
+    let configuration;
+    try {
+        const document = readApplicationConfigurationDocument(applicationRoot);
+        configuration = document.configuration;
+        checks.push({
+            id: 'configuration',
+            status: 'ok',
+            message: 'mova.config.json tiene un formato válido.',
+        });
+        if (document.migrations.length > 0) {
+            checks.push({
+                id: 'configuration-migrations',
+                status: 'warning',
+                message: 'mova.config.json necesita migraciones.',
+                detail: 'Ejecuta mova update para guardarlo con el esquema actual.',
+            });
+        }
+    }
+    catch (error) {
+        checks.push({
+            id: 'configuration',
+            status: 'error',
+            message: 'mova.config.json no es válido.',
+            detail: error instanceof Error ? error.message : undefined,
+        });
+        return { applicationRoot, checks };
+    }
+    checks.push(checkDependencies(applicationRoot, 'shell'));
+    checks.push(checkShellVersion(configuration.shell?.version));
+    const shellPackage = readOptionalPackage(applicationRoot);
+    const shellCoreVersion = shellPackage?.dependencies?.['@open-mova/core'];
+    for (const microfrontend of configuration.microfrontends) {
+        if (microfrontend.sourcePath) {
+            const microfrontendRoot = resolve(applicationRoot, microfrontend.sourcePath);
+            if (!existsSync(microfrontendRoot)) {
+                checks.push({
+                    id: `microfrontend:${microfrontend.name}:source`,
+                    status: 'error',
+                    message: `No existe el directorio del MF ${microfrontend.name}.`,
+                    detail: microfrontendRoot,
+                });
+            }
+            else {
+                checks.push(checkDependencies(microfrontendRoot, `MF ${microfrontend.name}`));
+                checks.push(checkCoreCompatibility(microfrontend.name, shellCoreVersion, readOptionalPackage(microfrontendRoot)?.dependencies?.['@open-mova/core']));
+            }
+        }
+        checks.push(checkProductionRemote(microfrontend.name, microfrontend.productionRemoteEntry));
+    }
+    const hasAndroid = existsSync(join(applicationRoot, 'android'));
+    const hasIos = existsSync(join(applicationRoot, 'ios'));
+    checks.push({
+        id: 'capacitor-platforms',
+        status: hasAndroid || hasIos ? 'ok' : 'warning',
+        message: hasAndroid || hasIos
+            ? `Plataformas añadidas: ${[hasAndroid && 'Android', hasIos && 'iOS'].filter(Boolean).join(', ')}.`
+            : 'No hay plataformas nativas añadidas todavía.',
+    });
+    if (hasAndroid) {
+        checks.push(checkAndroidSdk());
+        checks.push(checkCommand('adb', ['version'], 'Android Platform Tools (adb)', true));
+        checks.push(checkAndroidEmulators());
+        checks.push(checkGoogleMapsKey(applicationRoot, configuration.native?.googleMaps?.androidApiKey));
+    }
+    if (hasIos) {
+        if (process.platform !== 'darwin') {
+            checks.push({
+                id: 'ios-platform',
+                status: 'error',
+                message: 'La compilación de iOS requiere macOS.',
+            });
+        }
+        else {
+            checks.push(checkCommand('xcodebuild', ['-version'], 'Xcode', true));
+            checks.push(checkCommand('pod', ['--version'], 'CocoaPods', false));
+        }
+        checks.push(...checkIosUsageDescriptions(applicationRoot, shellPackage));
+    }
+    return { applicationRoot, checks };
+}
+function checkNodeVersion() {
+    const majorVersion = Number(process.versions.node.split('.')[0]);
+    return majorVersion >= 22
+        ? { id: 'node', status: 'ok', message: `Node.js ${process.versions.node}.` }
+        : {
+            id: 'node',
+            status: 'error',
+            message: `Node.js ${process.versions.node} no es compatible.`,
+            detail: 'Instala Node.js 22 o posterior.',
+        };
+}
+function checkCommand(command, args, label, required, id = command) {
+    const result = spawnSync(command, [...args], { encoding: 'utf8' });
+    const available = !result.error && result.status === 0;
+    const version = available ? (result.stdout || result.stderr).trim().split(/\r?\n/)[0] : undefined;
+    return {
+        id: `command:${id}`,
+        status: available ? 'ok' : required ? 'error' : 'warning',
+        message: available ? `${label}: ${version}.` : `${label} no está disponible.`,
+    };
+}
+function checkDependencies(directory, label) {
+    const packagePath = join(directory, 'package.json');
+    if (!existsSync(packagePath)) {
+        return {
+            id: `dependencies:${label}`,
+            status: 'error',
+            message: `${label} no contiene package.json.`,
+        };
+    }
+    return existsSync(join(directory, 'node_modules'))
+        ? {
+            id: `dependencies:${label}`,
+            status: 'ok',
+            message: `${label}: dependencias instaladas.`,
+        }
+        : {
+            id: `dependencies:${label}`,
+            status: 'warning',
+            message: `${label}: faltan las dependencias.`,
+            detail: `Ejecuta npm install en ${directory}.`,
+        };
+}
+function checkShellVersion(version) {
+    return version && /^v\d+\.\d+\.\d+$/.test(version)
+        ? { id: 'shell-version', status: 'ok', message: `Shell registrada: ${version}.` }
+        : {
+            id: 'shell-version',
+            status: 'error',
+            message: 'La aplicación no tiene una versión estable de shell registrada.',
+        };
+}
+function checkCoreCompatibility(microfrontendName, shellVersion, microfrontendVersion) {
+    if (!microfrontendVersion) {
+        return {
+            id: `microfrontend:${microfrontendName}:core`,
+            status: 'warning',
+            message: `El MF ${microfrontendName} no declara @open-mova/core.`,
+        };
+    }
+    if (microfrontendVersion === '*') {
+        return {
+            id: `microfrontend:${microfrontendName}:core`,
+            status: 'warning',
+            message: `El MF ${microfrontendName} necesita concretar su rango de @open-mova/core.`,
+            detail: 'Ejecuta mova mf update o registra de nuevo el MF con --core-version.',
+        };
+    }
+    if (!shellVersion || !areCoreRangesCompatible(shellVersion, microfrontendVersion)) {
+        return {
+            id: `microfrontend:${microfrontendName}:core`,
+            status: 'error',
+            message: `El MF ${microfrontendName} y la shell usan rangos distintos de @open-mova/core.`,
+            detail: `Shell: ${shellVersion ?? 'no declarado'}; MF: ${microfrontendVersion}.`,
+        };
+    }
+    return {
+        id: `microfrontend:${microfrontendName}:core`,
+        status: 'ok',
+        message: `El MF ${microfrontendName} comparte ${microfrontendVersion} de @open-mova/core.`,
+    };
+}
+function checkProductionRemote(name, remoteEntry) {
+    const isHttps = remoteEntry === undefined ? false : isHttpsUrl(remoteEntry);
+    return isHttps
+        ? {
+            id: `microfrontend:${name}:production`,
+            status: 'ok',
+            message: `El MF ${name} tiene una URL HTTPS de producción.`,
+        }
+        : {
+            id: `microfrontend:${name}:production`,
+            status: 'warning',
+            message: `El MF ${name} no tiene una URL HTTPS de producción válida.`,
+        };
+}
+function isHttpsUrl(value) {
+    try {
+        return new URL(value).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function checkAndroidSdk() {
+    const sdkRoot = process.env['ANDROID_SDK_ROOT'] ?? process.env['ANDROID_HOME'];
+    return sdkRoot && existsSync(sdkRoot)
+        ? { id: 'android-sdk', status: 'ok', message: `Android SDK: ${sdkRoot}.` }
+        : {
+            id: 'android-sdk',
+            status: 'warning',
+            message: 'No se ha detectado ANDROID_SDK_ROOT ni ANDROID_HOME.',
+        };
+}
+function checkAndroidEmulators() {
+    const result = spawnSync('emulator', ['-list-avds'], { encoding: 'utf8' });
+    if (result.error || result.status !== 0) {
+        return {
+            id: 'android-emulators',
+            status: 'warning',
+            message: 'No se ha podido consultar el listado de emuladores Android.',
+        };
+    }
+    const emulators = result.stdout.split(/\r?\n/).filter(Boolean);
+    return emulators.length > 0
+        ? {
+            id: 'android-emulators',
+            status: 'ok',
+            message: `Emuladores Android disponibles: ${emulators.length}.`,
+        }
+        : {
+            id: 'android-emulators',
+            status: 'warning',
+            message: 'No hay emuladores Android configurados.',
+        };
+}
+function checkGoogleMapsKey(applicationRoot, configuredKey) {
+    const resourcePath = join(applicationRoot, 'android', 'app', 'src', 'main', 'res', 'values', 'open_mova_google_maps.xml');
+    const resource = existsSync(resourcePath) ? readFileSync(resourcePath, 'utf8') : '';
+    const hasKey = Boolean(process.env['OPEN_MOVA_GOOGLE_MAPS_ANDROID_API_KEY'] ||
+        configuredKey ||
+        (resource && !resource.includes('OPEN_MOVA_GOOGLE_MAPS_API_KEY_NOT_CONFIGURED')));
+    return hasKey
+        ? { id: 'google-maps-key', status: 'ok', message: 'Google Maps tiene una clave configurada.' }
+        : {
+            id: 'google-maps-key',
+            status: 'warning',
+            message: 'Google Maps no tiene una clave Android configurada.',
+        };
+}
+function checkIosUsageDescriptions(applicationRoot, packageConfiguration) {
+    const plistPath = join(applicationRoot, 'ios', 'App', 'App', 'Info.plist');
+    if (!existsSync(plistPath)) {
+        return [
+            {
+                id: 'ios-info-plist',
+                status: 'error',
+                message: 'No se encuentra ios/App/App/Info.plist.',
+            },
+        ];
+    }
+    const plist = readFileSync(plistPath, 'utf8');
+    const requiredKeys = [];
+    if (packageConfiguration?.dependencies?.['@capacitor/camera']) {
+        requiredKeys.push('NSCameraUsageDescription', 'NSPhotoLibraryUsageDescription', 'NSPhotoLibraryAddUsageDescription');
+    }
+    if (packageConfiguration?.dependencies?.['@capacitor/geolocation']) {
+        requiredKeys.push('NSLocationWhenInUseUsageDescription');
+    }
+    const missingKeys = requiredKeys.filter((key) => !plist.includes(`<key>${key}</key>`));
+    return missingKeys.length === 0
+        ? [
+            {
+                id: 'ios-info-plist',
+                status: 'ok',
+                message: 'Info.plist contiene los permisos básicos requeridos.',
+            },
+        ]
+        : [
+            {
+                id: 'ios-info-plist',
+                status: 'warning',
+                message: 'Info.plist no contiene todas las descripciones de uso necesarias.',
+                detail: `Faltan: ${missingKeys.join(', ')}.`,
+            },
+        ];
+}
+function readOptionalPackage(directory) {
+    const packagePath = join(directory, 'package.json');
+    if (!existsSync(packagePath))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(packagePath, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/application/microfrontend-manifest.d.ts

@@ -0,0 +1,3 @@
+export declare const MICROFRONTEND_MANIFEST_PATH = "assets/open-mova.manifest.json";
+export declare function readRequiredCoreVersion(projectRoot: string): string;
+export declare function writeMicrofrontendManifest(projectRoot: string, name: string, remoteName: string, requiredCoreVersion: string): void;

package/dist/application/microfrontend-manifest.js

@@ -0,0 +1,20 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const MICROFRONTEND_MANIFEST_PATH = 'assets/open-mova.manifest.json';
+export function readRequiredCoreVersion(projectRoot) {
+    const packageConfiguration = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'));
+    const requiredVersion = packageConfiguration.dependencies?.['@open-mova/core'];
+    if (!requiredVersion) {
+        throw new Error(`${projectRoot} debe declarar @open-mova/core en dependencies para definir su compatibilidad.`);
+    }
+    return requiredVersion;
+}
+export function writeMicrofrontendManifest(projectRoot, name, remoteName, requiredCoreVersion) {
+    const manifest = {
+        schemaVersion: 1,
+        name,
+        remoteName,
+        core: { requiredVersion: requiredCoreVersion },
+    };
+    writeFileSync(join(projectRoot, 'src', 'assets', 'open-mova.manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}

package/dist/application/microfrontend-profile.js

@@ -1,6 +1,7 @@
 import { readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { toDisplayName, toRemoteName } from '../utils/names.js';
+import { readRequiredCoreVersion, writeMicrofrontendManifest } from './microfrontend-manifest.js';
 export function configureDownloadedMicrofrontend(destination, name, port, profile) {
     const projectName = `mova-mf-${name}`;
     const packagePath = join(destination, 'package.json');
@@ -9,7 +10,6 @@ export function configureDownloadedMicrofrontend(destination, name, port, profil
     packageJson.scripts.start = `ng serve ${projectName}`;
     packageJson.scripts.build = `ng build ${projectName}`;
     if (profile === 'minimal') {
-        delete packageJson.dependencies['@open-mova/core'];
         writeFileSync(join(destination, 'src/app/app.routes.ts'), minimalRoutes(name));
         writeFileSync(join(destination, 'src/app/app.config.ts'), minimalAppConfig());
     }
@@ -27,6 +27,7 @@ export function configureDownloadedMicrofrontend(destination, name, port, profil
         .replaceAll('mova-demo-microfrontend', `mova-${name}-microfrontend`));
     const appPath = join(destination, 'src/app/app.ts');
     writeFileSync(appPath, readFileSync(appPath, 'utf8').replace('mova-demo-microfrontend', `mova-${name}-microfrontend`));
+    writeMicrofrontendManifest(destination, name, toRemoteName(name), readRequiredCoreVersion(destination));
     // El lock heredado ya no representa el proyecto renombrado ni su dependencia local.
     rmSync(join(destination, 'package-lock.json'), { force: true });
     writeFileSync(join(destination, 'README.md'), `# ${projectName}\n\nMicrofrontal Open Mova (${profile}). Ejecuta \`npm install\` y \`npm start\`. La shell lo carga en http://localhost:${port}/remoteEntry.json.\n`);

package/dist/application/microfrontend-update.d.ts

@@ -0,0 +1,17 @@
+import type { MicrofrontendConfiguration, OpenMovaApplicationConfiguration } from '../types.js';
+import { type FileChange } from './project-update.js';
+import { type ShellVersion } from './shell-repository.js';
+export interface MicrofrontendUpdatePlan {
+    readonly microfrontend: MicrofrontendConfiguration;
+    readonly projectRoot: string;
+    readonly currentVersion: string;
+    readonly target: ShellVersion;
+    readonly targetCoreVersion: string;
+    readonly changes: readonly string[];
+    readonly conflicts: readonly string[];
+    readonly fileChanges: readonly FileChange[];
+    readonly packageContent?: string;
+    readonly removePackageLock: boolean;
+}
+export declare function createMicrofrontendUpdatePlan(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, name: string, requestedVersion?: string): MicrofrontendUpdatePlan;
+export declare function applyMicrofrontendUpdate(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, plan: MicrofrontendUpdatePlan): void;

package/dist/application/microfrontend-update.js

@@ -0,0 +1,117 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { writeApplicationConfiguration } from './configuration.js';
+import { readRequiredCoreVersion } from './microfrontend-manifest.js';
+import { configureDownloadedMicrofrontend } from './microfrontend-profile.js';
+import { applyFileChanges, compareManagedFiles, comparePackageConfiguration, requireCleanGitRepository, } from './project-update.js';
+import { downloadTaggedProject, listShellVersions } from './shell-repository.js';
+import { synchronizeShellConfiguration } from './shell-configuration.js';
+const GENERATED_PATHS = new Set(['package.json', 'package-lock.json']);
+export function createMicrofrontendUpdatePlan(applicationRoot, configuration, name, requestedVersion) {
+    const microfrontend = configuration.microfrontends.find((entry) => entry.name === name);
+    if (!microfrontend)
+        throw new Error(`No existe un microfrontal llamado "${name}".`);
+    if (!microfrontend.sourcePath || !microfrontend.template) {
+        throw new Error(`El MF ${name} no fue creado desde una plantilla gestionada por Open Mova y no se puede actualizar automáticamente.`);
+    }
+    const targetVersion = requestedVersion ?? listShellVersions()[0];
+    if (!targetVersion)
+        throw new Error('No hay versiones estables disponibles para actualizar.');
+    if (compareVersions(targetVersion, microfrontend.template.version) < 0) {
+        throw new Error('mova mf update no realiza downgrades de plantillas.');
+    }
+    const projectRoot = resolve(applicationRoot, microfrontend.sourcePath);
+    const port = readPort(microfrontend.developmentRemoteEntry);
+    const temporaryRoot = mkdtempSync(join(tmpdir(), 'open-mova-mf-update-'));
+    try {
+        const currentDirectory = join(temporaryRoot, 'current');
+        const targetDirectory = join(temporaryRoot, 'target');
+        const current = downloadTaggedProject('open-mova-mf-template', currentDirectory, microfrontend.template.version);
+        const target = downloadTaggedProject('open-mova-mf-template', targetDirectory, targetVersion);
+        if (current.commit !== microfrontend.template.commit) {
+            throw new Error(`El commit registrado para la plantilla ${microfrontend.template.version} no coincide con su tag.`);
+        }
+        configureDownloadedMicrofrontend(currentDirectory, microfrontend.name, port, microfrontend.template.profile);
+        configureDownloadedMicrofrontend(targetDirectory, microfrontend.name, port, microfrontend.template.profile);
+        const conflicts = [];
+        const fileChanges = compareManagedFiles(projectRoot, currentDirectory, targetDirectory, conflicts, GENERATED_PATHS);
+        const packageContent = comparePackageConfiguration(projectRoot, currentDirectory, targetDirectory, conflicts);
+        const targetCoreVersion = readRequiredCoreVersion(targetDirectory);
+        const changes = [
+            ...fileChanges.map((change) => `${change.content ? 'Actualizar' : 'Eliminar'} ${change.path}`),
+            ...(packageContent ? ['Actualizar package.json', 'Regenerar package-lock.json'] : []),
+            ...(target.version === microfrontend.template.version
+                ? []
+                : [`Registrar plantilla ${target.version}`]),
+            ...(targetCoreVersion === microfrontend.compatibility.requiredCoreVersion
+                ? []
+                : [`Actualizar compatibilidad de Core a ${targetCoreVersion}`]),
+        ];
+        return {
+            microfrontend,
+            projectRoot,
+            currentVersion: microfrontend.template.version,
+            target,
+            targetCoreVersion,
+            changes,
+            conflicts,
+            fileChanges,
+            ...(packageContent ? { packageContent } : {}),
+            removePackageLock: packageContent !== undefined,
+        };
+    }
+    finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
+export function applyMicrofrontendUpdate(applicationRoot, configuration, plan) {
+    if (plan.conflicts.length > 0) {
+        throw new Error('No se puede actualizar el microfrontal mientras existan conflictos.');
+    }
+    requireCleanGitRepository(applicationRoot);
+    const projectPath = relative(applicationRoot, plan.projectRoot);
+    if (isAbsolute(projectPath) || projectPath.startsWith('..')) {
+        requireCleanGitRepository(plan.projectRoot);
+    }
+    applyFileChanges(plan.projectRoot, plan.fileChanges);
+    if (plan.packageContent) {
+        writeFileSync(join(plan.projectRoot, 'package.json'), plan.packageContent, 'utf8');
+    }
+    if (plan.removePackageLock) {
+        rmSync(join(plan.projectRoot, 'package-lock.json'), { force: true });
+    }
+    const updatedConfiguration = {
+        ...configuration,
+        microfrontends: configuration.microfrontends.map((entry) => entry.name === plan.microfrontend.name
+            ? {
+                ...entry,
+                compatibility: { requiredCoreVersion: plan.targetCoreVersion },
+                template: {
+                    ...plan.target,
+                    project: 'open-mova-mf-template',
+                    profile: plan.microfrontend.template.profile,
+                },
+            }
+            : entry),
+    };
+    writeApplicationConfiguration(applicationRoot, updatedConfiguration);
+    synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
+}
+function readPort(remoteEntry) {
+    const port = Number(new URL(remoteEntry).port);
+    if (!Number.isInteger(port) || port < 1) {
+        throw new Error(`No se puede obtener el puerto de desarrollo desde ${remoteEntry}.`);
+    }
+    return port;
+}
+function compareVersions(first, second) {
+    const firstParts = first.slice(1).split('.').map(Number);
+    const secondParts = second.slice(1).split('.').map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (firstParts[index] ?? 0) - (secondParts[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}

package/dist/application/microfrontend.d.ts

@@ -17,6 +17,7 @@ export interface ExistingMicrofrontendOptions {
     readonly remoteEntry?: string;
     readonly productionRemoteEntry?: string;
     readonly port?: number;
+    readonly coreVersion?: string;
 }
 export declare function createMicrofrontend(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, options: CreateMicrofrontendOptions): MicrofrontendConfiguration;
 export declare function inspectExistingMicrofrontend(applicationRoot: string, options: ExistingMicrofrontendOptions): MicrofrontendConfiguration;

package/dist/application/microfrontend.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, rmSync } from 'node:fs';
 import { relative, resolve, sep } from 'node:path';
 import { normalizeName, toRemoteName } from '../utils/names.js';
-import { configureDownloadedMicrofrontend } from './microfrontend-profile.js';
+import { configureDownloadedMicrofrontend, } from './microfrontend-profile.js';
 import { downloadTaggedProject } from './shell-repository.js';
+import { readRequiredCoreVersion } from './microfrontend-manifest.js';
 export function createMicrofrontend(applicationRoot, configuration, options) {
     const name = normalizeName(options.name, 'El nombre del microfrontal');
     const route = normalizeName(options.route ?? name, 'La ruta del microfrontal');
@@ -32,6 +33,9 @@ export function createMicrofrontend(applicationRoot, configuration, options) {
             ? { productionRemoteEntry: options.productionRemoteEntry }
             : {}),
         sourcePath: toConfigurationPath(applicationRoot, destination),
+        compatibility: {
+            requiredCoreVersion: readRequiredCoreVersion(destination),
+        },
         template: { ...template, project: 'open-mova-mf-template', profile },
     };
 }
@@ -44,7 +48,7 @@ export function inspectExistingMicrofrontend(applicationRoot, options) {
         : undefined;
     const discovered = sourceDirectory
         ? inspectLocalProject(sourceDirectory)
-        : { remoteName: undefined, port: undefined };
+        : { remoteName: undefined, port: undefined, requiredCoreVersion: undefined };
     const remoteName = options.remoteName ?? discovered.remoteName;
     const inferredName = remoteName?.replace(/-microfrontend$/, '');
     const name = normalizeName(options.name ?? inferredName ?? '', 'El nombre del microfrontal');
@@ -59,6 +63,12 @@ export function inspectExistingMicrofrontend(applicationRoot, options) {
     if (!remoteEntry) {
         throw new Error('No se ha podido detectar el puerto. Indica --remote-entry o --port.');
     }
+    const requiredCoreVersion = options.coreVersion ??
+        discovered.requiredCoreVersion ??
+        readRequiredCoreVersion(applicationRoot);
+    if (!requiredCoreVersion) {
+        throw new Error('Indica --core-version para declarar qué versión de @open-mova/core necesita el microfrontal remoto.');
+    }
     return {
         name,
         route,
@@ -71,6 +81,7 @@ export function inspectExistingMicrofrontend(applicationRoot, options) {
         ...(sourceDirectory
             ? { sourcePath: toConfigurationPath(applicationRoot, sourceDirectory) }
             : {}),
+        compatibility: { requiredCoreVersion },
     };
 }
 function inspectLocalProject(directory) {
@@ -85,7 +96,7 @@ function inspectLocalProject(directory) {
     const federationContent = readFileSync(federationConfiguration, 'utf8');
     const remoteName = federationContent.match(/\bname\s*:\s*['"]([^'"]+)['"]/)?.[1];
     const port = readPort(angularConfiguration);
-    return { remoteName, port };
+    return { remoteName, port, requiredCoreVersion: readRequiredCoreVersion(directory) };
 }
 function readPort(configurationPath) {
     const parsed = JSON.parse(readFileSync(configurationPath, 'utf8'));

package/dist/application/native-capabilities.d.ts

@@ -0,0 +1,15 @@
+import type { OpenMovaApplicationConfiguration } from '../types.js';
+import { type NativeCapabilityDefinition } from './shell-configuration.js';
+export interface NativeCapabilityStatus {
+    readonly definition: NativeCapabilityDefinition;
+    readonly enabled: boolean;
+}
+export declare function listNativeCapabilities(applicationRoot: string): readonly NativeCapabilityStatus[];
+export declare function enableNativeCapabilities(applicationRoot: string, requestedNames: readonly string[]): OpenMovaApplicationConfiguration;
+export declare function disableNativeCapabilities(applicationRoot: string, requestedNames: readonly string[]): OpenMovaApplicationConfiguration;
+export declare function diagnoseNativeCapabilities(applicationRoot: string, platform?: 'android' | 'ios'): readonly string[];
+/**
+ * Recompone las dependencias seleccionables después de actualizar la shell.
+ * No instala paquetes: el flujo de update regenera después el lockfile.
+ */
+export declare function synchronizeNativeCapabilityDependencies(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;