@asteby/metacore-runtime-react 48.0.0 → 49.1.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

@@ -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'
@@ -91,6 +93,8 @@ 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'
+import { isTodayToken, todayInZone } from './calendar-date'
+import { useTimeZone } from './org-runtime-context'
 
 export type { ActionMetadata, ActionModalProps }
 
@@ -338,8 +342,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 +394,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 +449,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>
         )
@@ -979,6 +1023,7 @@ function GenericActionModal({ open, onOpenChange, action, model, record, endpoin
     const reasonPrompt = useReasonPrompt()
     const supervisor = useSupervisor()
     const branchGate = useBranchCreateGate()
+    const orgTimeZone = useTimeZone()
     const [formData, setFormData] = useState<Record<string, any>>({})
     const [executing, setExecuting] = useState(false)
     // Per-field validation errors (localized), shown inline under each input.
@@ -1016,11 +1061,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, { timeZone: orgTimeZone }))
             setFieldErrors({})
             setFormError(undefined)
         }
-    }, [open, action.fields, record])
+    }, [open, action.fields, record, model, orgTimeZone])
 
     // Lines the list row does not carry: load them from the declared relation
     // (see prefillRelationRequests) and seed the line-items grid.
@@ -1311,10 +1356,44 @@ function GenericActionModal({ open, onOpenChange, action, model, record, endpoin
     )
 }
 
+/** Context a declared field default is resolved against. */
+export interface FieldDefaultContext {
+    /** Org IANA timezone: `$today` is the org's day, not the browser's or UTC's. */
+    timeZone?: string
+    /** Clock (tests). */
+    now?: Date
+}
+
+const DATE_FIELD_TYPES = new Set(['date', 'datetime', 'timestamp', 'timestamptz'])
+
+/**
+ * The declared scalar default of a field, resolved: `defaultValue` (host
+ * camelCase) or `default` (raw manifest, the kernel serves action/document-form
+ * fields without renaming it). A date field may declare `$today` / `today` and
+ * gets the org's calendar day. An unknown `$token` never lands in a date field
+ * (undefined): a literal "$today" posted as invoice_date is a 422, an empty
+ * field is just a required field to fill.
+ */
+export function resolveFieldDefault(field: ActionFieldDef, ctx: FieldDefaultContext = {}): unknown {
+    const f = field as { defaultValue?: unknown; default?: unknown }
+    const raw = f.defaultValue ?? f.default
+    if (raw === undefined || raw === null) return undefined
+    if (DATE_FIELD_TYPES.has(String(field.type ?? '').toLowerCase()) && typeof raw === 'string') {
+        if (isTodayToken(raw)) return todayInZone(ctx.timeZone, ctx.now)
+        if (raw.trim().startsWith('$')) return undefined
+    }
+    return raw
+}
+
 // 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,
+    ctx: FieldDefaultContext = {},
+): Record<string, any> {
     const defaults: Record<string, any> = {}
     for (const field of fields) {
         if (isLineItemsField(field)) {
@@ -1326,12 +1405,12 @@ 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
         }
-        defaults[field.key] = field.defaultValue ?? (field.type === 'boolean' ? false : '')
+        defaults[field.key] = resolveFieldDefault(field, ctx) ?? (field.type === 'boolean' ? false : '')
     }
     return defaults
 }
@@ -1362,6 +1441,7 @@ function WizardActionModal({ open, onOpenChange, action, model, record, endpoint
     const api = useApi()
     const reasonPrompt = useReasonPrompt()
     const supervisor = useSupervisor()
+    const orgTimeZone = useTimeZone()
     const steps = action.steps ?? []
     const [stepIndex, setStepIndex] = useState(0)
     const [formData, setFormData] = useState<Record<string, any>>({})
@@ -1374,10 +1454,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, { timeZone: orgTimeZone }))
         setStepIndex(0)
         setFormError(undefined)
-    }, [open, action.steps, record])
+    }, [open, action.steps, record, model, orgTimeZone])
 
     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))
+    }
+}
+