@asteby/metacore-runtime-react 47.1.0 → 48.0.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()
+    })
+})

package/src/__tests__/primitives.test.ts

@@ -0,0 +1,224 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { allocatePayment, validateAllocation, type OpenDocument } from '../primitives/allocation'
+import { bucketFor, computeAging, daysOverdue } from '../primitives/aging'
+import {
+    __resetContributions,
+    contributionsVersion,
+    federatedModalComponent,
+    registerDocumentContribution,
+    registerFederatedModal,
+    resolveContributions,
+    resolveFederatedModal,
+    slotIdFor,
+    subscribeContributions,
+} from '../primitives/contributions'
+import { approvalsClient, groupApprovals, parseJSONField, registerApprovalCategory, type ApprovalRequestDTO } from '../primitives/approvals'
+import { CORE_DOCUMENT_KINDS, getDocumentKind, listDocumentKinds, registerDocumentKind } from '../primitives/document-kinds'
+import { blockingChecks } from '../primitives/panels'
+import { installedPredicate } from '../primitives/use-contributions'
+import { slotRegistry } from '../slot'
+import type { ApiClient } from '../api-context'
+
+// Datos del mockup complemento-pago.html (Transportes del Bajío).
+const docs: OpenDocument[] = [
+    { id: 'a1060', number: 'A-1060', issued_at: '2026-09-10', due_at: '2026-10-10', total: 42270.4, balance: 42270.4, currency: 'MXN', payment_method: 'PPD' },
+    { id: 'a1051', number: 'A-1051', issued_at: '2026-08-15', due_at: '2026-09-14', total: 18560, balance: 8500, currency: 'MXN', payment_method: 'PPD', installments_paid: 1 },
+    { id: 'a1066', number: 'A-1066', issued_at: '2026-09-28', due_at: '2026-10-28', total: 23260, balance: 23260, currency: 'MXN', payment_method: 'PPD' },
+]
+
+describe('allocatePayment', () => {
+    it('aplica primero lo más vencido y calcula parcialidad e insoluto', () => {
+        const r = allocatePayment(30000, docs)
+        expect(r.allocations).toEqual([
+            { document_id: 'a1051', amount: 8500, balance_before: 8500, balance_after: 0, installment: 2 },
+            { document_id: 'a1060', amount: 21500, balance_before: 42270.4, balance_after: 20770.4, installment: 1 },
+        ])
+        expect(r.unapplied).toBe(0)
+    })
+    it('manual respeta montos y deja sin aplicar el resto', () => {
+        const r = allocatePayment(10000, docs, 'manual', { a1066: 4000 })
+        expect(r.applied).toBe(4000)
+        expect(r.unapplied).toBe(6000)
+        expect(validateAllocation(10000, 'MXN', docs, r.allocations).map(i => i.code)).toEqual(['unapplied'])
+        expect(validateAllocation(10000, 'MXN', docs, r.allocations, { allowUnapplied: true })[0].severity).toBe('warning')
+    })
+    it('detecta pago mayor al saldo y moneda distinta', () => {
+        const codes = validateAllocation(9000, 'USD', docs, [{ document_id: 'a1051', amount: 9000, balance_before: 8500, balance_after: -500, installment: 2 }]).map(i => i.code)
+        expect(codes).toContain('over_balance')
+        expect(codes).toContain('currency_mismatch')
+    })
+})
+
+describe('computeAging', () => {
+    it('tramos y vencido por cliente al corte', () => {
+        expect(daysOverdue('2026-09-14', '2026-10-05')).toBe(21)
+        const { rows, totals, total } = computeAging(docs.map(d => ({ party_id: 'tba', due_at: d.due_at ?? null, issued_at: d.issued_at, balance: d.balance })), '2026-10-05')
+        expect(totals.current).toBe(65530.4)
+        expect(totals.d1_30).toBe(8500)
+        expect(total).toBe(74030.4)
+        expect(rows[0].oldest_overdue_days).toBe(21)
+    })
+})
+
+describe('contribuciones federadas', () => {
+    afterEach(() => __resetContributions())
+    const ctx = { kind: 'invoice', model: 'customers.Invoice', values: {}, mode: 'create' as const }
+    it('se ocultan si el addon no está instalado y se ordenan por prioridad', () => {
+        const Comp = () => null
+        registerDocumentContribution({ id: 'fiscal_mexico.header.cfdi', kinds: ['invoice', 'credit_note'], region: 'header.fields', requiresAddon: 'fiscal_mexico', priority: 10, component: Comp })
+        registerDocumentContribution({ id: 'inventory.header.warehouse', kinds: '*', region: 'header.fields', requiresAddon: 'inventory', component: Comp })
+        expect(resolveContributions(ctx, 'header.fields', a => a === 'inventory').map(c => c.id)).toEqual(['inventory.header.warehouse'])
+        expect(resolveContributions(ctx, 'header.fields', () => true).map(c => c.id)).toEqual(['fiscal_mexico.header.cfdi', 'inventory.header.warehouse'])
+    })
+    it('el disposer la quita (desinstalación en caliente)', () => {
+        const off = registerDocumentContribution({ id: 'x', kinds: '*', region: 'side.panels', component: () => null })
+        off()
+        expect(resolveContributions(ctx, 'side.panels', () => true)).toEqual([])
+    })
+    it('modal federado sin addon → null (el dispatcher usa el formulario genérico)', () => {
+        registerFederatedModal({ key: 'fiscal_mexico.import_cfdi', addon: 'fiscal_mexico', load: async () => ({ default: () => null }) })
+        expect(resolveFederatedModal('fiscal_mexico.import_cfdi', () => false)).toBeNull()
+        expect(resolveFederatedModal('fiscal_mexico.import_cfdi', () => true)?.addon).toBe('fiscal_mexico')
+    })
+})
+
+describe('groupApprovals', () => {
+    it('agrupa por categoría registrada por cada addon', () => {
+        const off = registerApprovalCategory({ key: 'cfdi', label: 'Cancelación CFDI', match: r => r.action_key === 'cancel_fiscal' })
+        const base = { kind: 'action', status: 'pending' } as ApprovalRequestDTO
+        const g = groupApprovals([{ ...base, id: '1', action_key: 'cancel_fiscal' }, { ...base, id: '2', action_key: 'approve_adjustment' }])
+        expect(Object.keys(g).sort()).toEqual(['cfdi', 'other'])
+        off()
+    })
+})
+
+describe('allocatePayment (estrategias y bordes)', () => {
+    it('oldest_issued_first ordena por emisión', () => {
+        const r = allocatePayment(50000, docs, 'oldest_issued_first')
+        expect(r.allocations.map(a => a.document_id)).toEqual(['a1051', 'a1060'])
+    })
+    it('monto negativo o cero no aplica nada y validateAllocation lo marca', () => {
+        expect(allocatePayment(-5, docs)).toEqual({ allocations: [], applied: 0, unapplied: 0 })
+        expect(validateAllocation(0, 'MXN', docs, []).map(i => i.code)).toContain('non_positive')
+    })
+    it('pago mayor a todos los saldos deja el excedente sin aplicar', () => {
+        const r = allocatePayment(100000, docs)
+        expect(r.applied).toBe(74030.4)
+        expect(r.unapplied).toBe(25969.6)
+    })
+})
+
+describe('bucketFor', () => {
+    it('ubica los bordes de cada tramo', () => {
+        expect(bucketFor(-3)).toBe('current')
+        expect(bucketFor(0)).toBe('current')
+        expect(bucketFor(30)).toBe('d1_30')
+        expect(bucketFor(31)).toBe('d31_60')
+        expect(bucketFor(400)).toBe('d90_plus')
+    })
+})
+
+describe('contribuciones federadas (registro)', () => {
+    afterEach(() => __resetContributions())
+    const ctx = { kind: 'invoice', model: 'customers.Invoice', values: { total: 10 }, mode: 'edit' as const }
+
+    it('publica en slotRegistry por kind/region y el disposer la retira', () => {
+        const off = registerDocumentContribution({ id: 'a.body.x', kinds: ['invoice', 'quote'], region: 'body.sections', component: () => null })
+        expect(slotRegistry.get(slotIdFor('invoice', 'body.sections'))).toHaveLength(1)
+        expect(slotRegistry.get(slotIdFor('quote', 'body.sections'))).toHaveLength(1)
+        off()
+        off() // idempotente
+        expect(slotRegistry.get(slotIdFor('invoice', 'body.sections'))).toHaveLength(0)
+    })
+
+    it('re-registrar el mismo id reemplaza; el disposer viejo no borra el nuevo', () => {
+        const offOld = registerDocumentContribution({ id: 'a.side.p', kinds: '*', region: 'side.panels', priority: 1, component: () => null })
+        registerDocumentContribution({ id: 'a.side.p', kinds: '*', region: 'side.panels', priority: 5, component: () => null })
+        expect(slotRegistry.get(slotIdFor('*', 'side.panels'))).toHaveLength(1)
+        offOld()
+        expect(resolveContributions(ctx, 'side.panels', () => true).map(c => c.priority)).toEqual([5])
+    })
+
+    it('filtra por `when` y por kind; con `load` siempre expone un componente', () => {
+        registerDocumentContribution({ id: 'a.h.only_edit', kinds: ['invoice'], region: 'header.fields', when: c => c.mode === 'edit', load: async () => ({ default: () => null }) })
+        registerDocumentContribution({ id: 'a.h.quote', kinds: ['quote'], region: 'header.fields', component: () => null })
+        const [only] = resolveContributions(ctx, 'header.fields', () => true)
+        expect(only.id).toBe('a.h.only_edit')
+        expect(typeof only.component).toBe('function')
+        expect(resolveContributions({ ...ctx, mode: 'create' }, 'header.fields', () => true)).toEqual([])
+    })
+
+    it('exige component o load', () => {
+        expect(() => registerDocumentContribution({ id: 'bad', kinds: '*', region: 'side.panels' })).toThrow(/component o load/)
+    })
+
+    it('notifica a los suscriptores en register/dispose', () => {
+        const spy = vi.fn()
+        const unsub = subscribeContributions(spy)
+        const v0 = contributionsVersion()
+        const off = registerDocumentContribution({ id: 'n', kinds: '*', region: 'side.panels', component: () => null })
+        off()
+        expect(spy).toHaveBeenCalledTimes(2)
+        expect(contributionsVersion()).toBe(v0 + 2)
+        unsub()
+    })
+
+    it('modal federado: no registrado → null; disposer lo retira; componente memoizado', () => {
+        expect(resolveFederatedModal('returns.settle_method', () => true)).toBeNull()
+        const m = { key: 'returns.settle_method', addon: 'returns', load: async () => ({ default: () => null }) }
+        const off = registerFederatedModal(m)
+        expect(resolveFederatedModal('returns.settle_method', () => true)).toBe(m)
+        expect(federatedModalComponent(m)).toBe(federatedModalComponent(m))
+        off()
+        expect(resolveFederatedModal('returns.settle_method', () => true)).toBeNull()
+    })
+
+    it('installedPredicate: sin provider = instalado; con provider consulta el set', () => {
+        expect(installedPredicate(null)('lo_que_sea')).toBe(true)
+        const p = installedPredicate({ addons: new Set(['customers']), capabilities: new Set() })
+        expect(p('customers')).toBe(true)
+        expect(p('fiscal_mexico')).toBe(false)
+    })
+})
+
+describe('tipos de documento', () => {
+    it('registerDocumentKind con disposer y filtrado por addon instalado', () => {
+        const offs = CORE_DOCUMENT_KINDS.map(registerDocumentKind)
+        expect(getDocumentKind('invoice')?.model).toBe('customers.Invoice')
+        expect(listDocumentKinds(a => a === 'purchases').map(k => k.key)).toEqual(['purchase_order', 'supplier_invoice', 'supplier_payment'])
+        offs.forEach(off => off())
+        expect(getDocumentKind('invoice')).toBeUndefined()
+    })
+})
+
+describe('paneles', () => {
+    it('blockingChecks: solo errores sin política de autorización', () => {
+        const checks = [
+            { key: 'a', severity: 'error' as const, message: 'Falta RFC' },
+            { key: 'b', severity: 'error' as const, message: 'Sin crédito', approval_policy: 'credit_override' },
+            { key: 'c', severity: 'warning' as const, message: 'Sin correo' },
+        ]
+        expect(blockingChecks(checks).map(c => c.key)).toEqual(['a'])
+    })
+})
+
+describe('approvalsClient', () => {
+    it('arma la consulta y lee lista y conteo', async () => {
+        const get = vi.fn(async (url: string) =>
+            url.startsWith('/approvals/count') ? { data: { data: { count: 3 } } } : { data: { data: [{ id: '1' }], meta: { total: 1 } } },
+        )
+        const post = vi.fn(async () => ({ data: {} }))
+        const c = approvalsClient({ get, post } as unknown as ApiClient)
+        expect(await c.list({ status: 'pending', for_me: true, model: undefined })).toEqual({ items: [{ id: '1' }], total: 1 })
+        expect(get).toHaveBeenCalledWith('/approvals?status=pending&for_me=true')
+        expect(await c.count()).toBe(3)
+        await c.reject('9', 'No procede')
+        expect(post).toHaveBeenCalledWith('/approvals/9/reject', { reason: 'No procede' })
+    })
+    it('parseJSONField tolera string, objeto y basura', () => {
+        expect(parseJSONField('{"a":1}')).toEqual({ a: 1 })
+        expect(parseJSONField({ a: 2 })).toEqual({ a: 2 })
+        expect(parseJSONField('no-json')).toBeNull()
+        expect(parseJSONField('')).toBeNull()
+    })
+})

package/src/__tests__/record-prefill-bar.test.tsx

@@ -0,0 +1,50 @@
+// @vitest-environment happy-dom
+//
+// RecordPrefillBar: pinta los ayudantes registrados para el modelo/modo, los
+// filtra por permiso y solo deja pasar al formulario las claves que declara.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { registerRecordPrefill, unregisterRecordPrefillsByOwner, type RecordPrefillProps } from '@asteby/metacore-sdk'
+import { RecordPrefillBar } from '../record-prefill-bar'
+import { PermissionsProvider } from '../permissions-context'
+
+afterEach(() => {
+    cleanup()
+    unregisterRecordPrefillsByOwner('fiscal_mexico')
+})
+
+function CsfButton({ applyValues }: RecordPrefillProps) {
+    return (
+        <button type="button" onClick={() => applyValues({ tax_id: 'XAXX010101000', organization_id: 'hack' })}>
+            Cargar constancia
+        </button>
+    )
+}
+
+describe('RecordPrefillBar', () => {
+    it('aplica solo claves permitidas y aparece cuando el remote registra tarde', () => {
+        const onApply = vi.fn()
+        render(
+            <RecordPrefillBar model="customers.Customer" mode="create" values={{}} allowedKeys={new Set(['tax_id'])} onApply={onApply} />,
+        )
+        expect(screen.queryByText('Cargar constancia')).toBeNull()
+        act(() => {
+            registerRecordPrefill({ id: 'fiscal_mexico.csf', models: ['Customer'], component: CsfButton }, 'fiscal_mexico')
+        })
+        fireEvent.click(screen.getByText('Cargar constancia'))
+        expect(onApply).toHaveBeenCalledWith({ tax_id: 'XAXX010101000' })
+    })
+
+    it('se oculta sin el permiso declarado', () => {
+        registerRecordPrefill(
+            { id: 'fiscal_mexico.csf', models: ['Customer'], component: CsfButton, permission: 'customers.csf' },
+            'fiscal_mexico',
+        )
+        render(
+            <PermissionsProvider permissions={[]} isAdmin={false}>
+                <RecordPrefillBar model="Customer" mode="create" values={{}} allowedKeys={new Set(['tax_id'])} onApply={() => {}} />
+            </PermissionsProvider>,
+        )
+        expect(screen.queryByText('Cargar constancia')).toBeNull()
+    })
+})

package/src/action-modal-dispatcher.tsx

@@ -15,7 +15,7 @@
 // The host injects its axios-like client via <ApiProvider>; we no longer
 // depend on a bundler alias to `@/lib/api`.
 import { emitRecordMutation } from './record-mutation-events'
-import { useState, useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react'
+import { Suspense, useState, useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
     Dialog,
@@ -88,6 +88,9 @@ import {
     subscribeActionComponents,
 } from '@asteby/metacore-sdk'
 import { requestFederatedAction } from './federated-action-loader'
+import { useInstalledAddons } from './installed-addons-context'
+import { federatedModalComponent, resolveFederatedModal } from './primitives/contributions'
+import { installedPredicate, useContributionsVersion } from './primitives/use-contributions'
 
 export type { ActionMetadata, ActionModalProps }
 
@@ -375,6 +378,15 @@ export function ActionModalDispatcher({
     const readComponent = () => getActionComponent(model, action.key)
     const CustomComponent = useSyncExternalStore(subscribeActionComponents, readComponent, readComponent)
 
+    // Modal federado declarativo (registerFederatedModal). Si el addon dueño
+    // del slug consta como NO instalado, el `modal` se ignora y se usa el
+    // formulario genérico de la acción de inmediato (sin esperar el timeout).
+    useContributionsVersion()
+    const installed = useInstalledAddons()
+    const slug = action.modal || ''
+    const federatedModal = slug ? resolveFederatedModal(slug, installedPredicate(installed)) : null
+    const modalAddonMissing = !!slug && !federatedModal && !!installed && !installed.addons.has(slug.split('.')[0])
+
     if (CustomComponent) {
         return (
             <CustomComponent
@@ -389,10 +401,28 @@ export function ActionModalDispatcher({
         )
     }
 
+    if (federatedModal) {
+        const FederatedComponent = federatedModalComponent<ActionModalProps>(federatedModal)
+        return (
+            <Suspense fallback={<LoadingActionDialog open={open} onOpenChange={onOpenChange} action={action} />}>
+                <FederatedComponent
+                    open={open}
+                    onOpenChange={onOpenChange}
+                    action={action}
+                    model={model}
+                    record={record}
+                    endpoint={endpoint}
+                    onSuccess={onSuccess}
+                />
+            </Suspense>
+        )
+    }
+
     // Declarative custom slot (`modal: "addon.action"`). Wait for the remote,
     // then a hard error — confirm/fields generics look "fine" and hide a
-    // missing remote.
-    if (action.modal) {
+    // missing remote. Exception: the slug's addon is known NOT installed — the
+    // remote will never come, so fall through to the generic form now.
+    if (action.modal && !modalAddonMissing) {
         return (
             <PendingCustomActionModal
                 open={open}
@@ -479,7 +509,6 @@ function PendingCustomActionModal({
     action: ActionMetadata
     model: string
 }) {
-    const { t } = useTranslation()
     const slug = action.modal || ''
     const [timedOut, setTimedOut] = useState(false)
 
@@ -522,6 +551,20 @@ function PendingCustomActionModal({
         return <MissingCustomActionModal open={open} onOpenChange={onOpenChange} action={action} model={model} />
     }
 
+    return <LoadingActionDialog open={open} onOpenChange={onOpenChange} action={action} />
+}
+
+/** Diálogo «Cargando…» mientras llega el componente federado de la acción. */
+function LoadingActionDialog({
+    open,
+    onOpenChange,
+    action,
+}: {
+    open: boolean
+    onOpenChange: (open: boolean) => void
+    action: ActionMetadata
+}) {
+    const { t } = useTranslation()
     return (
         <Dialog open={open} onOpenChange={onOpenChange}>
             <DialogContent>

package/src/business/catalog-product-search.ts

@@ -0,0 +1,87 @@
+// createCatalogProductSearch — buscador de productos POR DEFECTO para
+// DocumentLinesGrid cuando el host no inyecta uno (`searchProducts`).
+//
+// Problema que corrige: DynamicCRUDPage monta DocumentFormDialog SIN
+// `searchProducts`, así que el paso de renglones de «Crear factura» solo ofrecía
+// «Renglón libre» (descripción a mano, precio 0, IVA 0) y la factura se guardaba
+// en $0. Con esto, cualquier documento declarativo busca en el catálogo.
+//
+// Lee el listado canónico GET /data/<model>?search=&per_page= (el mismo que usa
+// DynamicTable). No usa /options: su envelope solo trae id/label, sin precio.
+import type { ProductQuery, ProductResult } from './product-search'
+
+interface ApiLike {
+    get: (url: string, cfg?: { params?: Record<string, unknown>; signal?: AbortSignal }) => Promise<{ data: any }>
+}
+
+export interface CatalogProductSearchOptions {
+    /** Modelo de catálogo. Default `products.Product`. */
+    model?: string
+    /** Endpoint de listado. Default `/data/<model>`. */
+    endpoint?: string
+    limit?: number
+    /** Tasa de impuesto cuando el producto no trae la suya (config fiscal de la org; p. ej. 0.16). */
+    defaultTaxRate?: number
+}
+
+const num = (v: unknown): number | undefined => {
+    const n = typeof v === 'string' && v.trim() !== '' ? Number(v) : typeof v === 'number' ? v : NaN
+    return Number.isFinite(n) ? n : undefined
+}
+
+const str = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() ? v.trim() : undefined)
+
+/** Tasa como fracción: acepta 0.16 o 16. */
+const rate = (v: unknown): number | undefined => {
+    const n = num(v)
+    if (n == null || n < 0) return undefined
+    return n > 1 ? n / 100 : n
+}
+
+const bag = (v: unknown): Record<string, unknown> => {
+    if (typeof v === 'string') {
+        try {
+            const parsed = JSON.parse(v)
+            return parsed && typeof parsed === 'object' ? parsed : {}
+        } catch {
+            return {}
+        }
+    }
+    return v && typeof v === 'object' ? (v as Record<string, unknown>) : {}
+}
+
+/** Proyección pura registro del catálogo → ProductResult (exportada para tests). */
+export function catalogRecordToProduct(rec: Record<string, any>, defaultTaxRate?: number): ProductResult {
+    // Campos de extensión de otros addons (p. ej. claves SAT de fiscal_mexico).
+    const extensions = Object.fromEntries(
+        Object.entries(bag(rec.fiscal_data)).filter(([, v]) => typeof v === 'string' && v !== ''),
+    ) as Record<string, string>
+    const pt = String(rec.product_type ?? '')
+    return {
+        id: String(rec.id ?? rec.value ?? ''),
+        name: String(rec.name ?? rec.label ?? ''),
+        sku: str(rec.sku),
+        barcode: str(rec.barcode),
+        kind: pt === 'service' ? 'service' : 'product',
+        price: num(rec.unit_price ?? rec.sale_price ?? rec.price),
+        cost: num(rec.cost_price ?? rec.cost),
+        tax_rate: rate(rec.tax_rate) ?? defaultTaxRate,
+        unit: str(rec.unit_of_measure) ?? str(rec.unit),
+        extensions: Object.keys(extensions).length ? extensions : undefined,
+    }
+}
+
+export function createCatalogProductSearch(api: ApiLike, opts: CatalogProductSearchOptions = {}) {
+    const model = opts.model ?? 'products.Product'
+    const url = opts.endpoint ?? `/data/${model}`
+    const limit = opts.limit ?? 20
+    return async (query: Exclude<ProductQuery, { kind: 'empty' }>, signal: AbortSignal): Promise<ProductResult[]> => {
+        const search = query.kind === 'barcode' ? query.barcode : query.raw.trim()
+        const res = await api.get(url, { params: { search, per_page: limit }, signal })
+        const rows: unknown = res?.data?.data
+        if (!Array.isArray(rows)) return []
+        return rows
+            .filter((r) => r && typeof r === 'object' && (r as Record<string, unknown>).is_active !== false)
+            .map((r) => catalogRecordToProduct(r as Record<string, any>, opts.defaultTaxRate))
+    }
+}

package/src/business/catalog.ts

@@ -51,6 +51,8 @@ export const BUSINESS_COMPONENTS: readonly BusinessComponentSpec[] = [
             'applyProductToLine',
             'addProductLine',
             'lineGridKeyCommand',
+            'createCatalogProductSearch',
+            'catalogRecordToProduct',
         ],
     },
     {