@tinya-code/gas-admin-ui 0.2.0-alpha.12 → 0.2.0-alpha.15

package/README.md

@@ -310,6 +310,228 @@ The shell starts at `/login` and, once authenticated, shows the sidebar menu and
 
 ---
 
+## Todos los tipos de campo del formulario
+
+Esta es la referencia completa de todos los tipos de campo que puedes declarar en `ResourceSchema.fields`. Cada tipo tiene su propio comportamiento de renderizado, validación y propiedades específicas.
+
+| Tipo | Descripción | Uso típico |
+|------|-------------|------------|
+| `text` | Input de una línea para texto corto | Nombres, slugs, URLs cortas |
+| `textarea` | Área de texto multilínea | Descripciones largas, notas |
+| `slug` | Slug generado automáticamente de otro campo | Identificadores amigables para SEO |
+| `number` | Campo numérico con controles de incremento | Cantidades, precios, edades |
+| `currency` | Campo monetario con formato de moneda | Precios, montos, saldos |
+| `boolean` | Interruptor (toggle) o casilla de verificación | Estados activos/inactivos |
+| `select` | Desplegable con radios para 2-4 opciones o dropdown para más | Estados, categorías pequeñas |
+| `dropdown` | Desplegable nativo (`<select>`) SIEMPRE, sin mutar a radios | Estados con muchas opciones |
+| `rich-select` | Selector visual con tarjetas y preview HTML personalizado | Opciones con iconos, colores, estados visuales |
+| `multiselect` | Selección múltiple de opciones | Tags, etiquetas múltiples |
+| `url` | Campo para URLs válidas | Enlaces externos, sitios web |
+| `email` | Campo de email con validación de formato | Correos electrónicos |
+| `phone` | Campo de teléfono con formato telefónico | Números de teléfono |
+| `date` | Selector de fecha (ISO `YYYY-MM-DD`) | Fechas de nacimiento, citas |
+| `time` | Selector de hora | Horas de apertura, citas |
+| `readonly-text` | Texto de solo lectura que no se envía al back | IDs generados, timestamps |
+| `relation` | Relación con otro recurso (fuente de datos) | Clientes, productos, usuarios relacionados |
+| `image` | Subida y vista previa de imágenes | Logos, fotos de perfil |
+| `file` | Subida de archivos genéricos (PDF, DOCX, etc.) | Documentos, adjuntos |
+| `group` | Grupo de campos con tarjeta, colapsable o inline | Secciones de formulario relacionadas |
+| `list` | Lista repetible de campos (items) | Múltiples direcciones, teléfonos |
+| `string-list` | Lista simple de strings | Tags simples, palabras clave |
+| `key-value` | Tabla de pares clave-valor | Metadatos, configuraciones personalizadas |
+| `color` | Selector de color nativo (`<input type="color">`) | Colores primarios, secundarios, temas |
+
+### Ejemplos por tipo
+
+A continuación verás cómo declarar cada tipo en tu schema, con sus propiedades específicas:
+
+#### `text` — Input de una línea
+
+```ts
+{ key: 'name', type: 'text', label: 'Nombre del Negocio', required: true, validators: { minLength: 2, maxLength: 120 }, section: 'general', width: 6 }
+```
+
+#### `textarea` — Área de texto multilínea
+
+```ts
+{ key: 'description', type: 'textarea', label: 'Descripción', validators: { maxLength: 500 }, section: 'general', width: 12 }
+```
+
+#### `slug` — Identificador amigable
+
+```ts
+{ key: 'slug', type: 'slug', from: 'name', label: 'Slug', required: true, lockAfterCreate: true, section: 'general', width: 6 }
+```
+
+#### `number` — Campo numérico
+
+```ts
+{ key: 'minVisits', type: 'number', label: 'Visitas Mínimas', required: true, min: 0, section: 'general', width: 6 }
+```
+
+#### `currency` — Campo monetario
+
+```ts
+{ key: 'price', type: 'currency', label: 'Precio', validators: { min: 0 }, section: 'pricing', width: 6 }
+```
+
+#### `boolean` — Interruptor / Casilla
+
+```ts
+{ key: 'active', type: 'boolean', label: 'Activo', section: 'general', width: 3 }
+```
+
+#### `select` — Desplegable (radios si 2-4 opciones, dropdown si más)
+
+```ts
+{ key: 'status', type: 'select', label: 'Estado', required: true, options: [
+  { value: 'active', label: 'Activo' },
+  { value: 'inactive', label: 'Inactivo' },
+  { value: 'pending', label: 'Pendiente' },
+], section: 'general', width: 6 }
+```
+
+#### `dropdown` — Desplegable nativo SIEMPRE
+
+```ts
+{ key: 'timezone', type: 'dropdown', label: 'Zona Horaria', required: true, section: 'general', width: 6, default: 'America/Lima', options: [
+  { value: 'America/Lima', label: 'Lima (Perú)' },
+  { value: 'America/Bogota', label: 'Bogotá (Colombia)' },
+  { value: 'America/Mexico_City', label: 'Ciudad de México' },
+], }
+```
+
+#### `rich-select` — Selector visual con tarjetas
+
+```ts
+{ key: 'cardStyle', type: 'rich-select', label: 'Estilo de Tarjeta', cardWidth: 3, section: 'branding', width: 12,
+  options: [
+    { value: 'none', label: 'Ninguno', preview: '<span class="w-8 h-8 bg-amber-300 rounded-sm flex items-center justify-center text-xs font-medium text-amber-900">Ninguna</span>' },
+    { value: 'monthly', label: 'Mensual', preview: '<span class="w-8 h-8 bg-blue-100 rounded-sm flex items-center justify-center text-xs font-medium text-blue-900">Mensual</span>' },
+    { value: 'yearly', label: 'Anual', preview: '<span class="w-8 h-8 bg-green-100 rounded-sm flex items-center justify-center text-xs font-medium text-green-900">Anual</span>' },
+  ], }
+```
+
+#### `multiselect` — Selección múltiple
+
+```ts
+{ key: 'tags', type: 'multiselect', label: 'Etiquetas', section: 'tags', width: 12, options: [
+  { value: 'vip', label: 'Cliente VIP' },
+  { value: 'new', label: 'Cliente Nuevo' },
+  { value: 'inactive', label: 'Inactivo' },
+], }
+```
+
+#### `url` — Campo de URL
+
+```ts
+{ key: 'website', type: 'url', label: 'Sitio Web', placeholder: 'https://ejemplo.com', section: 'contact', width: 12 }
+```
+
+#### `email` — Campo de correo electrónico
+
+```ts
+{ key: 'email', type: 'email', label: 'Correo Electrónico', required: true, section: 'contact', width: 12 }
+```
+
+#### `phone` — Campo de teléfono
+
+```ts
+{ key: 'phone', type: 'phone', label: 'Teléfono', section: 'contact', width: 6 }
+```
+
+#### `date` — Selector de fecha
+
+```ts
+{ key: 'birthDate', type: 'date', label: 'Fecha de Nacimiento', section: 'personal', width: 6 }
+```
+
+#### `time` — Selector de hora
+
+```ts
+{ key: 'openingTime', type: 'time', label: 'Hora de Apertura', section: 'hours', width: 6 }
+```
+
+#### `readonly-text` — Texto de solo lectura
+
+```ts
+{ key: 'memberId', type: 'readonly-text', label: 'ID Membresía', readonly: true, section: 'general', width: 6 }
+```
+
+#### `relation` — Relación con otro recurso
+
+```ts
+{ key: 'clientId', type: 'relation', label: 'Cliente', source: { resource: 'clients', labelField: 'name', valueField: 'membershipId' }, section: 'association', width: 12 }
+```
+
+#### `image` — Subida de imagen
+
+```ts
+{ key: 'logoUrl', type: 'image', label: 'Logo', section: 'branding', width: 12, accept: 'image/*', maxSizeMB: 2 }
+```
+
+#### `file` — Subida de archivo genérico
+
+```ts
+{ key: 'document', type: 'file', label: 'Documento', section: 'files', width: 12, accept: '.pdf,.doc,.docx', maxSizeMB: 5 }
+```
+
+#### `group` — Grupo de campos
+
+```ts
+{ key: 'address', type: 'group', label: 'Dirección', display: 'card', section: 'location', width: 12, fields: [
+  { key: 'street', type: 'text', label: 'Calle', width: 6 },
+  { key: 'city', type: 'text', label: 'Ciudad', width: 6 },
+]},
+```
+
+#### `list` — Lista repetible de items
+
+```ts
+{ key: 'phones', type: 'list', label: 'Teléfonos', itemFields: [
+  { key: 'number', type: 'phone', label: 'Número', width: 6 },
+  { key: 'type', type: 'select', label: 'Tipo', options: [{ value: 'mobile', label: 'Móvil' }, { value: 'home', label: 'Hogar' }], width: 6 },
+], section: 'contact', width: 12 }
+```
+
+#### `string-list` — Lista simple de strings
+
+```ts
+{ key: 'skills', type: 'string-list', label: 'Habilidades', itemType: 'text', section: 'skills', width: 12 }
+```
+
+#### `key-value` — Pares clave-valor
+
+```ts
+{ key: 'metadata', type: 'key-value', label: 'Metadatos', section: 'advanced', width: 12 }
+```
+
+#### `color` — Selector de color
+
+```ts
+{ key: 'colorPrimary', type: 'color', label: 'Color Primario', placeholder: '#4A2C11', section: 'branding', width: 6, default: '#4A2C11' }
+```
+
+### Propiedades comunes a todos los campos
+
+| Propiedad | Tipo | Descripción |
+|-----------|------|-------------|
+| `key` | `string` | Nombre de la propiedad en el JSON que envía/recibe el back. |
+| `label` | `string` | Rótulo visible para el usuario en el formulario y la ficha. |
+| `help` | `string` | Texto corto de ayuda que se muestra debajo del campo. |
+| `placeholder` | `string` | Texto sugerente que se muestra dentro del input cuando está vacío. |
+| `required` | `boolean` | Si es obligatorio. El back también lo valida (R7.4). |
+| `default` | `any` | Valor por defecto si el registro no trae este campo (ej. `default: 'none'` en un `select`/`dropdown`). |
+| `readonly` | `boolean` | Si el campo es solo lectura (no editable en el formulario). |
+| `width` | `1-12` | Ancho en la grilla del formulario (1–12), igual que un widget del dashboard. |
+| `section` | `string` | Id de la sección/pestaña del layout a la que pertenece (base.md §4). |
+| `description` | `string` | Descripción corta de para qué sirve este campo. Se muestra como tooltip al pasar el cursor sobre el rótulo. |
+| `docLink` | `string` | URL de documentación externa para este campo (se abre al hacer clic en el tooltip). |
+| `validators` | `object` | Reglas de validación (`minLength`, `maxLength`, `pattern`, `min`, `max`, `unique`). |
+| `access` | `object` | Nivel de acceso requerido (`read`, `write`) — solo UX, el back vuelve a verificar en cada petición. |
+
+---
+
 ## Schema examples (real implementations)
 
 The examples below are taken from a production consumer of this library.

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/gas-admin-ui",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinya-code/gas-admin-ui",
-  "version": "0.2.0-alpha.12",
+  "version": "0.2.0-alpha.15",
   "description": "Motor de render Angular para admin CRUD: declará ResourceSchema y el motor dibuja vistas, campos y widgets.",
   "repository": {
     "type": "git",
@@ -28,17 +28,5 @@
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "sideEffects": false,
-  "module": "fesm2022/tinya-code-gas-admin-ui.mjs",
-  "typings": "types/tinya-code-gas-admin-ui.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./types/tinya-code-gas-admin-ui.d.ts",
-      "default": "./fesm2022/tinya-code-gas-admin-ui.mjs"
-    }
-  },
-  "type": "module"
-}
+  "sideEffects": false
+}

package/src/lib/actions/action-registry.spec.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  actionType,
+  actionsFor,
+  getAction,
+  registerAction,
+  type ActionDescriptor,
+} from './action-registry';
+
+function descriptor(
+  type: string,
+  surfaces: ActionDescriptor['surfaces'] = ['row'],
+): ActionDescriptor {
+  return { type, surfaces, run: async () => ({ ok: true }) };
+}
+
+describe('action-registry', () => {
+  it('registra un descriptor y lo devuelve por su tipo', () => {
+    registerAction(descriptor('compartir'));
+    expect(getAction('compartir')?.type).toBe('compartir');
+  });
+
+  it('devuelve undefined para un tipo sin registrar', () => {
+    expect(getAction('sin-registrar')).toBeUndefined();
+  });
+
+  it('al re-registrar un tipo reemplaza el descriptor anterior', () => {
+    registerAction(descriptor('navegar', ['detail']));
+    registerAction(descriptor('navegar', ['row', 'detail']));
+    expect(getAction('navegar')?.surfaces).toEqual(['row', 'detail']);
+  });
+
+  it('lista sólo los descriptores cuya superficie coincide', () => {
+    registerAction(descriptor('cabecera', ['header']));
+    expect(actionsFor('header').map((d) => d.type)).toEqual(['cabecera']);
+    expect(actionsFor('bulk')).toEqual([]);
+  });
+});
+
+describe('actionType', () => {
+  it('usa el tipo declarado', () => {
+    expect(actionType({ id: 'x', label: 'X', type: 'trigger' })).toBe('trigger');
+    expect(actionType({ id: 'x', label: 'X', type: 'copy-share', urlTemplate: '/p/{ref}' })).toBe(
+      'copy-share',
+    );
+  });
+
+  it('una acción sin type es una navegación (NavigateAction.type es opcional)', () => {
+    expect(actionType({ id: 'x', label: 'X', urlTemplate: '/p/{ref}' })).toBe('navigate');
+  });
+});

package/src/lib/actions/action-registry.ts

@@ -0,0 +1,126 @@
+import type { Router } from '@angular/router';
+
+import type { LucideIcon } from '@lucide/angular';
+
+import {
+  actionDescriptors,
+  isShareAction,
+  isTriggerAction,
+  resolveShare,
+  type ResolvedShare,
+} from './descriptors';
+import type { ResourceAction } from '../core/models/schema.model';
+import type { SessionUser } from '../core/services/auth.service';
+import type { ApiService } from '../core/services/api.service';
+import type { NotificationService } from '../core/services/notification.service';
+
+/**
+ * Registro único de acciones (R3.9 · `refactormotor.md`).
+ *
+ * Es el gemelo del registro de render (`core/registry/render-registry.ts`):
+ * en lugar de «qué componente pinta un tipo de campo», responde «qué
+ * comportamiento ejecuta un tipo de acción» y permite **migrar el dispatch
+ * if/copiado-pegado de las vistas (R3.11) a datos + un solo `run`**.
+ *
+ * Como los descriptores son objetos planos de módulo (no los inyecta Angular),
+ * todo lo que necesiten llegar por el `ActionContext`: los puertos (`api`,
+ * `router`, `toast`) y los datos (`record`, `resource`, `vars`).
+ */
+
+/** Superficies donde una acción puede aparecer. */
+export type ActionSurface = 'row' | 'detail' | 'header' | 'bulk' | 'post-create';
+
+/**
+ * Lo que aporta el llamador al ejecutar una acción: el registro sobre el que
+ * corre y los puertos que el descriptor usará para actuar.
+ *
+ * `record` es `null` en las superficies sin fila (`header`, `bulk`), para que
+ * un descriptor pueda distinguir «sin registro» de «registro vacío».
+ */
+export interface ActionRequest {
+  record: Record<string, unknown> | null;
+  /** Id del recurso (schema) dueño de la acción. */
+  resource: string;
+  api: ApiService;
+  router: Router;
+  toast: NotificationService;
+  user: SessionUser | null;
+  /**
+   * `keyField` del schema. **R3.12 (desviación nº 3 del contrato):** con
+   * `record` forma la clave que necesita la ruta lógica de `trigger`
+   * (`/admin/<recurso>/<key>/actions/<name>`). Lo aporta la vista, que es
+   * quien tiene el schema.
+   */
+  keyField: string;
+}
+
+/**
+ * Contexto que recibe el descriptor: la petición del llamador más el contexto
+ * de interpolación ya resuelto. `ActionService.run` lo arma, así que ninguna
+ * vista repite `buildInterpolationContext(record)`.
+ */
+export interface ActionContext extends ActionRequest {
+  /** `{...configGlobal, ...record, public_base_url}` — listo para las plantillas. */
+  vars: Record<string, unknown>;
+}
+
+/** Resultado que la vista puede leer para saber si debe recargar. */
+export interface ActionResult {
+  /** `false` cuando la acción no llegó a ejecutarse; el error ya se notificó. */
+  ok: boolean;
+  /** `true` cuando tocó datos y la vista debe recargar su listado/detalle. */
+  reload?: boolean;
+}
+
+export interface ActionDescriptor {
+  /** Clave del dispatch: el `type` del schema (`'navigate'` no lo declara). */
+  type: string;
+  /** Superficies donde esta acción puede aparecer. */
+  surfaces: ActionSurface[];
+  run: (ctx: ActionContext, action: ResourceAction) => Promise<ActionResult>;
+  /** `true` si el descriptor exige confirmación antes de ejecutar. */
+  confirm?: boolean;
+  /**
+   * Icono lucide que representa la acción donde el espacio es reducido
+   * (la fila del listado). Sin él, la vista muestra `action.label`.
+   */
+  icon?: LucideIcon;
+}
+
+export { isShareAction, isTriggerAction, resolveShare, type ResolvedShare };
+
+const ACCIONES = new Map<string, ActionDescriptor>();
+
+/** Registra (o reemplaza) un descriptor de acción. */
+export function registerAction(descriptor: ActionDescriptor): void {
+  ACCIONES.set(descriptor.type, descriptor);
+}
+
+export function getAction(type: string): ActionDescriptor | undefined {
+  return ACCIONES.get(type);
+}
+
+/** Descriptores disponibles en una superficie. */
+export function actionsFor(surface: ActionSurface): ActionDescriptor[] {
+  return [...ACCIONES.values()].filter((descriptor) => descriptor.surfaces.includes(surface));
+}
+
+/**
+ * Clave de dispatch de una acción. `NavigateAction.type` es **opcional**
+ * (schema.model.ts), así que una acción sin `type` es una navegación.
+ */
+export function actionType(action: ResourceAction): string {
+  return action.type ?? 'navigate';
+}
+
+/** Tipos registrados. Sólo para comprobaciones y tests. */
+export function actionTypes(): string[] {
+  return [...ACCIONES.keys()];
+}
+
+// Catálogo a scope de módulo: se registra al importar, sin esperar a DI,
+// igual que el registro de render (mismo motivo: `buildFormSchema()` es una
+// función pura que consulta sin inyectar nada).
+for (const descriptor of actionDescriptors) {
+  registerAction(descriptor);
+}

package/src/lib/actions/action-service.spec.ts

@@ -0,0 +1,215 @@
+import { TestBed } from '@angular/core/testing';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ActionService } from './action-service';
+import { registerAction, type ActionContext, type ActionDescriptor } from './action-registry';
+import { actionDescriptors } from './descriptors';
+import type { ResourceAction } from '../core/models/schema.model';
+import type { ApiService } from '../core/services/api.service';
+import { ConfigService } from '../core/services/config.service';
+import type { NotificationService } from '../core/services/notification.service';
+import type { Router } from '@angular/router';
+
+/** Notificador falso: sólo el contrato que `ActionService` usa. */
+function fakeToast(): NotificationService & { confirm: ReturnType<typeof vi.fn> } {
+  return {
+    confirm: vi.fn().mockResolvedValue(true),
+    error: vi.fn(),
+    success: vi.fn(),
+    info: vi.fn(),
+    dismiss: vi.fn(),
+  } as unknown as NotificationService & { confirm: ReturnType<typeof vi.fn> };
+}
+
+function fakeRequest(toast: NotificationService) {
+  return {
+    record: { slug: 'tecla', ref: 'p1' },
+    resource: 'productos',
+    api: {} as ApiService,
+    router: { navigate: async () => true } as unknown as Router,
+    toast,
+    user: null,
+    keyField: 'ref',
+  };
+}
+
+const COMPARTIR: ResourceAction = {
+  id: 'compartir',
+  label: 'Compartir',
+  type: 'copy-share',
+  urlTemplate: 'https://demo/p/{ref}',
+};
+
+describe('ActionService', () => {
+  let service: ActionService;
+  let toast: ReturnType<typeof fakeToast>;
+  const ensureLoaded = vi.fn<() => Promise<void>>().mockResolvedValue(undefined);
+
+  beforeEach(() => {
+    toast = fakeToast();
+    ensureLoaded.mockClear();
+    ensureLoaded.mockResolvedValue(undefined);
+    TestBed.configureTestingModule({
+      providers: [
+        // ConfigService real pediría HttpClient/API_URL; sólo aporta `vars`
+        // y el reintento de config que `copy-share` dispara.
+        {
+          provide: ConfigService,
+          useValue: {
+            ensureLoaded,
+            buildInterpolationContext: (record: Record<string, unknown>) => ({
+              ...record,
+              public_base_url: 'https://demo',
+            }),
+          },
+        },
+      ],
+    });
+    service = TestBed.inject(ActionService);
+  });
+
+  // El `Map` del registro es estado de módulo **compartido entre ficheros**
+  // cuando vitest los ejecuta en el mismo worker: varios tests de éste
+  // sobrescriben `copy-share` / `navigate` / `trigger` con dobles.
+  // Sin restaurar aquí, `contract.spec` y `descriptors.spec` leen esos dobles
+  // y la suite se pone flaka **según el orden de ficheros** (falló 4 tests de
+  // `descriptors.spec` en una corrida y 0 en la siguiente, sin tocar código).
+  // Quien ensucia es quien limpia: el estado por defecto es el catálogo real.
+  afterEach(() => {
+    for (const descriptor of actionDescriptors) registerAction(descriptor);
+  });
+
+  it('ejecuta el descriptor y le entrega la petición + vars de interpolación', async () => {
+    const vistos: ActionContext[] = [];
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row', 'post-create'],
+      run: async (ctx) => {
+        vistos.push(ctx);
+        return { ok: true, reload: true };
+      },
+    });
+
+    const resultado = await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(resultado).toEqual({ ok: true, reload: true });
+    expect(vistos).toHaveLength(1);
+    expect(vistos[0].record).toEqual({ slug: 'tecla', ref: 'p1' });
+    expect(vistos[0].resource).toBe('productos');
+    expect(vistos[0].vars).toEqual({ slug: 'tecla', ref: 'p1', public_base_url: 'https://demo' });
+  });
+
+  it('copy-share reintenta la config global ANTES de resolver vars', async () => {
+    // Regresión del «mensaje = sólo la URL»: si el load del bootstrap falló,
+    // el descriptor debe ver la config ya recargada, no el snapshot vacío.
+    let ensureHecho = false;
+    ensureLoaded.mockImplementation(async () => {
+      ensureHecho = true;
+    });
+    const varsAlEjecutar: Record<string, unknown>[] = [];
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row'],
+      run: async (ctx) => {
+        expect(ensureHecho).toBe(true);
+        varsAlEjecutar.push(ctx.vars);
+        return { ok: true };
+      },
+    });
+
+    await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(ensureLoaded).toHaveBeenCalledOnce();
+    expect(varsAlEjecutar[0]).toEqual({
+      slug: 'tecla',
+      ref: 'p1',
+      public_base_url: 'https://demo',
+    });
+  });
+
+  it('acciones que no son copy-share no tocan la config', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>().mockResolvedValue({ ok: true });
+    registerAction({ type: 'navigate', surfaces: ['row'], run });
+
+    await service.run({ id: 'ver', label: 'Ver', urlTemplate: '/p/{ref}' }, fakeRequest(toast));
+
+    expect(ensureLoaded).not.toHaveBeenCalled();
+  });
+
+  it('una acción sin type resuelve el descriptor navigate', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>();
+    registerAction({ type: 'navigate', surfaces: ['row', 'detail'], run });
+
+    await service.run({ id: 'ver', label: 'Ver', urlTemplate: '/p/{ref}' }, fakeRequest(toast));
+
+    expect(run).toHaveBeenCalledOnce();
+  });
+
+  it('sin descriptor registrado rompe en lugar de ignorarse', async () => {
+    // `ResourceAction` es una unión cerrada y el registro es estado de
+    // módulo compartido entre tests: se fuerza un type que nadie registra
+    // (el cast a `unknown` sólo salva al compilador, no cambia el código).
+    const desconocida = { id: 'x', label: 'X', type: 'nadie' } as unknown as ResourceAction;
+    await expect(service.run(desconocida, fakeRequest(toast))).rejects.toThrow(
+      'no tiene descriptor registrado',
+    );
+  });
+
+  it('con confirmación rechazada no ejecuta y devuelve ok false', async () => {
+    toast.confirm.mockResolvedValue(false);
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>();
+    registerAction({
+      type: 'trigger',
+      surfaces: ['row'],
+      confirm: true,
+      run,
+    });
+
+    const resultado = await service.run(
+      {
+        id: 'publicar',
+        label: 'Publicar',
+        type: 'trigger',
+        confirmMessage: 'Se publicará para todos.',
+      },
+      fakeRequest(toast),
+    );
+
+    expect(toast.confirm).toHaveBeenCalledWith({
+      title: 'Publicar',
+      message: 'Se publicará para todos.',
+      confirmLabel: 'Confirmar',
+      cancelLabel: 'Cancelar',
+    });
+    expect(run).not.toHaveBeenCalled();
+    expect(resultado).toEqual({ ok: false });
+  });
+
+  it('con confirmación aceptada ejecuta el descriptor', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>().mockResolvedValue({ ok: true });
+    registerAction({ type: 'trigger', surfaces: ['row'], confirm: true, run });
+
+    const resultado = await service.run(
+      { id: 'duplicar', label: 'Duplicar', type: 'trigger' },
+      fakeRequest(toast),
+    );
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(resultado).toEqual({ ok: true });
+  });
+
+  it('un error del descriptor se notifica y no se devuelve como éxito', async () => {
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row'],
+      run: async () => {
+        throw new Error('El backend respondió 500');
+      },
+    });
+
+    const resultado = await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(toast.error).toHaveBeenCalledWith('El backend respondió 500');
+    expect(resultado).toEqual({ ok: false });
+  });
+});