@asteby/metacore-runtime-react 47.1.0 → 49.0.0

package/src/__tests__/secondary-actions.test.tsx

@@ -0,0 +1,261 @@
+// @vitest-environment happy-dom
+//
+// Acciones secundarias de un registro (P2 UX Pitsline): una sola primaria
+// destacada; compartir / imprimir / correo / chat van al «Más…» de la fila y al
+// pie del documento; lo que aporta un addon (registerRecordAction) sólo aparece
+// con su proveedor instalado y activo. Y la infraestructura de registro es una
+// sola: lo que un addon registra por AddonAPI (modal, slot) llega a los mismos
+// lectores que registerFederatedModal / <Slot>.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+
+const I18N_T = (_k: string, opts?: { defaultValue?: string }) => opts?.defaultValue ?? _k
+const USE_TRANSLATION = { t: I18N_T, i18n: { language: 'es' } }
+vi.mock('react-i18next', () => ({ useTranslation: () => USE_TRANSLATION }))
+
+import { Registry, registerRecordAction, type ActionMetadata } from '@asteby/metacore-sdk'
+import { InstalledAddonsProvider } from '../installed-addons-context'
+import {
+    classifyActionPriority,
+    isActionProviderActive,
+    resolveRecordActions,
+    splitActionsByPriority,
+} from '../record-actions'
+import { RowActionsMenu } from '../row-actions-menu'
+import { DocumentSecondaryBar } from '../document/secondary-bar'
+import { resolveActions } from '../document/evaluate'
+import type { DocumentSpec } from '../document/types'
+import { Slot } from '../slot'
+import { ActionModalDispatcher } from '../action-modal-dispatcher'
+
+const disposers: Array<() => void> = []
+afterEach(() => {
+    cleanup()
+    while (disposers.length) disposers.pop()!()
+})
+
+const ROW = { id: 'inv-1', folio: 'A-1' }
+const ACTIONS = [
+    { key: 'stamp', label: 'Timbrar', icon: 'Stamp', priority: 'primary' },
+    { key: 'cancel', label: 'Cancelar', icon: 'X' },
+    { key: 'send_cfdi_email', label: 'Enviar por correo', icon: 'Mail' },
+    { key: 'reprint_cfdi', label: 'Reimprimir', icon: 'Printer' },
+    { key: 'approve', label: 'Aprobar', icon: 'Check', priority: 'primary' },
+]
+
+function shareToChat() {
+    const run = vi.fn()
+    disposers.push(
+        registerRecordAction(
+            { id: 'team_chat.share', label: 'Enviar al chat', icon: 'MessageSquareShare', requires: { addon: 'link' }, run },
+            'host',
+        ),
+    )
+    return run
+}
+
+async function openMenu() {
+    const trigger = screen.getByText('Abrir menú').closest('button')!
+    await act(async () => {
+        fireEvent.pointerDown(trigger, { button: 0, ctrlKey: false, pointerType: 'mouse' })
+    })
+}
+
+describe('clasificación primaria / secundaria', () => {
+    it('convención por segmento de clave; `priority` explícito manda', () => {
+        expect(classifyActionPriority({ key: 'send_cfdi_email' })).toBe('secondary')
+        expect(classifyActionPriority({ key: 'download_acuse' })).toBe('secondary')
+        expect(classifyActionPriority({ key: 'send_whatsapp' })).toBe('secondary')
+        expect(classifyActionPriority({ key: 'send' })).toBeUndefined() // enviar cotización = flujo principal
+        expect(classifyActionPriority({ key: 'create_mailbox' })).toBeUndefined()
+        expect(classifyActionPriority({ key: 'delete' })).toBeUndefined()
+        expect(classifyActionPriority({ key: 'print_label', priority: 'primary' })).toBe('primary')
+    })
+
+    it('una sola primaria: la primera que la reclama; las demás quedan como principales', () => {
+        const { primary, main, secondary } = splitActionsByPriority(ACTIONS)
+        expect(primary?.key).toBe('stamp')
+        expect(main.map((a) => a.key)).toEqual(['cancel', 'approve'])
+        expect(secondary.map((a) => a.key)).toEqual(['send_cfdi_email', 'reprint_cfdi'])
+    })
+
+    it('acción por capacidad sin proveedor activo no se ofrece', () => {
+        const a = { key: 'send_whatsapp', trigger: { type: 'capability', capability: 'messaging.whatsapp.send' } }
+        expect(isActionProviderActive(a, null)).toBe(true)
+        expect(isActionProviderActive(a, { addons: new Set(), capabilities: new Set() })).toBe(false)
+        expect(isActionProviderActive(a, { addons: new Set(['link']), capabilities: new Set(['messaging.whatsapp.send']) })).toBe(true)
+    })
+})
+
+describe('resolveRecordActions (registro de acciones aportadas)', () => {
+    const installed = (addons: string[], caps: string[] = []) => ({ addons: new Set(addons), capabilities: new Set(caps) })
+    const row = (c: Parameters<typeof registerRecordAction>[0], owner?: string) => ({ contribution: c, owner })
+
+    it('por addon, por capacidad o por dueño; modelos y expand', () => {
+        const rows = [
+            row({ id: 'a.chat', label: 'Chat', requires: { addon: 'link' }, run: () => {} }, 'host'),
+            row({ id: 'b.wa', label: 'WhatsApp', requires: { capability: 'messaging.whatsapp.send' }, run: () => {} }, 'host'),
+            row({ id: 'c.own', label: 'Propia', run: () => {} }, 'fiscal_mexico'),
+            row({ id: 'd.only', label: 'Sólo facturas', models: ['Invoice'], run: () => {} }),
+            row({ id: 'e.pdf', expand: () => [{ key: 'ticket', label: 'Ticket', run: () => {} }] }),
+        ]
+        const keys = (inst: ReturnType<typeof installed> | null, model = 'Sale') =>
+            resolveRecordActions(rows, { model, record: ROW }, inst).map((r) => r.key)
+        expect(keys(installed([]))).toEqual(['e.pdf:ticket'])
+        expect(keys(installed(['link', 'fiscal_mexico'], ['messaging.whatsapp.send']))).toEqual(['a.chat', 'b.wa', 'c.own', 'e.pdf:ticket'])
+        expect(keys(installed([]), 'customers.Invoice')).toEqual(['d.only', 'e.pdf:ticket'])
+        // Sin InstalledAddonsProvider = desconocido: se muestra (el servidor revalida).
+        expect(keys(null)).toEqual(['a.chat', 'b.wa', 'c.own', 'e.pdf:ticket'])
+    })
+})
+
+describe('RowActionsMenu', () => {
+    it('«Enviar al chat» aparece sólo con el addon proveedor instalado y activo', async () => {
+        shareToChat()
+        const { unmount } = render(
+            <InstalledAddonsProvider addons={['fiscal_mexico']}>
+                <RowActionsMenu actions={[]} row={ROW} model="Invoice" />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.queryByText('Abrir menú')).toBeNull() // nada que ofrecer
+        unmount()
+
+        render(
+            <InstalledAddonsProvider addons={['fiscal_mexico', 'link']}>
+                <RowActionsMenu actions={[]} row={ROW} model="Invoice" />
+            </InstalledAddonsProvider>,
+        )
+        await openMenu()
+        expect(screen.getByText('Enviar al chat')).toBeTruthy()
+    })
+
+    it('primaria única destacada; las secundarias van bajo «Más…», no en el primer nivel', async () => {
+        const run = shareToChat()
+        render(
+            <InstalledAddonsProvider addons={['link']}>
+                <RowActionsMenu actions={ACTIONS} row={ROW} model="Invoice" />
+            </InstalledAddonsProvider>,
+        )
+        await openMenu()
+        const top = [...document.querySelectorAll('[role="menu"] > [role="menuitem"]')].map(
+            (el) => el.getAttribute('data-action') ?? el.textContent,
+        )
+        expect(top).toEqual(['stamp', 'cancel', 'approve', 'Más…'])
+        expect(document.querySelectorAll('[data-action].font-semibold')).toHaveLength(1)
+        expect(document.querySelector('[data-action="stamp"]')?.className).toContain('font-semibold')
+        expect(screen.queryByText('Enviar por correo')).toBeNull()
+        expect(screen.queryByText('Enviar al chat')).toBeNull()
+
+        const more = screen.getByText('Más…')
+        await act(async () => {
+            fireEvent.keyDown(more, { key: 'ArrowRight' })
+        })
+        expect(screen.getByText('Enviar por correo')).toBeTruthy()
+        await act(async () => {
+            fireEvent.click(screen.getByText('Enviar al chat'))
+        })
+        expect(run).toHaveBeenCalledWith({ model: 'Invoice', record: ROW })
+    })
+})
+
+describe('documento: secundarias en el pie', () => {
+    const spec: DocumentSpec = {
+        model: 'invoices',
+        title: '{{folio}}',
+        statuses: [],
+        actions: [
+            { key: 'register_payment', label: 'Registrar pago' },
+            { key: 'send', label: 'Enviar por correo', modelAction: 'send_cfdi_email' },
+            { key: 'download_pdf', label: 'Descargar PDF', openUrl: '{{pdf}}' },
+            { key: 'credit_note', label: 'Nota de crédito' },
+            { key: 'share_link', label: 'Enlace', priority: 'secondary' },
+        ],
+        layouts: [],
+        defaultLayout: {
+            primary: 'register_payment',
+            secondary: ['send', 'download_pdf', 'credit_note'],
+            more: ['share_link'],
+        },
+        tabs: [],
+    }
+
+    it('resolveActions saca compartir/correo/PDF de la cabecera al pie', () => {
+        const layout = resolveActions(spec, { record: ROW, sources: {}, derived: {} })
+        expect(layout.primary?.def.key).toBe('register_payment')
+        expect(layout.secondary.map((a) => a.def.key)).toEqual(['credit_note'])
+        expect(layout.more).toEqual([])
+        expect(layout.footer.map((a) => a.def.key)).toEqual(['send', 'download_pdf', 'share_link'])
+    })
+
+    it('la primaria de un layout nunca se va al pie aunque sea una descarga', () => {
+        const layout = resolveActions(
+            { ...spec, defaultLayout: { primary: 'download_pdf', secondary: ['send'] } },
+            { record: ROW, sources: {}, derived: {} },
+        )
+        expect(layout.primary?.def.key).toBe('download_pdf')
+        expect(layout.footer.map((a) => a.def.key)).toEqual(['send'])
+    })
+
+    it('DocumentSecondaryBar junta las del documento y las aportadas, filtradas por proveedor', () => {
+        shareToChat()
+        const items = [{ key: 'download_pdf', label: 'Descargar PDF', icon: 'FileDown', run: () => {} }]
+        const { rerender } = render(
+            <InstalledAddonsProvider addons={[]}>
+                <DocumentSecondaryBar items={items} model="Invoice" record={ROW} />
+            </InstalledAddonsProvider>,
+        )
+        const bar = () => document.querySelector('[data-document-secondary]')!
+        expect([...bar().querySelectorAll('[data-action]')].map((b) => b.getAttribute('data-action'))).toEqual(['download_pdf'])
+
+        rerender(
+            <InstalledAddonsProvider addons={['link']}>
+                <DocumentSecondaryBar items={items} model="Invoice" record={ROW} />
+            </InstalledAddonsProvider>,
+        )
+        expect([...bar().querySelectorAll('[data-action]')].map((b) => b.getAttribute('data-action'))).toEqual([
+            'download_pdf',
+            'team_chat.share',
+        ])
+    })
+
+    it('sin nada secundario no pinta el pie', () => {
+        render(<DocumentSecondaryBar items={[]} model="Invoice" record={ROW} />)
+        expect(document.querySelector('[data-document-secondary]')).toBeNull()
+    })
+})
+
+describe('registro único: AddonAPI → lectores de runtime-react', () => {
+    it('api.registry.registerSlot se pinta en <Slot> y se oculta si su addon no está instalado', () => {
+        const reg = new Registry()
+        const Widget = () => <span>widget de returns</span>
+        reg.scope('returns').registerSlot({ name: 'invoice.footer', component: Widget })
+        disposers.push(() => void reg.unbind('returns'))
+        const { rerender } = render(
+            <InstalledAddonsProvider addons={['returns']}>
+                <Slot name="invoice.footer" />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.getByText('widget de returns')).toBeTruthy()
+        rerender(
+            <InstalledAddonsProvider addons={[]}>
+                <Slot name="invoice.footer" />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.queryByText('widget de returns')).toBeNull()
+    })
+
+    it('api.registry.registerModal resuelve `action.modal` por slug en el dispatcher', () => {
+        const reg = new Registry()
+        const Modal = (p: { recordId: string; close: () => void }) => <div>modal {p.recordId}</div>
+        reg.scope('fiscal_mexico').registerModal({ slug: 'fiscal_mexico.import_cfdi', component: Modal as never })
+        disposers.push(() => void reg.unbind('fiscal_mexico'))
+        const action: ActionMetadata = { key: 'import_cfdi', label: 'Importar', icon: 'Upload', modal: 'fiscal_mexico.import_cfdi' }
+        render(
+            <InstalledAddonsProvider addons={['fiscal_mexico']}>
+                <ActionModalDispatcher open onOpenChange={() => {}} action={action} model="SupplierInvoice" record={{ id: 9 }} onSuccess={() => {}} />
+            </InstalledAddonsProvider>,
+        )
+        expect(screen.getByText('modal 9')).toBeTruthy()
+        expect(screen.queryByTestId('federated-action-loading')).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,
@@ -84,10 +84,15 @@ import type { ActionFieldDef, TableMetadata, ColumnDefinition } from './types'
 import {
     type ActionMetadata,
     type ActionModalProps,
+    type BridgedActionProps,
+    adaptActionProps,
     getActionComponent,
     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 }
 
@@ -335,8 +340,45 @@ function defaultFromRecordSpec(field: ActionFieldDef): string | string[] | undef
     return f.defaultFromRecord ?? f.default_from_record
 }
 
-/** Scalar seed for one action field from the row being acted on. */
-export function scalarDefaultFromRecord(field: ActionFieldDef, record: any): unknown {
+/** `customers.Invoice`, `Invoice`, `invoices`, `sales_orders` → forma comparable. */
+function modelToken(m: string): string {
+    const last = m.split('.').pop() ?? m
+    return last.replace(/[^a-z0-9]/gi, '').toLowerCase()
+}
+
+/**
+ * ¿`ref` (FK de un campo) apunta al modelo `model` de la fila? Tolera prefijo de
+ * addon, PascalCase vs tabla y el plural de la tabla (`Invoice` ↔ `invoices`,
+ * `CustomerAddress` ↔ `customer_addresses`).
+ */
+export function refTargetsModel(ref: string | undefined | null, model: string | undefined | null): boolean {
+    if (!ref || !model) return false
+    const a = modelToken(ref)
+    const b = modelToken(model)
+    if (!a || !b) return false
+    return a === b || a + 's' === b || a + 'es' === b || b + 's' === a || b + 'es' === a
+}
+
+function fieldRef(field: ActionFieldDef): string | undefined {
+    if (field.ref) return field.ref
+    const opts = (field as { options?: unknown }).options
+    if (opts && !Array.isArray(opts) && typeof opts === 'object') {
+        const src = (opts as { source?: unknown }).source
+        if (typeof src === 'string' && src) return src
+    }
+    return undefined
+}
+
+/**
+ * Scalar seed for one action field from the row being acted on.
+ *
+ * Sin `default_from_record` declarado, un campo se siembra con la columna
+ * homónima de la fila; y un selector que apunta al MISMO modelo de la fila y
+ * que la fila no tiene como columna (`invoice_id` → Invoice en «Registrar pago»
+ * de una factura) se siembra con el id de esa fila: la acción se abrió desde
+ * ella (retest Pitsline 2026-10-05).
+ */
+export function scalarDefaultFromRecord(field: ActionFieldDef, record: any, model?: string): unknown {
     if (!record) return undefined
     const spec = defaultFromRecordSpec(field)
     if (typeof spec === 'string') {
@@ -350,6 +392,12 @@ export function scalarDefaultFromRecord(field: ActionFieldDef, record: any): unk
     } else if (field.key) {
         const v = readRecordPath(record, field.key)
         if (v !== undefined && v !== null && v !== '') return v
+        // Sólo si la fila NO tiene esa columna: un `parent_id` vacío de una
+        // categoría es «sin padre», no «yo mismo».
+        const id = unwrapRecordScalar(record.id)
+        if (!(field.key in record) && id !== undefined && id !== null && id !== '' && refTargetsModel(fieldRef(field), model)) {
+            return id
+        }
     }
     return undefined
 }
@@ -375,6 +423,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 +446,25 @@ export function ActionModalDispatcher({
         )
     }
 
+    if (federatedModal) {
+        // Modal por slug del store canónico: lo registró `api.registry.registerModal`
+        // (contrato recordId/payload/close) o registerFederatedModal
+        // (ActionModalProps). Recibe ambos contratos.
+        const FederatedComponent = federatedModalComponent<BridgedActionProps>(federatedModal)
+        return (
+            <Suspense fallback={<LoadingActionDialog open={open} onOpenChange={onOpenChange} action={action} />}>
+                <FederatedComponent
+                    {...adaptActionProps({ open, onOpenChange, action, model, record, endpoint, 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 +551,6 @@ function PendingCustomActionModal({
     action: ActionMetadata
     model: string
 }) {
-    const { t } = useTranslation()
     const slug = action.modal || ''
     const [timedOut, setTimedOut] = useState(false)
 
@@ -522,6 +593,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>
@@ -973,11 +1058,11 @@ function GenericActionModal({ open, onOpenChange, action, model, record, endpoin
 
     useEffect(() => {
         if (open && action.fields) {
-            setFormData(buildFieldDefaults(action.fields, record))
+            setFormData(buildFieldDefaults(action.fields, record, model))
             setFieldErrors({})
             setFormError(undefined)
         }
-    }, [open, action.fields, record])
+    }, [open, action.fields, record, model])
 
     // Lines the list row does not carry: load them from the declared relation
     // (see prefillRelationRequests) and seed the line-items grid.
@@ -1271,7 +1356,7 @@ function GenericActionModal({ open, onOpenChange, action, model, record, endpoin
 // buildFieldDefaults seeds formData for a set of action fields, honoring the
 // same line-items prefill spec + boolean/empty rules GenericActionModal uses, so
 // wizard steps and single-page forms initialize identically.
-export function buildFieldDefaults(fields: ActionFieldDef[], record: any): Record<string, any> {
+export function buildFieldDefaults(fields: ActionFieldDef[], record: any, model?: string): Record<string, any> {
     const defaults: Record<string, any> = {}
     for (const field of fields) {
         if (isLineItemsField(field)) {
@@ -1283,7 +1368,7 @@ export function buildFieldDefaults(fields: ActionFieldDef[], record: any): Recor
                   : []
             continue
         }
-        const fromRecord = scalarDefaultFromRecord(field, record)
+        const fromRecord = scalarDefaultFromRecord(field, record, model)
         if (fromRecord !== undefined && fromRecord !== null && fromRecord !== '') {
             defaults[field.key] = fromRecord
             continue
@@ -1331,10 +1416,10 @@ function WizardActionModal({ open, onOpenChange, action, model, record, endpoint
     useEffect(() => {
         if (!open) return
         const allFields = steps.flatMap((s) => s.fields ?? [])
-        setFormData(buildFieldDefaults(allFields, record))
+        setFormData(buildFieldDefaults(allFields, record, model))
         setStepIndex(0)
         setFormError(undefined)
-    }, [open, action.steps, record])
+    }, [open, action.steps, record, model])
 
     const updateField = (key: string, value: any) =>
         setFormData((prev: Record<string, any>) => ({ ...prev, [key]: value }))

package/src/action-priority.ts

@@ -0,0 +1,82 @@
+// Clasificación primaria / secundaria de acciones — puro (sin React), lo usan
+// el menú de fila, la cabecera/pie del documento y resolveActions del
+// DocumentPage. Ver record-actions.ts para las acciones aportadas por addons.
+import type { ActionPriority } from '@asteby/metacore-sdk'
+import type { InstalledAddonsValue } from './installed-addons-context'
+
+export type { ActionPriority }
+
+/** Lo mínimo que se lee de una acción de metadata para clasificarla. */
+export interface PrioritizableAction {
+    key: string
+    priority?: string
+    trigger?: { type?: string; capability?: string } | null
+}
+
+// Segmentos de la clave (separados por _ . -) que marcan una acción de
+// compartir/salida. Por segmento: `create_mailbox` no es «mail», `send` solo
+// (enviar una cotización) sigue siendo flujo principal.
+const SECONDARY_SEGMENTS = new Set([
+    'print',
+    'reprint',
+    'share',
+    'email',
+    'mail',
+    'whatsapp',
+    'chat',
+    'download',
+    'pdf',
+    'xml',
+    'acuse',
+])
+
+const CRUD_KEYS = new Set(['view', 'edit', 'delete'])
+
+/** "primary" | "secondary" | undefined (= acción normal del menú). */
+export function classifyActionPriority(action: PrioritizableAction): ActionPriority | undefined {
+    if (action.priority === 'primary' || action.priority === 'secondary') return action.priority
+    if (CRUD_KEYS.has(action.key)) return undefined
+    return action.key
+        .toLowerCase()
+        .split(/[_.-]+/)
+        .some((seg) => SECONDARY_SEGMENTS.has(seg))
+        ? 'secondary'
+        : undefined
+}
+
+export interface SplitActions<A> {
+    /** La única destacada (la primera que se declara `primary`). */
+    primary?: A
+    /** El resto de acciones principales, en orden. */
+    main: A[]
+    /** Compartir / imprimir / correo / chat… */
+    secondary: A[]
+}
+
+/**
+ * Separa primaria, principales y secundarias conservando el orden. Si varias
+ * reclaman `primary`, sólo la primera lo es; las demás quedan como principales.
+ */
+export function splitActionsByPriority<A extends PrioritizableAction>(actions: readonly A[]): SplitActions<A> {
+    let primary: A | undefined
+    const main: A[] = []
+    const secondary: A[] = []
+    for (const a of actions) {
+        const p = classifyActionPriority(a)
+        if (p === 'secondary') secondary.push(a)
+        else if (p === 'primary' && !primary) primary = a
+        else main.push(a)
+    }
+    return { primary, main, secondary }
+}
+
+/**
+ * Una acción que despacha por capacidad (`trigger.type: "capability"`) sólo se
+ * ofrece si algún addon instalado la provee. Sin provider = desconocido → se
+ * muestra (el servidor revalida igual).
+ */
+export function isActionProviderActive(action: PrioritizableAction, installed: InstalledAddonsValue | null): boolean {
+    const t = action.trigger
+    if (!installed || !t || t.type !== 'capability' || !t.capability) return true
+    return installed.capabilities.has(t.capability)
+}

package/src/business/business.test.ts

@@ -94,7 +94,7 @@ describe('line items', () => {
             makeLine({ description: ' Llanta ', quantity: '2' as unknown as number, unit_price: '' as unknown as number, sku: '', lot: ' L1 ' }),
             makeLine({ kind: 'note', description: 'Nota' }),
         ])
-        expect(out[0]).toEqual({ position: 1, kind: 'item', description: 'Llanta', quantity: 2, unit_price: 0, discount: 0, tax_rate: 0, lot: 'L1' })
+        expect(out[0]).toEqual({ position: 1, kind: 'item', description: 'Llanta', quantity: 2, unit_price: 0, discount: 0, tax_rate: 0, lot: 'L1', subtotal: 0, tax_amount: 0 })
         expect(out[1]).toEqual({ position: 2, kind: 'note', description: 'Nota' })
         expect(out[0]).not.toHaveProperty('key')
         expect(out[0]).not.toHaveProperty('catalog_price')

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

@@ -0,0 +1,105 @@
+// 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))
+    }
+}
+
+/**
+ * Buscador del host (`searchProducts`) con el IVA de la org como respaldo: un
+ * producto que no trae su tasa entra con la de la org en vez de 0 (retest
+ * Pitsline 2026-10-05: el buscador de ops no devolvía tasa y el renglón de la
+ * factura quedaba sin IVA). Sin tasa de org, el buscador queda tal cual.
+ */
+export function withDefaultTaxRate<Q, S>(
+    search: (query: Q, signal: S) => Promise<ProductResult[]>,
+    defaultTaxRate: number | undefined,
+): (query: Q, signal: S) => Promise<ProductResult[]> {
+    if (defaultTaxRate == null) return search
+    return async (query, signal) => {
+        const rows = await search(query, signal)
+        return rows.map((p) => (p.tax_rate == null ? { ...p, tax_rate: defaultTaxRate } : p))
+    }
+}
+

package/src/business/catalog.ts

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