@asteby/metacore-runtime-react 47.0.0 → 48.0.0

package/src/__tests__/dynamic-form-select-edit.test.tsx

@@ -0,0 +1,155 @@
+// @vitest-environment happy-dom
+//
+// Editar un registro con un select que YA tiene valor y guardar sin tocarlo debe
+// conservar ese valor en el payload. Antes los `values` del DynamicForm se
+// sembraban en un efecto (primer render con '') y el Select de Radix emitía
+// `onValueChange('')`, que pisaba el valor real y viajaba en el PATCH (p.ej. un
+// renglón «Refacción» quedaba en «-»). Cubre también: `readonly` de columna en
+// `deriveRelationFormFields`, selects vacíos no tocados fuera del PATCH, y el
+// modal de renglón con cuerpo con scroll y footer fijo.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react'
+
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (k: string, o?: any) => o?.defaultValue ?? k, i18n: { language: 'es' } }),
+}))
+
+import { DynamicForm, guardEmptySelect } from '../dynamic-form'
+import { DynamicRelation } from '../dynamic-relation'
+import { deriveRelationFormFields } from '../dynamic-relation-helpers'
+import { ApiProvider, type ApiClient } from '../api-context'
+import type { ActionFieldDef } from '../types'
+
+afterEach(cleanup)
+
+const kindField: ActionFieldDef = {
+    key: 'kind',
+    label: 'Tipo',
+    type: 'select',
+    options: [
+        { value: 'service', label: 'Servicio' },
+        { value: 'part', label: 'Refacción' },
+    ],
+}
+
+describe('DynamicForm — edición con select', () => {
+    it('guardar sin tocar el select conserva su valor en el payload', async () => {
+        const onSubmit = vi.fn()
+        render(
+            <DynamicForm
+                fields={[{ key: 'description', label: 'Descripción', type: 'text' }, kindField]}
+                initialValues={{ id: 'r1', description: 'Balata', kind: 'part' }}
+                onSubmit={onSubmit}
+            />,
+        )
+        await act(async () => {
+            screen.getByText('Guardar').click()
+        })
+        expect(onSubmit).toHaveBeenCalledTimes(1)
+        expect(onSubmit.mock.calls[0][0]).toMatchObject({ description: 'Balata', kind: 'part' })
+    })
+
+    it('en edición no manda un select vacío que el usuario no tocó', async () => {
+        const onSubmit = vi.fn()
+        render(
+            <DynamicForm
+                fields={[{ key: 'description', label: 'Descripción', type: 'text' }, kindField]}
+                initialValues={{ id: 'r1', description: 'Balata' }}
+                onSubmit={onSubmit}
+            />,
+        )
+        await act(async () => {
+            screen.getByText('Guardar').click()
+        })
+        expect(onSubmit).toHaveBeenCalledTimes(1)
+        expect(onSubmit.mock.calls[0][0]).not.toHaveProperty('kind')
+    })
+})
+
+describe('guardEmptySelect', () => {
+    it("ignora '' cuando ya hay valor y '' no es opción", () => {
+        const onChange = vi.fn()
+        guardEmptySelect('part', onChange, ['service', 'part'])('')
+        expect(onChange).not.toHaveBeenCalled()
+    })
+    it("deja pasar '' si no había valor o si '' es opción válida, y cualquier otro valor", () => {
+        const onChange = vi.fn()
+        guardEmptySelect('', onChange, ['service', 'part'])('')
+        guardEmptySelect('part', onChange, ['', 'part'])('')
+        guardEmptySelect('part', onChange, ['service', 'part'])('service')
+        expect(onChange.mock.calls).toEqual([[''], [''], ['service']])
+    })
+})
+
+const META = {
+    name: 'work_order_item',
+    columns: [
+        { key: 'id', label: 'ID', type: 'text', sortable: true, filterable: false, hidden: true },
+        { key: 'work_order_id', label: 'OT', type: 'text', sortable: false, filterable: false },
+        { key: 'description', label: 'Descripción', type: 'text', sortable: true, filterable: true },
+        {
+            key: 'kind',
+            label: 'Tipo',
+            type: 'select',
+            sortable: true,
+            filterable: true,
+            options: [
+                { value: 'service', label: 'Servicio' },
+                { value: 'part', label: 'Refacción' },
+            ],
+        },
+        { key: 'line_total', label: 'Importe', type: 'number', sortable: false, filterable: false, readonly: true },
+    ],
+    actions: [],
+    hasActions: false,
+    enableCRUDActions: false,
+}
+
+const DATA = [{ id: 'woi_1', work_order_id: 'wo_1', description: 'Balata', kind: 'part', line_total: 450 }]
+
+function mockApi(): ApiClient {
+    return {
+        get: vi.fn((url: string) => {
+            if (url.startsWith('/metadata/table/')) {
+                return Promise.resolve({ data: { success: true, data: META } })
+            }
+            return Promise.resolve({ data: { success: true, data: DATA } })
+        }),
+        post: vi.fn(() => Promise.resolve({ data: { success: true, data: {} } })),
+        put: vi.fn(() => Promise.resolve({ data: { success: true, data: {} } })),
+        delete: vi.fn(() => Promise.resolve({ data: { success: true, data: {} } })),
+    }
+}
+
+describe('DynamicRelation — editar renglón con select', () => {
+    it('deriveRelationFormFields copia readonly de la columna', () => {
+        const fields = deriveRelationFormFields(META as any, 'work_order_id')
+        expect(fields.find((f) => f.key === 'line_total')?.readonly).toBe(true)
+        expect(fields.find((f) => f.key === 'kind')?.readonly).toBeUndefined()
+    })
+
+    it('el PATCH conserva el tipo y no manda columnas readonly; el modal hace scroll con footer fijo', async () => {
+        const api = mockApi()
+        render(
+            <ApiProvider client={api}>
+                <DynamicRelation kind="one_to_many" model="work_order_item" foreignKey="work_order_id" parentId="wo_1" />
+            </ApiProvider>,
+        )
+        await waitFor(() => expect(screen.getByText('Balata')).toBeTruthy())
+        await act(async () => {
+            screen.getByLabelText('Editar').click()
+        })
+        const dialog = await screen.findByRole('dialog')
+        expect(dialog.className).toContain('max-h-[90dvh]')
+        expect(dialog.querySelector('.overflow-y-auto')).toBeTruthy()
+
+        await act(async () => {
+            screen.getByText('Guardar').click()
+        })
+        await waitFor(() => expect(api.put).toHaveBeenCalledTimes(1))
+        const [url, payload] = (api.put as any).mock.calls[0]
+        expect(url).toContain('woi_1')
+        expect(payload).toMatchObject({ description: 'Balata', kind: 'part' })
+        expect(payload).not.toHaveProperty('line_total')
+    })
+})

package/src/__tests__/dynamic-kanban.test.tsx

@@ -293,11 +293,32 @@ describe('withGroupBy (one model, several boards)', () => {
             ...over,
         }) as any
 
-    it('is the same object when there is no override or it matches the served group_by', () => {
-        const m = boardMeta()
+    it('is the same object when the served group_by is already the stage column', () => {
+        const m = boardMeta({ group_by: 'stage' })
         expect(withGroupBy(m, undefined)).toBe(m)
-        expect(withGroupBy(m, 'assigned_mechanic_id')).toBe(m)
+        expect(withGroupBy(m, 'stage')).toBe(m)
         expect(withGroupBy(null, 'stage')).toBeNull()
+        const flat = boardMeta({ stages: undefined, transitions: undefined, smart_lanes: undefined })
+        expect(withGroupBy(flat, 'assigned_mechanic_id')).toBe(flat)
+        expect(withGroupBy(flat, undefined)).toBe(flat)
+    })
+    // Pitsline r3 (b): WorkOrder serves group_by=service_bay_id (the last kanban
+    // nav entry) with the stage lanes. Without ?group_by= the board grouped the
+    // stage lanes by the bay: every card in «Sin etapa», each lane count sent
+    // f_service_bay_id=diagnosis and a drop PUT service_bay_id='diagnosis' (422).
+    it('groups a board without ?group_by= by the stage column, not the served one', () => {
+        const out = withGroupBy(boardMeta(), undefined)!
+        expect(out.group_by).toBe('stage')
+        expect(out.stages).toHaveLength(1)
+        expect(out.transitions).toHaveLength(1)
+    })
+    it('drops the stage machine on the board of the served (non-stage) column', () => {
+        const out = withGroupBy(boardMeta(), 'assigned_mechanic_id')!
+        expect(out.group_by).toBe('assigned_mechanic_id')
+        expect(out.stages).toBeUndefined()
+        expect(out.transitions).toBeUndefined()
+        expect(out.smart_lanes).toBeUndefined()
+        expect(refLaneSource(out)).toEqual({ ref: 'users' })
     })
     it('ignores a column the model does not have', () => {
         const m = boardMeta()

package/src/__tests__/dynamic-record-extension-label.test.tsx

@@ -0,0 +1,88 @@
+// @vitest-environment happy-dom
+//
+// Retest Pitsline 05/10: the customer and product forms printed the fields that
+// fiscal_mexico adds by extension as `FISCAL_MEXICO.EXT.CUSTOMER.RFC_RECEPTOR`.
+// The server served the label as the raw catalog key and the dialog rendered it
+// verbatim (uppercased by CSS). The dialog now resolves such a key with the
+// client catalog, and humanizes it when the catalog does not have it either.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render, waitFor } from '@testing-library/react'
+import { I18nextProvider } from 'react-i18next'
+import i18next from 'i18next'
+
+import { DynamicRecordDialog } from '../dialogs/dynamic-record'
+import { ApiProvider } from '../api-context'
+import { localizeFieldLabel } from '../dynamic-columns-helpers'
+
+afterEach(cleanup)
+
+function makeI18n() {
+    const inst = i18next.createInstance()
+    void inst.init({
+        lng: 'es',
+        fallbackLng: 'es',
+        react: { useSuspense: false },
+        resources: {
+            es: {
+                translation: {
+                    fiscal_mexico: { ext: { customer: { rfc_receptor: 'RFC' } } },
+                },
+            },
+        },
+    })
+    return inst
+}
+
+const api = {
+    get: vi.fn(async () => ({ data: { data: {} } })),
+    post: async () => ({ data: { success: true } }),
+    put: async () => ({ data: { success: true } }),
+    delete: async () => ({ data: { success: true } }),
+} as never
+
+describe('DynamicRecordDialog — extension field labels', () => {
+    it('never prints a raw catalog key as the field label', async () => {
+        render(
+            <I18nextProvider i18n={makeI18n()}>
+                <ApiProvider client={api}>
+                    <DynamicRecordDialog
+                        open
+                        onOpenChange={() => {}}
+                        mode="create"
+                        model="customers"
+                        schema={{
+                            title: 'Nuevo cliente',
+                            fields: [
+                                { key: 'name', label: 'Nombre', type: 'text' },
+                                { key: 'fiscal_data.rfc_receptor', label: 'fiscal_mexico.ext.customer.rfc_receptor', type: 'text' },
+                                { key: 'fiscal_data.codigo_postal', label: 'fiscal_mexico.ext.customer.codigo_postal', type: 'text' },
+                            ],
+                        } as never}
+                    />
+                </ApiProvider>
+            </I18nextProvider>,
+        )
+
+        const label = (key: string) =>
+            document.querySelector(`[data-aby-field="${key}"] label`)?.textContent ?? ''
+        await waitFor(() => expect(label('fiscal_data.rfc_receptor')).toBe('RFC'))
+        expect(label('fiscal_data.codigo_postal')).toBe('Codigo Postal')
+        expect(label('name')).toBe('Nombre')
+        expect(document.body.textContent).not.toContain('fiscal_mexico.ext')
+    })
+})
+
+describe('localizeFieldLabel', () => {
+    it('leaves human labels alone, even single words or acronyms', () => {
+        const t = vi.fn((k: string) => `T:${k}`)
+        expect(localizeFieldLabel('Nombre', t)).toBe('Nombre')
+        expect(localizeFieldLabel('RFC', t)).toBe('RFC')
+        expect(localizeFieldLabel('Código postal', t)).toBe('Código postal')
+        expect(t).not.toHaveBeenCalled()
+    })
+
+    it('resolves catalog keys and humanizes the ones the catalog lacks', () => {
+        expect(localizeFieldLabel('a.b', (k: string, o?: { defaultValue?: string }) => (k === 'a.b' ? 'Hola' : o?.defaultValue ?? k))).toBe('Hola')
+        expect(localizeFieldLabel('fiscal_mexico.ext.product.mx_clave_unidad', (k: string) => k)).toBe('Mx Clave Unidad')
+    })
+})

package/src/__tests__/dynamic-table-infinite-scroll.test.tsx

@@ -149,6 +149,10 @@ describe('DynamicTable infinite scroll', () => {
         await waitFor(() => expect(screen.getByText('30 de 45')).toBeTruthy())
         observers.forEach((o) => o.fire(true))
         await waitFor(() => expect(screen.getByText('45 de 45')).toBeTruthy())
+        // The sentinel leaves the viewport once everything is loaded. While it
+        // stays intersecting the hook deliberately chains the next page after a
+        // reset (viewport-fill), which would mask the collapse asserted below.
+        observers.forEach((o) => o.fire(false))
 
         // Change the active filters via defaultFilters (part of buildFilterParams).
         rerender(

package/src/__tests__/installed-addons-context.test.tsx

@@ -0,0 +1,50 @@
+// @vitest-environment happy-dom
+//
+// InstalledAddonsProvider: sin provider = desconocido (undefined), con provider
+// responde por clave de addon y por capacidad.
+import { afterEach, describe, expect, it } from 'vitest'
+import { cleanup, render, screen } from '@testing-library/react'
+import {
+    InstalledAddonsProvider,
+    useAddonInstalled,
+    useCapabilityProvided,
+    useInstalledAddons,
+} from '../installed-addons-context'
+
+afterEach(() => cleanup())
+
+function Probe() {
+    const fiscal = useAddonInstalled('fiscal_mexico')
+    const issuer = useCapabilityProvided('fiscal.invoice_issuer')
+    const all = useInstalledAddons()
+    return (
+        <span data-testid="probe">
+            {String(fiscal)}|{String(issuer)}|{all ? [...all.addons].join(',') : 'null'}
+        </span>
+    )
+}
+
+describe('InstalledAddonsProvider', () => {
+    it('sin provider devuelve undefined/null (nunca asume ausente)', () => {
+        render(<Probe />)
+        expect(screen.getByTestId('probe').textContent).toBe('undefined|undefined|null')
+    })
+
+    it('responde por addon y por capacidad', () => {
+        render(
+            <InstalledAddonsProvider addons={['customers', 'fiscal_mexico']} capabilities={['fiscal.invoice_issuer']}>
+                <Probe />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.getByTestId('probe').textContent).toBe('true|true|customers,fiscal_mexico')
+    })
+
+    it('addon no instalado = false', () => {
+        render(
+            <InstalledAddonsProvider addons={['customers']}>
+                <Probe />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.getByTestId('probe').textContent).toBe('false|false|customers')
+    })
+})

package/src/__tests__/line-item-totals.test.ts

@@ -25,6 +25,34 @@ const journalField = (overrides: Partial<ActionFieldDef> = {}): ActionFieldDef =
 })
 
 describe('computeLineItemTotals', () => {
+    // Pitsline r3 (g): the work order lines carry qty + a `total` price column
+    // and no amount column. qty=2 × 750 footed 750; the saved order was 1500.
+    it('suma qty × precio cuando la columna total es el precio unitario', () => {
+        const field = {
+            key: 'lines',
+            type: 'array',
+            itemFields: [
+                { key: 'description', type: 'string' },
+                { key: 'qty', type: 'number' },
+                { key: 'price', type: 'number', total: true },
+            ],
+        } as any
+        const rows = [{ qty: '2', price: '750' }, { qty: 1, price: 99.9 }]
+        expect(computeLineItemTotals(field, rows)).toEqual({ price: 1599.9 })
+    })
+    it('con columna de importe, el precio unitario se suma tal cual', () => {
+        const field = {
+            key: 'lines',
+            type: 'array',
+            itemFields: [
+                { key: 'qty', type: 'number' },
+                { key: 'unit_price', type: 'number', total: true },
+                { key: 'subtotal', type: 'number', total: true },
+            ],
+        } as any
+        const rows = [{ qty: 2, unit_price: 10, subtotal: 20 }]
+        expect(computeLineItemTotals(field, rows)).toEqual({ unit_price: 10, subtotal: 20 })
+    })
     it('suma solo las columnas marcadas con total', () => {
         const rows = [
             { account_id: 'a', debit: '100', credit: '' },

package/src/__tests__/line-items-lock-rows.test.tsx

@@ -65,6 +65,7 @@ describe('DynamicLineItems — lock_rows', () => {
     it('control: sin lock_rows muestra "Agregar renglón" y un botón de borrar por fila', () => {
         render(<DynamicLineItems field={lineField()} value={rows} onChange={vi.fn()} />)
         expect(screen.getByText('Agregar renglón')).toBeTruthy()
-        expect(screen.getAllByLabelText('Eliminar renglón')).toHaveLength(2)
+        // Mobile cards + desktop table both render a delete control per row.
+        expect(screen.getAllByLabelText('Eliminar renglón')).toHaveLength(rows.length * 2)
     })
 })

package/src/__tests__/option-filter.test.tsx

@@ -0,0 +1,115 @@
+// @vitest-environment happy-dom
+//
+// `option_filter` / `optionFilter` on a relation picker hides options client-side
+// (PIT-059: cancelled invoices must not show up in the payments selector).
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, render, screen, waitFor, within } from '@testing-library/react'
+import { applyOptionFilter, getOptionFilter, optionPassesRule } from '../option-filter'
+import { projectOption } from '../use-options-resolver'
+import { DynamicSelectField } from '../dynamic-select-field'
+import { ApiProvider, type ApiClient } from '../api-context'
+import type { ActionFieldDef } from '../types'
+
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (k: string, o?: any) => o?.defaultValue ?? k, i18n: { language: 'es' } }),
+}))
+
+afterEach(cleanup)
+
+const invoices = [
+    { id: 'i1', label: 'FAC-1', status: 'timbrada', total: 100 },
+    { id: 'i2', label: 'FAC-2', status: 'Cancelada', total: 50 },
+    { id: 'i3', label: 'FAC-3', status: 'pendiente', total: 70 },
+    { id: 'i4', label: 'FAC-4' },
+].map(projectOption)
+
+describe('getOptionFilter', () => {
+    it('is empty when the field declares none (retrocompat)', () => {
+        expect(getOptionFilter({ key: 'x' })).toEqual([])
+        expect(getOptionFilter(undefined)).toEqual([])
+    })
+    it('reads camelCase and snake_case, one rule or a list', () => {
+        const rule = { field: 'status', not_in: ['cancelada'] }
+        expect(getOptionFilter({ optionFilter: rule })).toEqual([rule])
+        expect(getOptionFilter({ option_filter: [rule] })).toEqual([rule])
+    })
+    it('ignores malformed rules', () => {
+        expect(getOptionFilter({ option_filter: [{ nope: 1 }, null, { field: '' }] })).toEqual([])
+    })
+})
+
+describe('applyOptionFilter', () => {
+    it('returns the same array with no rules', () => {
+        expect(applyOptionFilter(invoices, [])).toBe(invoices)
+    })
+    it('not_in hides cancelled invoices (case-insensitive) and keeps options without the column', () => {
+        const out = applyOptionFilter(invoices, [{ field: 'status', not_in: ['cancelada'] }])
+        expect(out.map((o) => o.id)).toEqual(['i1', 'i3', 'i4'])
+    })
+    it('notEquals alias and equals / in need the column to exist', () => {
+        expect(applyOptionFilter(invoices, [{ field: 'status', notEquals: 'cancelada' }]).map((o) => o.id)).toEqual(['i1', 'i3', 'i4'])
+        expect(applyOptionFilter(invoices, [{ field: 'status', equals: 'timbrada' }]).map((o) => o.id)).toEqual(['i1'])
+        expect(applyOptionFilter(invoices, [{ field: 'status', in: ['timbrada', 'pendiente'] }]).map((o) => o.id)).toEqual(['i1', 'i3'])
+    })
+    it('combines rules with AND', () => {
+        const out = applyOptionFilter(invoices, [
+            { field: 'status', not_in: ['cancelada'] },
+            { field: 'status', not_equals: 'pendiente' },
+        ])
+        expect(out.map((o) => o.id)).toEqual(['i1', 'i4'])
+    })
+    it('never hides the current selection', () => {
+        const out = applyOptionFilter(invoices, [{ field: 'status', not_in: ['cancelada'] }], 'i2')
+        expect(out.map((o) => o.id)).toEqual(['i1', 'i2', 'i3', 'i4'])
+    })
+    it('tests standard keys too (label)', () => {
+        expect(optionPassesRule(invoices[0], { field: 'label', equals: 'fac-1' })).toBe(true)
+    })
+})
+
+describe('DynamicSelectField with option_filter', () => {
+    const field = (extra: Partial<ActionFieldDef> = {}): ActionFieldDef => ({
+        key: 'invoice_id',
+        label: 'Factura',
+        type: 'dynamic_select',
+        ref: 'invoices.Invoice',
+        ...extra,
+    })
+    const api = () => {
+        const get = vi.fn(async () => ({
+            data: {
+                success: true,
+                data: [
+                    { id: 'i1', label: 'FAC-1', status: 'timbrada' },
+                    { id: 'i2', label: 'FAC-2', status: 'cancelada' },
+                ],
+                meta: { type: 'dynamic', count: 2 },
+            },
+        }))
+        const post = vi.fn(async () => ({ data: { success: false } }))
+        return { get, post } as unknown as ApiClient
+    }
+    const open = async (f: ActionFieldDef) => {
+        render(
+            <ApiProvider client={api()}>
+                <DynamicSelectField field={f} value="" onChange={() => {}} />
+            </ApiProvider>,
+        )
+        await act(async () => {
+            screen.getByRole('combobox').click()
+        })
+    }
+
+    it('lists every option without a filter', async () => {
+        await open(field())
+        await waitFor(() => expect(screen.getByText('FAC-2')).toBeTruthy())
+        expect(screen.getByText('FAC-1')).toBeTruthy()
+    })
+
+    it('hides the cancelled invoice when the manifest declares option_filter', async () => {
+        await open(field({ option_filter: { field: 'status', not_in: ['cancelada'] } }))
+        await waitFor(() => expect(screen.getByText('FAC-1')).toBeTruthy())
+        expect(screen.queryByText('FAC-2')).toBeNull()
+        expect(within(document.body).queryAllByText('FAC-2')).toHaveLength(0)
+    })
+})

package/src/__tests__/primitives-federated.test.tsx

@@ -0,0 +1,156 @@
+// @vitest-environment happy-dom
+//
+// Primitivos federados en React: el dispatcher pinta un modal de
+// registerFederatedModal sin esperar al host, usa el formulario genérico de
+// inmediato si el addon del slug no está instalado, y useDocumentContributions
+// re-pinta al registrar/desmontar un remote.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, render, screen } from '@testing-library/react'
+
+const USE_TRANSLATION = {
+    t: (_k: string, opts?: { defaultValue?: string }) => opts?.defaultValue ?? _k,
+    i18n: { language: 'es' },
+}
+vi.mock('react-i18next', () => ({ useTranslation: () => USE_TRANSLATION }))
+vi.mock('@tanstack/react-router', () => ({ useNavigate: () => () => {} }))
+
+import { ActionModalDispatcher } from '../action-modal-dispatcher'
+import { setFederatedActionLoader } from '../federated-action-loader'
+import { ApiProvider, type ApiClient } from '../api-context'
+import { InstalledAddonsProvider } from '../installed-addons-context'
+import {
+    __resetContributions,
+    registerDocumentContribution,
+    registerFederatedModal,
+    type DocumentEditorContext,
+} from '../primitives/contributions'
+import { useDocumentContributions } from '../primitives/use-contributions'
+import type { ActionMetadata, ActionModalProps } from '@asteby/metacore-sdk'
+
+afterEach(() => {
+    cleanup()
+    vi.restoreAllMocks()
+    setFederatedActionLoader(null)
+    __resetContributions()
+})
+
+const noopApi = {
+    get: vi.fn().mockResolvedValue({ data: {} }),
+    post: vi.fn().mockResolvedValue({ data: { success: true } }),
+    delete: vi.fn().mockResolvedValue({ data: { success: true } }),
+} as unknown as ApiClient
+
+const importAction: ActionMetadata = {
+    key: 'import_cfdi',
+    label: 'Importar CFDI',
+    modal: 'fiscal_mexico.import_cfdi',
+    confirm: true,
+    confirmMessage: '¿Importar?',
+    executable: true,
+}
+
+function ImportModal({ action }: ActionModalProps) {
+    return <div data-testid="import-modal">{action.modal}</div>
+}
+
+function renderDispatcher(addons?: string[]) {
+    const tree = (
+        <ActionModalDispatcher
+            open
+            onOpenChange={() => {}}
+            action={importAction}
+            model="Invoice"
+            record={{ id: '1' } as any}
+            endpoint="/data/Invoice"
+            onSuccess={() => {}}
+        />
+    )
+    return render(
+        <ApiProvider client={noopApi}>
+            {addons ? <InstalledAddonsProvider addons={addons}>{tree}</InstalledAddonsProvider> : tree}
+        </ApiProvider>,
+    )
+}
+
+describe('ActionModalDispatcher + registerFederatedModal', () => {
+    it('pinta el modal registrado (lazy) sin pedir el remote al host', async () => {
+        const loader = vi.fn()
+        setFederatedActionLoader(loader)
+        registerFederatedModal({ key: 'fiscal_mexico.import_cfdi', addon: 'fiscal_mexico', load: async () => ({ default: ImportModal }) })
+        renderDispatcher(['fiscal_mexico'])
+        expect((await screen.findByTestId('import-modal')).textContent).toBe('fiscal_mexico.import_cfdi')
+        expect(loader).not.toHaveBeenCalled()
+        expect(screen.queryByText('¿Importar?')).toBeNull()
+    })
+
+    it('addon del slug no instalado → formulario genérico de inmediato, sin esperar ni pedir el remote', () => {
+        const loader = vi.fn()
+        setFederatedActionLoader(loader)
+        registerFederatedModal({ key: 'fiscal_mexico.import_cfdi', addon: 'fiscal_mexico', load: async () => ({ default: ImportModal }) })
+        renderDispatcher(['customers'])
+        expect(screen.getByText('¿Importar?')).toBeTruthy()
+        expect(screen.queryByTestId('federated-action-loading')).toBeNull()
+        expect(loader).not.toHaveBeenCalled()
+    })
+
+    it('addon instalado pero modal aún sin registrar → espera al remote (no cae al genérico)', async () => {
+        renderDispatcher(['fiscal_mexico'])
+        expect(screen.getByTestId('federated-action-loading')).toBeTruthy()
+        expect(screen.queryByText('¿Importar?')).toBeNull()
+        act(() => {
+            registerFederatedModal({ key: 'fiscal_mexico.import_cfdi', addon: 'fiscal_mexico', load: async () => ({ default: ImportModal }) })
+        })
+        expect(await screen.findByTestId('import-modal')).toBeTruthy()
+    })
+
+    it('sin InstalledAddonsProvider se conserva la espera de siempre', () => {
+        renderDispatcher()
+        expect(screen.getByTestId('federated-action-loading')).toBeTruthy()
+        expect(screen.queryByText('¿Importar?')).toBeNull()
+    })
+})
+
+describe('useDocumentContributions', () => {
+    const ctx: DocumentEditorContext = { kind: 'invoice', model: 'customers.Invoice', values: {}, mode: 'create' }
+
+    function Region() {
+        const items = useDocumentContributions(ctx, 'header.fields')
+        return (
+            <div data-testid="region">
+                {items.map(({ id, component: C }) => (
+                    <C key={id} ctx={ctx} setValue={() => {}} issues={{ report: () => {} }} />
+                ))}
+            </div>
+        )
+    }
+
+    it('re-pinta al registrar y al desmontar el remote; filtra por addon instalado', async () => {
+        render(
+            <InstalledAddonsProvider addons={['fiscal_mexico']}>
+                <Region />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.getByTestId('region').textContent).toBe('')
+        let off = () => {}
+        act(() => {
+            off = registerDocumentContribution({
+                id: 'fiscal_mexico.header.cfdi',
+                kinds: ['invoice'],
+                region: 'header.fields',
+                requiresAddon: 'fiscal_mexico',
+                load: async () => ({ default: () => <span>Uso del CFDI</span> }),
+            })
+            registerDocumentContribution({
+                id: 'inventory.header.warehouse',
+                kinds: '*',
+                region: 'header.fields',
+                requiresAddon: 'inventory',
+                component: () => <span>Almacén</span>,
+            })
+        })
+        expect(await screen.findByText('Uso del CFDI')).toBeTruthy()
+        expect(screen.queryByText('Almacén')).toBeNull()
+        act(() => off())
+        expect(screen.queryByText('Uso del CFDI')).toBeNull()
+    })
+})