@asteby/metacore-runtime-react 47.1.0 → 49.0.0

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

@@ -12,10 +12,11 @@ vi.mock('react-i18next', () => {
     return { useTranslation: () => value }
 })
 
-import { DocumentFormDialog, resolveDocumentForms } from '../document-form-dialog'
+import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from '../document-form-dialog'
 import { DynamicCRUDPage } from '../dynamic-crud-page'
 import { useMetadataCache } from '../metadata-cache'
 import { ApiProvider, type ApiClient } from '../api-context'
+import { OrgRuntimeProvider } from '../org-runtime-provider'
 import type { DocumentFormsManifest } from '../types'
 
 afterEach(cleanup)
@@ -128,6 +129,124 @@ describe('DocumentFormDialog', () => {
     })
 })
 
+// Retest Pitsline 05/10: Facturas → Crear guardaba la factura en $0 porque el
+// host (DynamicCRUDPage / ops) no pasa `searchProducts` y el paso de renglones
+// solo ofrecía «Renglón libre» sin precio.
+describe('DocumentFormDialog: buscador de catálogo por defecto', () => {
+    const invoiceOnly: DocumentFormsManifest = { ...forms, types: [forms.types[0]] }
+    const catalogRow = {
+        id: 'prod-1',
+        name: 'Llanta 205/55R16',
+        sku: 'LL-205',
+        unit_price: '1500.00',
+        cost_price: '900',
+        unit_of_measure: 'pza',
+        product_type: 'product',
+        fiscal_data: { mx_clave_prod_serv: '25172504', mx_clave_unidad: 'H87' },
+    }
+
+    function mount(opts: { searchProducts?: any; taxRate?: number } = {}) {
+        const get = vi.fn().mockResolvedValue({ data: { success: true, data: [catalogRow] } })
+        const post = vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'inv-1' } } })
+        const client = { get, post, put: vi.fn(), delete: vi.fn() } as unknown as ApiClient
+        render(
+            <ApiProvider client={client}>
+                <OrgRuntimeProvider taxRate={opts.taxRate}>
+                    <DocumentFormDialog
+                        open
+                        onOpenChange={vi.fn()}
+                        model="customers.Invoice"
+                        forms={invoiceOnly}
+                        searchProducts={opts.searchProducts}
+                    />
+                </OrgRuntimeProvider>
+            </ApiProvider>,
+        )
+        return { get, post }
+    }
+
+    async function pickFirstProduct(query: string, name: RegExp) {
+        fireEvent.change(document.querySelectorAll('input')[0], { target: { value: 'ACME' } })
+        fireEvent.click(screen.getByRole('button', { name: 'Siguiente' }))
+        fireEvent.change(await screen.findByLabelText('Buscar producto'), { target: { value: query } })
+        fireEvent.click(await waitFor(() => screen.getByRole('button', { name }), { timeout: 2000 }))
+    }
+
+    it('sin searchProducts del host busca en el catálogo y el renglón entra con precio, cantidad 1, unidad, SKU e IVA de la org', async () => {
+        const { get, post } = mount({ taxRate: 0.16 })
+        await pickFirstProduct('llanta', /Llanta 205\/55R16/)
+        expect(get).toHaveBeenCalledWith(
+            '/data/products.Product',
+            expect.objectContaining({ params: expect.objectContaining({ search: 'llanta' }) }),
+        )
+        fireEvent.click(screen.getByRole('button', { name: 'Crear' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        const [line] = (post.mock.calls[0][1] as any).lines
+        expect(line).toMatchObject({
+            product_id: 'prod-1',
+            sku: 'LL-205',
+            description: 'Llanta 205/55R16',
+            quantity: 1,
+            unit_price: 1500,
+            tax_rate: 0.16,
+            unit: 'pza',
+            fiscal_data: { mx_clave_prod_serv: '25172504', mx_clave_unidad: 'H87' },
+        })
+        expect(line.unit_price).toBeGreaterThan(0)
+    })
+
+    it('si el host pasa searchProducts, se usa ese y no el catálogo', async () => {
+        const searchProducts = vi.fn(async () => [{ id: 'h1', name: 'Servicio host', price: 250, tax_rate: 0.08 }])
+        const { get, post } = mount({ searchProducts })
+        await pickFirstProduct('serv', /Servicio host/)
+        expect(searchProducts).toHaveBeenCalled()
+        expect(get).not.toHaveBeenCalledWith('/data/products.Product', expect.anything())
+        fireEvent.click(screen.getByRole('button', { name: 'Crear' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        expect((post.mock.calls[0][1] as any).lines[0]).toMatchObject({ product_id: 'h1', quantity: 1, unit_price: 250, tax_rate: 0.08 })
+    })
+})
+
+// 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()
@@ -157,7 +276,7 @@ describe('DynamicCRUDPage + document_forms', () => {
             ...extra,
         }) as any
 
-    const mount = (m: any) => {
+    const mount = (m: any, filter?: Record<string, string>) => {
         useMetadataCache.getState().setMetadata('fiscal_documents', m)
         const client = {
             get: vi.fn(async (url: string) =>
@@ -169,7 +288,7 @@ describe('DynamicCRUDPage + document_forms', () => {
         } as unknown as ApiClient
         render(
             <ApiProvider client={client}>
-                <DynamicCRUDPage model="fiscal_documents" />
+                <DynamicCRUDPage model="fiscal_documents" filter={filter} />
             </ApiProvider>,
         )
     }
@@ -187,4 +306,40 @@ describe('DynamicCRUDPage + document_forms', () => {
         await new Promise((r) => setTimeout(r, 50))
         expect(screen.queryByRole('radiogroup')).toBeNull()
     })
+
+    // Retest r3 (05/10): «Documentos fiscales → Facturas» (nav filtrado por el
+    // type_field) ofrecía Crear y abría el REP, el único tipo declarado.
+    it('vista filtrada a un tipo sin formulario: sin botón Crear', async () => {
+        mount(meta({ document_forms: forms }), { type: 'P' })
+        await screen.findByText(/Nota/)
+        await new Promise((r) => setTimeout(r, 50))
+        expect(screen.queryByText(/New Nota/)).toBeNull()
+    })
+
+    it('vista filtrada a un tipo con formulario: Crear abre ese tipo directo', async () => {
+        mount(meta({ document_forms: forms }), { type: 'eq:E' })
+        fireEvent.click((await screen.findByText(/New Nota/)).closest('button')!)
+        expect(await screen.findByText('Factura origen')).toBeTruthy()
+        expect(screen.queryByRole('radiogroup')).toBeNull()
+    })
+})
+
+describe('scopeDocumentFormsToFilter', () => {
+    it('sin filtro sobre el type_field no cambia nada', () => {
+        expect(scopeDocumentFormsToFilter(forms, undefined)).toEqual({ forms, hideCreate: false })
+        expect(scopeDocumentFormsToFilter(forms, { status: 'draft' })).toEqual({ forms, hideCreate: false })
+        expect(scopeDocumentFormsToFilter(undefined, { type: 'I' })).toEqual({ forms: undefined, hideCreate: false })
+        expect(scopeDocumentFormsToFilter({ ...forms, type_field: undefined }, { type: 'X' }).hideCreate).toBe(false)
+    })
+
+    it('acota al tipo del filtro (valor o key, sin importar mayúsculas ni eq:)', () => {
+        expect(scopeDocumentFormsToFilter(forms, { type: 'e' }).forms?.types.map((x) => x.key)).toEqual(['credit_note'])
+        expect(scopeDocumentFormsToFilter(forms, { type: 'eq:I' }).forms?.types.map((x) => x.key)).toEqual(['invoice'])
+        const noValue: DocumentFormsManifest = { type_field: 'document_type', types: [{ key: 'payment_complement', label: 'REP', fields: [] }] }
+        expect(scopeDocumentFormsToFilter(noValue, { document_type: 'payment_complement' }).forms).toBe(noValue)
+    })
+
+    it('filtro a un tipo sin formulario: oculta Crear', () => {
+        expect(scopeDocumentFormsToFilter(forms, { type: 'P' })).toEqual({ forms: undefined, hideCreate: true })
+    })
 })

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

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

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

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

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

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

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

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

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

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

package/src/__tests__/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)
+    })
+})
+