@asteby/metacore-runtime-react 48.0.0 → 49.0.0

package/src/__tests__/document-form-dialog.test.tsx

@@ -207,6 +207,46 @@ describe('DocumentFormDialog: buscador de catálogo por defecto', () => {
     })
 })
 
+// Retest Pitsline 2026-10-05 (FAC-00013): el buscador de ops no trae tasa y el
+// renglón entraba sin IVA; el producto sin tasa toma la de la org.
+describe('DocumentFormDialog: IVA de la org con el buscador del host', () => {
+    it('producto sin tasa → IVA de la org; con tasa propia → la suya', async () => {
+        const searchProducts = vi.fn(async () => [
+            { id: 'p1', name: 'Llanta host', price: 200 },
+            { id: 'p2', name: 'Frontera host', price: 100, tax_rate: 0.08 },
+        ])
+        const post = vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'inv-1' } } })
+        const client = { get: vi.fn(), post, put: vi.fn(), delete: vi.fn() } as unknown as ApiClient
+        render(
+            <ApiProvider client={client}>
+                <OrgRuntimeProvider taxRate={0.16}>
+                    <DocumentFormDialog
+                        open
+                        onOpenChange={vi.fn()}
+                        model="customers.Invoice"
+                        forms={{ ...forms, lines_field: 'items', types: [forms.types[0]] }}
+                        searchProducts={searchProducts as any}
+                    />
+                </OrgRuntimeProvider>
+            </ApiProvider>,
+        )
+        fireEvent.change(document.querySelectorAll('input')[0], { target: { value: 'ACME' } })
+        fireEvent.click(screen.getByRole('button', { name: 'Siguiente' }))
+        const search = await screen.findByLabelText('Buscar producto')
+        fireEvent.change(search, { target: { value: 'host' } })
+        fireEvent.click(await waitFor(() => screen.getByRole('button', { name: /Llanta host/ }), { timeout: 2000 }))
+        fireEvent.change(await screen.findByLabelText('Buscar producto'), { target: { value: 'fron' } })
+        fireEvent.click(await waitFor(() => screen.getByRole('button', { name: /Frontera host/ }), { timeout: 2000 }))
+        fireEvent.click(screen.getByRole('button', { name: 'Crear' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        const body = post.mock.calls[0][1] as any
+        expect(body.items).toEqual([
+            expect.objectContaining({ product_id: 'p1', quantity: 1, unit_price: 200, tax_rate: 0.16 }),
+            expect.objectContaining({ product_id: 'p2', quantity: 1, unit_price: 100, tax_rate: 0.08 }),
+        ])
+    })
+})
+
 describe('resolveDocumentForms', () => {
     it('sin manifest (o sin tipos) devuelve undefined: el alta genérica sigue igual', () => {
         expect(resolveDocumentForms(null)).toBeUndefined()

package/src/__tests__/prefill-scalar-from-record.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { readRecordPath, scalarDefaultFromRecord, unwrapRecordScalar } from '../action-modal-dispatcher'
+import {
+    buildFieldDefaults,
+    readRecordPath,
+    refTargetsModel,
+    scalarDefaultFromRecord,
+    unwrapRecordScalar,
+} from '../action-modal-dispatcher'
 import type { ActionFieldDef } from '../types'
 
 describe('scalarDefaultFromRecord', () => {
@@ -35,3 +41,48 @@ describe('scalarDefaultFromRecord', () => {
         expect(scalarDefaultFromRecord(field, record)).toBe('11111111-1111-4111-8111-111111111111')
     })
 })
+
+// Retest Pitsline 2026-10-05: «Registrar pago» desde una factura PPD con saldo
+// abría el modal con «Factura» vacía: el campo es `invoice_id` y la fila (la
+// factura) no tiene esa columna, tiene `id`.
+describe('selector que apunta al modelo de la fila', () => {
+    // Campos de customers `register_payment` (target_model Invoice).
+    const registerPayment = [
+        { key: 'customer_id', label: 'Cliente', type: 'dynamic_select', required: true, ref: 'Customer' },
+        {
+            key: 'invoice_id',
+            label: 'Factura',
+            type: 'dynamic_select',
+            ref: 'Invoice',
+            options: { source: 'Invoice', value: 'id', label: 'number' },
+        },
+        { key: 'amount', label: 'Monto', type: 'number', required: true },
+    ] as unknown as ActionFieldDef[]
+    const invoice = { id: 'inv-13', number: 'FAC-00013', customer_id: { value: 'cus-1', label: 'Demo' }, amount_due: 232 }
+
+    it('«Registrar pago» abre precargado con la factura y su cliente', () => {
+        const d = buildFieldDefaults(registerPayment, invoice, 'invoices')
+        expect(d.invoice_id).toBe('inv-13')
+        expect(d.customer_id).toBe('cus-1')
+    })
+
+    it('sin el modelo de la fila no adivina', () => {
+        expect(buildFieldDefaults(registerPayment, invoice).invoice_id).toBe('')
+        expect(buildFieldDefaults(registerPayment, invoice, 'customers').invoice_id).toBe('')
+    })
+
+    it('una columna propia vacía (parent_id sin padre) no se siembra con el id de la fila', () => {
+        const parent = { key: 'parent_id', label: 'Padre', type: 'dynamic_select', ref: 'Category' } as ActionFieldDef
+        expect(scalarDefaultFromRecord(parent, { id: 'cat-1', parent_id: null }, 'categories')).toBeUndefined()
+    })
+
+    it('refTargetsModel tolera prefijo de addon, PascalCase y plural de tabla', () => {
+        expect(refTargetsModel('customers.Invoice', 'invoices')).toBe(true)
+        expect(refTargetsModel('Invoice', 'Invoice')).toBe(true)
+        expect(refTargetsModel('CustomerAddress', 'customer_addresses')).toBe(true)
+        expect(refTargetsModel('SalesOrder', 'sales_orders')).toBe(true)
+        expect(refTargetsModel('Invoice', 'invoice_items')).toBe(false)
+        expect(refTargetsModel(undefined, 'invoices')).toBe(false)
+    })
+})
+

package/src/__tests__/row-action-link-navigation.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { linkNavigation } from '../dynamic-row-actions'
+
+// «Crear desde»: el botón de la fila del origen es una acción link con query
+// (`/m/invoices?create=invoice&from=sales_order&from_id={id}`). En `to` el
+// router la tomaba como parte del path y `$model` quedaba "invoices?create=…".
+describe('linkNavigation', () => {
+    it('separa la query como search', () => {
+        expect(linkNavigation('/m/invoices?create=invoice&from=sales_order&from_id=so-1')).toEqual({
+            to: '/m/invoices',
+            search: { create: 'invoice', from: 'sales_order', from_id: 'so-1' },
+        })
+    })
+    it('sin query deja el destino igual', () => {
+        expect(linkNavigation('/m/quotes/abc')).toEqual({ to: '/m/quotes/abc' })
+    })
+})

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

@@ -84,6 +84,8 @@ import type { ActionFieldDef, TableMetadata, ColumnDefinition } from './types'
 import {
     type ActionMetadata,
     type ActionModalProps,
+    type BridgedActionProps,
+    adaptActionProps,
     getActionComponent,
     subscribeActionComponents,
 } from '@asteby/metacore-sdk'
@@ -338,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') {
@@ -353,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
 }
@@ -402,17 +447,14 @@ export function ActionModalDispatcher({
     }
 
     if (federatedModal) {
-        const FederatedComponent = federatedModalComponent<ActionModalProps>(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
-                    open={open}
-                    onOpenChange={onOpenChange}
-                    action={action}
-                    model={model}
-                    record={record}
-                    endpoint={endpoint}
-                    onSuccess={onSuccess}
+                    {...adaptActionProps({ open, onOpenChange, action, model, record, endpoint, onSuccess })}
                 />
             </Suspense>
         )
@@ -1016,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.
@@ -1314,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)) {
@@ -1326,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
@@ -1374,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

@@ -85,3 +85,21 @@ export function createCatalogProductSearch(api: ApiLike, opts: CatalogProductSea
             .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))
+    }
+}
+