slicejs-cli 3.4.0 → 3.5.0

package/commands/types/types.js

@@ -4,6 +4,7 @@ import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 
 import Print from '../Print.js';
+import { getConfigPath, getComponentsJsPath, joinRoot } from '../utils/PathHelper.js';
 
 const TYPE_MAP = {
   string: 'string',
@@ -114,22 +115,29 @@ const sortKeys = (obj) => {
     }, {});
 };
 
-const parseComponentsRegistry = (content) => {
+const parseComponentsRegistry = (content, filePath) => {
   const match = content.match(/const components = ({[\s\S]*?});/);
   if (!match) {
-    throw new Error('Invalid components.js format. Expected: const components = { ... };');
+    throw new Error(`Invalid format in ${filePath}. Expected: const components = { ... };`);
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch (parseError) {
+    throw new Error(`Failed to parse components registry in ${filePath}: ${parseError.message}`);
   }
-  return JSON.parse(match[1]);
 };
 
-const extractStaticPropsFromSource = (source) => {
+const extractStaticPropsFromSource = (source, filePath) => {
   let ast;
   try {
     ast = parse(source, {
       sourceType: 'module',
       plugins: ['classProperties']
     });
-  } catch {
+  } catch (parseError) {
+    const sourceDesc = filePath || 'unknown file';
+    const loc = parseError.loc ? ` at line ${parseError.loc.line}, column ${parseError.loc.column}` : '';
+    Print.warning(`Parse error in ${sourceDesc}${loc}: ${parseError.message}`);
     return null;
   }
 
@@ -194,7 +202,7 @@ const DEFAULT_EDITOR_EXCLUDE = ['node_modules', 'dist', 'src/libs/**', 'tests/**
 const NOISY_INCLUDE_PATTERNS = new Set(['src/**/*.js', 'api/**/*.js', 'tests/**/*.js']);
 
 const readPublicFolderExcludes = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return [];
 
   try {
@@ -230,7 +238,7 @@ const collectJavaScriptFiles = async (dirPath) => {
 };
 
 const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return { updatedFiles: 0, scannedFiles: 0 };
 
   let parsed;
@@ -245,7 +253,7 @@ const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
     .map((folder) => String(folder || '').trim())
     .filter(Boolean)
     .map((folder) => folder.replace(/^[/\\]+/, ''))
-    .map((folder) => path.join(projectRoot, 'src', folder));
+    .map((folder) => joinRoot(projectRoot, 'src', folder));
 
   const uniqueDirs = Array.from(new Set(candidateDirs));
   let scannedFiles = 0;
@@ -360,9 +368,11 @@ const readCategoryPathFromConfig = async (configPath, category) => {
 };
 
 const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   const categoryPathCache = new Map();
   const componentPropsMap = {};
+  let skippedCount = 0;
+  let processedCount = 0;
 
   for (const [componentName, category] of Object.entries(sortKeys(registryMap))) {
     if (!categoryPathCache.has(category)) {
@@ -372,26 +382,50 @@ const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
 
     const categoryPath = categoryPathCache.get(category);
     if (!categoryPath) {
+      skippedCount++;
       continue;
     }
 
-    const componentFile = path.join(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
+    const componentFile = joinRoot(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
     if (!(await fs.pathExists(componentFile))) {
+      skippedCount++;
+      continue;
+    }
+
+    let source;
+    try {
+      source = await fs.readFile(componentFile, 'utf8');
+    } catch (readError) {
+      Print.warning(`Cannot read ${componentFile}: ${readError.message}`);
+      skippedCount++;
       continue;
     }
 
-    const source = await fs.readFile(componentFile, 'utf8');
-    const props = extractStaticPropsFromSource(source);
-    componentPropsMap[componentName] = props || { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    const props = extractStaticPropsFromSource(source, componentFile);
+    if (props) {
+      componentPropsMap[componentName] = props;
+      processedCount++;
+    } else {
+      componentPropsMap[componentName] = { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    }
+  }
+
+  if (skippedCount > 0) {
+    Print.info(`Skipped ${skippedCount} component(s) with missing or unreadable files`);
   }
 
   return componentPropsMap;
 };
 
 const generateTypesFile = async ({ projectRoot, outputPath }) => {
-  const registryPath = path.join(projectRoot, 'src', 'Components', 'components.js');
-  const registryContent = await fs.readFile(registryPath, 'utf8');
-  const registryMap = parseComponentsRegistry(registryContent);
+  const registryPath = getComponentsJsPath(import.meta.url, projectRoot);
+  let registryContent;
+  try {
+    registryContent = await fs.readFile(registryPath, 'utf8');
+  } catch (readError) {
+    throw new Error(`Cannot read components registry at ${registryPath}: ${readError.message}`);
+  }
+  const registryMap = parseComponentsRegistry(registryContent, registryPath);
 
   const componentPropsMap = await loadComponentStaticProps({ projectRoot, registryMap });
 
@@ -412,12 +446,12 @@ const toPosixRelative = (projectRoot, targetPath) => {
 
 const ensureEditorConfigForTypes = async ({ projectRoot, outputPath }) => {
   try {
-    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    const tsconfigPath = joinRoot(projectRoot, 'tsconfig.json');
     if (await fs.pathExists(tsconfigPath)) {
       return { mode: 'tsconfig_exists', filePath: tsconfigPath, includeAdded: false };
     }
 
-    const jsconfigPath = path.join(projectRoot, 'jsconfig.json');
+    const jsconfigPath = joinRoot(projectRoot, 'jsconfig.json');
     const declarationGlob = (() => {
       const relative = toPosixRelative(projectRoot, outputPath);
       if (!relative) return 'src/**/*.d.ts';
@@ -541,5 +575,6 @@ export {
   extractStaticPropsFromSource,
   generateDeclarationContent,
   generateTypesFile,
+  parseComponentsRegistry,
   runGenerateTypes
 };

package/commands/utils/PathHelper.js

@@ -59,10 +59,17 @@ export function getDistPath(moduleUrl, ...segments) {
   return joinProject(moduleUrl, 'dist', ...segments)
 }
 
-export function getConfigPath(moduleUrl) {
+export function getConfigPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'sliceConfig.json')
   return joinProject(moduleUrl, 'src', 'sliceConfig.json')
 }
 
-export function getComponentsJsPath(moduleUrl) {
+export function getComponentsJsPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'Components', 'components.js')
   return joinProject(moduleUrl, 'src', 'Components', 'components.js')
 }
+
+export function joinRoot(root, ...segments) {
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}

package/commands/utils/VersionChecker.js

@@ -4,7 +4,7 @@ import fs from "fs-extra";
 import path from "path";
 import { fileURLToPath } from "url";
 import Print from "../Print.js";
-import { getProjectRoot } from "../utils/PathHelper.js";
+import { getProjectRoot, getPath } from "../utils/PathHelper.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -25,14 +25,14 @@ class VersionChecker {
 
       // Get Framework version from project node_modules
       const projectRoot = getProjectRoot(import.meta.url);
-      const frameworkPackagePath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'package.json');
+      const frameworkPackagePath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'package.json');
       if (await fs.pathExists(frameworkPackagePath)) {
         const frameworkPackage = await fs.readJson(frameworkPackagePath);
         this.currentFrameworkVersion = frameworkPackage.version;
       }
 
       // Get Project's CLI version
-      const projectPackagePath = path.join(__dirname, '../../../../package.json');
+      const projectPackagePath = getPath(import.meta.url, 'package.json');
       if (await fs.pathExists(projectPackagePath)) {
         const projectPackage = await fs.readJson(projectPackagePath);
         if (projectPackage.dependencies && projectPackage.dependencies['slicejs-cli']) {

package/commands/utils/bundling/DependencyAnalyzer.js

@@ -3,21 +3,13 @@ import fs from 'fs-extra';
 import path from 'path';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { getSrcPath, getComponentsJsPath, getProjectRoot, getConfigPath } from '../PathHelper.js';
+import { getSrcPath, getComponentsJsPath, getConfigPath, getPath } from '../PathHelper.js';
 
 export default class DependencyAnalyzer {
   constructor(moduleUrl) {
     this.moduleUrl = moduleUrl;
-    this.projectRoot = getProjectRoot(moduleUrl);
     this.componentsPath = path.dirname(getComponentsJsPath(moduleUrl));
-    this.frameworkComponentsPath = path.join(
-      this.projectRoot,
-      'node_modules',
-      'slicejs-web-framework',
-      'Slice',
-      'Components',
-      'Structural'
-    );
+    this.frameworkComponentsPath = getPath(moduleUrl, 'node_modules', 'slicejs-web-framework', 'Slice', 'Components', 'Structural');
     this.routesPath = getSrcPath(moduleUrl, 'routes.js');
 
     // Analysis storage
@@ -229,7 +221,7 @@ export default class DependencyAnalyzer {
     if (!await fs.pathExists(this.frameworkComponentsPath)) {
       return;
     }
-    const frameworkConfigPath = path.join(this.projectRoot, 'src', 'sliceConfig.json');
+    const frameworkConfigPath = getConfigPath(this.moduleUrl);
     let frameworkConfig = {};
     try {
       frameworkConfig = await fs.readJson(frameworkConfigPath);
@@ -723,7 +715,7 @@ export default class DependencyAnalyzer {
    */
   async analyzeRoutes() {
     if (!await fs.pathExists(this.routesPath)) {
-      throw new Error('routes.js no encontrado');
+      throw new Error(`routes.js not found at expected path: ${this.routesPath}. Ensure your routes.js file exists in the src directory.`);
     }
 
     const content = await fs.readFile(this.routesPath, 'utf-8');
@@ -735,11 +727,11 @@ export default class DependencyAnalyzer {
       });
 
       let currentRoute = null;
-      const self = this; // Guardar referencia a la instancia
+      const self = this; // Save reference to instance
 
       traverse.default(ast, {
         ObjectExpression(path) {
-          // Buscar objetos de ruta: { path: '/', component: 'HomePage' }
+          // Look for route objects: { path: '/', component: 'HomePage' }
           const properties = path.node.properties;
           const pathProp = properties.find(p => p.key?.name === 'path');
           const componentProp = properties.find(p => p.key?.name === 'component');
@@ -756,7 +748,7 @@ export default class DependencyAnalyzer {
 
             self.routes.set(routePath, currentRoute);
 
-            // Marcar el componente como usado por esta ruta
+            // Mark the component as used by this route
             if (self.components.has(componentName)) {
               self.components.get(componentName).routes.add(routePath);
             }
@@ -768,7 +760,7 @@ export default class DependencyAnalyzer {
       this.routeGroups = this.detectRouteGroups();
 
     } catch (error) {
-      console.warn(`⚠️  Error parseando rutas: ${error.message}`);
+      console.warn(`⚠️  Error parsing routes at ${this.routesPath}: ${error.message}`);
     }
   }
 

package/commands/utils/loadConfig.js

@@ -0,0 +1,31 @@
+import fs from 'fs-extra';
+import { getConfigPath } from './PathHelper.js';
+import Print from '../Print.js';
+
+export async function loadConfig(moduleUrl) {
+  try {
+    const configPath = getConfigPath(moduleUrl);
+    if (!await fs.pathExists(configPath)) {
+      return null;
+    }
+    const rawData = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(rawData);
+  } catch (error) {
+    Print.error(`Error loading configuration: ${error.message}`);
+    return null;
+  }
+}
+
+export function loadConfigSync(moduleUrl) {
+  try {
+    const configPath = getConfigPath(moduleUrl);
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const rawData = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(rawData);
+  } catch (error) {
+    Print.error(`Error loading configuration: ${error.message}`);
+    return null;
+  }
+}

package/commands/utils/updateManager.js

@@ -6,7 +6,7 @@ import inquirer from "inquirer";
 import ora from "ora";
 import Print from "../Print.js";
 import versionChecker from "./VersionChecker.js";
-import { getProjectRoot } from "../utils/PathHelper.js";
+import { getProjectRoot, getApiPath, getPath } from "../utils/PathHelper.js";
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs-extra";
@@ -401,9 +401,8 @@ export class UpdateManager {
 
     async updateApiIndexIfNeeded(options = {}) {
         try {
-            const projectRoot = getProjectRoot(import.meta.url);
-            const projectApiPath = path.join(projectRoot, 'api', 'index.js');
-            const frameworkApiPath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'api', 'index.js');
+            const projectApiPath = getApiPath(import.meta.url, 'index.js');
+            const frameworkApiPath = getPath(import.meta.url, 'node_modules', 'slicejs-web-framework', 'api', 'index.js');
 
             if (!await fs.pathExists(projectApiPath) || !await fs.pathExists(frameworkApiPath)) {
                 return;

package/docs/superpowers/specs/2026-05-10-pwa-generate-design.md

@@ -1,64 +1,64 @@
-# Diseno de `slice generate-pwa` (V1)
+# Design of `slice generate-pwa` (V1)
 
-## Objetivo
+## Objective
 
-Agregar un comando dedicado de CLI, `slice generate-pwa`, que convierta un build de Slice en una PWA usable offline, con estrategia de cache configurable y exclusion explicita de dominios de backend para evitar cache accidental de APIs REST.
+Add a dedicated CLI command, `slice generate-pwa`, that converts a Slice build into an offline-capable PWA, with configurable cache strategy and explicit backend domain exclusion to prevent accidental REST API caching.
 
-El comando debe ser postbundle, operar sobre `dist/` y mantener una experiencia simple de V1.
+The command must be post-bundle, operate on `dist/`, and maintain a simple V1 experience.
 
-## Alcance V1
+## V1 Scope
 
-- Nuevo comando `slice generate-pwa`.
-- Ejecutar `build` automaticamente antes del proceso PWA.
-- Generar `manifest.json` en `dist/`.
-- Generar `sw.js` en `dist/`.
-- Registrar Service Worker en el HTML de entrada de `dist`.
-- Soportar estrategias: `hybrid` (default), `offline-first`, `network-first`.
-- Persistir y leer configuracion desde `src/sliceConfig.json` en:
+- New `slice generate-pwa` command.
+- Automatically run `build` before the PWA process.
+- Generate `manifest.json` in `dist/`.
+- Generate `sw.js` in `dist/`.
+- Register Service Worker in the entry HTML of `dist`.
+- Support strategies: `hybrid` (default), `offline-first`, `network-first`.
+- Persist and read configuration from `src/sliceConfig.json` in:
   - `pwa.cache.excludeDomains`.
-- Aplicar exclusion efectiva de `localhost` y `127.0.0.1` en desarrollo.
+- Apply effective exclusion of `localhost` and `127.0.0.1` in development.
 
-## Fuera de alcance V1
+## Out of V1 Scope
 
-- Exclusion por paths o headers (`excludePaths`, `excludeHeaders`).
-- UI interactiva avanzada para crear iconos PWA.
-- Soporte de push notifications, background sync o runtime caching avanzado por tipo de API.
-- Plugin system formal; se deja preparado para evolucion futura.
+- Exclusion by paths or headers (`excludePaths`, `excludeHeaders`).
+- Advanced interactive UI for creating PWA icons.
+- Support for push notifications, background sync, or advanced runtime caching by API type.
+- Formal plugin system; left prepared for future evolution.
 
-## UX del comando
+## Command UX
 
-### Sintaxis
+### Syntax
 
 ```bash
 slice generate-pwa
 slice generate-pwa --strategy hybrid
 slice generate-pwa --strategy offline-first
 slice generate-pwa --strategy network-first
-slice generate-pwa --name "Mi App" --short-name "MiApp"
+slice generate-pwa --name "My App" --short-name "MyApp"
 ```
 
-### Flags V1
+### V1 Flags
 
 - `--strategy <hybrid|offline-first|network-first>` (default: `hybrid`)
 - `--name <string>`
 - `--short-name <string>`
 
-### Flujo de ejecucion
+### Execution flow
 
-1. Ejecuta build de produccion.
-2. Lee y normaliza configuracion PWA en `src/sliceConfig.json`.
-3. Genera manifiesto de assets para precache desde `dist/`.
-4. Genera `dist/manifest.json`.
-5. Genera `dist/sw.js` con la estrategia seleccionada.
-6. Inyecta (o asegura) registro SW en HTML de entrada de `dist`.
-7. Imprime resumen final:
-   - estrategia usada,
-   - cantidad de assets precacheados,
-   - dominios excluidos efectivos.
+1. Run production build.
+2. Read and normalize PWA configuration from `src/sliceConfig.json`.
+3. Generate asset manifest for precache from `dist/`.
+4. Generate `dist/manifest.json`.
+5. Generate `dist/sw.js` with the selected strategy.
+6. Inject (or ensure) SW registration in entry HTML of `dist`.
+7. Print final summary:
+   - strategy used,
+   - number of precached assets,
+   - effective excluded domains.
 
-## Configuracion en `sliceConfig.json`
+## Configuration in `sliceConfig.json`
 
-Seccion minima V1:
+V1 minimal section:
 
 ```json
 {
@@ -70,113 +70,113 @@ Seccion minima V1:
 }
 ```
 
-Reglas:
+Rules:
 
-- Si `pwa` no existe, el comando crea la seccion sin romper configuracion previa.
-- `excludeDomains` acepta hosts exactos (ej: `api.midominio.com`).
-- En ejecucion de desarrollo, se agregan de forma efectiva (no necesariamente persistida) `localhost` y `127.0.0.1`.
+- If `pwa` does not exist, the command creates the section without breaking existing configuration.
+- `excludeDomains` accepts exact hosts (e.g., `api.mydomain.com`).
+- In development execution, `localhost` and `127.0.0.1` are effectively added (not necessarily persisted).
 
-## Arquitectura propuesta
+## Proposed Architecture
 
-### Integracion CLI
+### CLI Integration
 
-- Agregar comando en `client.js`:
+- Add command in `client.js`:
   - `generate-pwa`
-  - opcion `--strategy`
-  - opciones de nombre para manifest
+  - `--strategy` option
+  - name options for manifest
 
-### Modulos nuevos
+### New Modules
 
 - `commands/pwa/generatePwa.js`
-  - Orquestador del flujo completo.
+  - Orchestrator of the complete flow.
 - `commands/pwa/ConfigResolver.js`
-  - Lee/crea/normaliza `pwa.cache.excludeDomains`.
+  - Reads/creates/normalizes `pwa.cache.excludeDomains`.
 - `commands/pwa/AssetManifestBuilder.js`
-  - Recorre `dist/` y arma lista precache.
+  - Iterates `dist/` and builds precache list.
 - `commands/pwa/ManifestGenerator.js`
-  - Genera `manifest.json` con defaults y overrides por flags.
+  - Generates `manifest.json` with defaults and flag overrides.
 - `commands/pwa/ServiceWorkerGenerator.js`
-  - Genera `sw.js` con estrategia seleccionada y exclusiones.
+  - Generates `sw.js` with selected strategy and exclusions.
 
-## Diseno de cache
+## Cache Design
 
-### Reglas globales
+### Global Rules
 
-- Interceptar solo requests `GET`.
-- Si el host esta en `excludeDomains`, hacer `fetch` directo (sin cache).
-- Versionado de cache por build id (timestamp o hash de build).
-- Al activar nuevo SW, limpiar caches viejas automaticamente.
+- Intercept only `GET` requests.
+- If the host is in `excludeDomains`, do a direct `fetch` (no cache).
+- Cache versioning by build id (timestamp or build hash).
+- On new SW activation, automatically clean old caches.
 
-### Estrategias
+### Strategies
 
 - `hybrid` (default):
-  - assets estaticos -> `cache-first`.
-  - navegacion HTML -> `network-first` con fallback offline.
+  - static assets -> `cache-first`.
+  - HTML navigation -> `network-first` with offline fallback.
 - `offline-first`:
-  - navegacion + estaticos -> `cache-first`.
-  - update en background cuando haya red.
+  - navigation + static -> `cache-first`.
+  - background update when online.
 - `network-first`:
-  - navegacion -> `network-first`.
-  - estaticos precacheados como respaldo.
+  - navigation -> `network-first`.
+  - precached static assets as fallback.
 
-## Manejo de API REST y seguridad
+## REST API and Security Handling
 
-Para evitar cache de backend no deseado:
+To prevent unwanted backend caching:
 
-- Exclusion por dominio con `excludeDomains` (regla principal de V1).
-- Limitar runtime cache a activos del frontend y navegacion segun estrategia.
-- No cachear metodos distintos de `GET`.
+- Domain exclusion via `excludeDomains` (main V1 rule).
+- Limit runtime cache to frontend assets and navigation per strategy.
+- Do not cache methods other than `GET`.
 
-Resultado: los assets del cliente se aceleran offline, pero el backend queda fuera de cache por configuracion explicita.
+Result: client assets are accelerated offline, but the backend stays out of the cache via explicit configuration.
 
 ## Error handling
 
-- Si build falla, abortar `generate-pwa` con mensaje claro.
-- Si `dist/` no existe tras build, abortar con diagnostico.
-- Si `sliceConfig.json` es invalido, mostrar error con sugerencia de reparacion.
-- Si no se puede inyectar registro SW en HTML, reportar warning y ruta objetivo.
+- If build fails, abort `generate-pwa` with a clear message.
+- If `dist/` does not exist after build, abort with diagnostics.
+- If `sliceConfig.json` is invalid, show error with repair suggestion.
+- If SW registration cannot be injected into HTML, report warning and target path.
 
 ## Testing
 
 ### Unit tests
 
 - `ConfigResolver`:
-  - crea seccion `pwa.cache.excludeDomains` cuando no existe,
-  - respeta config existente.
+  - creates `pwa.cache.excludeDomains` section when it does not exist,
+  - respects existing config.
 - `AssetManifestBuilder`:
-  - incluye assets esperados,
-  - excluye archivos no aptos.
+  - includes expected assets,
+  - excludes unsuitable files.
 - `ServiceWorkerGenerator`:
-  - genera logica correcta por estrategia,
-  - respeta `excludeDomains`.
+  - generates correct logic per strategy,
+  - respects `excludeDomains`.
 
-### Integracion
+### Integration
 
-- `slice generate-pwa` ejecuta build y crea `dist/manifest.json` + `dist/sw.js`.
-- registro SW presente en HTML de salida.
-- exclusiones de dominio aplicadas en codigo generado.
+- `slice generate-pwa` runs build and creates `dist/manifest.json` + `dist/sw.js`.
+- SW registration present in output HTML.
+- domain exclusions applied in generated code.
 
-### E2E manual minima
+### Minimal E2E manual
 
 - Build + generate-pwa.
-- Abrir app, validar installability (manifest).
-- Apagar red, validar navegacion offline en `hybrid`.
-- Verificar que requests a dominio excluido no se sirven desde cache SW.
-
-## Plan de evolucion (post V1)
-
-- `excludePaths` y `excludeHeaders`.
-- soporte de iconos y shortcuts PWA asistidos.
-- estrategia por ruta (ej: `/api/*` network-only).
-- extraer pipeline postbundle reusable para otras features.
-
-## Criterios de aceptacion
-
-- Existe comando `slice generate-pwa` funcional.
-- Ejecuta build antes de generar artefactos PWA.
-- Genera `manifest.json` y `sw.js` en `dist/`.
-- Registra SW en HTML principal de salida.
-- `hybrid` es default con HTML `network-first` y fallback offline.
-- Lee/escribe `pwa.cache.excludeDomains` en `src/sliceConfig.json`.
-- Excluye dominios configurados del cache runtime.
-- Muestra resumen final legible al usuario.
+- Open app, validate installability (manifest).
+- Turn off network, validate offline navigation in `hybrid`.
+- Verify that requests to excluded domain are not served from SW cache.
+
+## Evolution Plan (post V1)
+
+- `excludePaths` and `excludeHeaders`.
+- Assisted PWA icon and shortcut support.
+- Per-route strategy (e.g., `/api/*` network-only).
+- Extract reusable postbundle pipeline for other features.
+
+## Acceptance Criteria
+
+- Functional `slice generate-pwa` command exists.
+- Runs build before generating PWA artifacts.
+- Generates `manifest.json` and `sw.js` in `dist/`.
+- Registers SW in main output HTML.
+- `hybrid` is default with HTML `network-first` and offline fallback.
+- Reads/writes `pwa.cache.excludeDomains` in `src/sliceConfig.json`.
+- Excludes configured domains from runtime cache.
+- Shows a readable final summary to the user.