@asteby/metacore-runtime-react 49.2.1 → 49.3.1

package/dist/validator.js

@@ -1,3 +1,4 @@
+import { applyOptionWhen, getDependsOn } from './option-when';
 const NIL_UUID = '00000000-0000-0000-0000-000000000000';
 const NUMERIC_TYPES = new Set(['int', 'integer', 'bigint', 'decimal', 'numeric', 'number', 'float', 'double']);
 const RULE_NAMES = new Set([
@@ -203,7 +204,13 @@ function checkBuiltin(slug, value) {
             return undefined;
     }
 }
-function specFromField(field) {
+/**
+ * `context` son los valores hermanos contra los que se evalúa el `when` de
+ * cada opción: una opción que su `when` descarta con el valor actual (forma de
+ * pago «99» con método PUE) es `invalid_option`, igual que una fuera de catálogo
+ * — y como la rechaza el kernel al guardar.
+ */
+function specFromField(field, context) {
     const v = fieldValidationOf(field);
     const spec = {
         required: !!field.required,
@@ -213,8 +220,10 @@ function specFromField(field) {
         max: v.max,
         custom: v.custom,
     };
-    if (field.options?.length)
-        spec.options = field.options.map(o => String(o.value));
+    if (field.options?.length) {
+        const applicable = context ? applyOptionWhen(field.options, context, getDependsOn(field)) : field.options;
+        spec.options = applicable.map(o => String(o.value));
+    }
     return spec;
 }
 function isLineItems(field) {
@@ -229,10 +238,10 @@ function itemFieldsOf(field) {
  *  field issue, dotted keys for line-items (`items.0.qty`). */
 export function validateValues(fields, values) {
     const bag = {};
-    walk(fields, values ?? {}, '', bag);
+    walk(fields, values ?? {}, '', bag, values ?? {});
     return bag;
 }
-function walk(fields, values, prefix, bag) {
+function walk(fields, values, prefix, bag, context) {
     for (const field of fields) {
         const key = field.key;
         if (!key)
@@ -247,11 +256,12 @@ function walk(fields, values, prefix, bag) {
             }
             rows.forEach((row, i) => {
                 const obj = row && typeof row === 'object' ? row : {};
-                walk(itemFieldsOf(field), obj, `${path}.${i}`, bag);
+                // Una celda puede depender de otra del renglón o del encabezado.
+                walk(itemFieldsOf(field), obj, `${path}.${i}`, bag, { ...context, ...obj });
             });
             continue;
         }
-        const issues = checkValue(raw, specFromField(field));
+        const issues = checkValue(raw, specFromField(field, context));
         if (issues.length)
             bag[path] = issues;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asteby/metacore-runtime-react",
-  "version": "49.2.1",
+  "version": "49.3.1",
   "description": "React runtime for metacore hosts — renders addon contributions dynamically",
   "repository": {
     "type": "git",

package/src/__tests__/document-editor-model.test.ts

@@ -17,7 +17,7 @@ import {
     splitEditorFields,
     toOpenDocuments,
 } from '../business/document-editor-model'
-import { makeLine, serializeLineItems } from '../business/line-items'
+import { makeLine, serializeLineItems, validateLineItems } from '../business/line-items'
 import { allocatePayment, validateAllocation } from '../primitives/allocation'
 import type { ActionFieldDef, DocumentFormOpenDocuments } from '../types'
 
@@ -100,6 +100,19 @@ describe('linesFromSource', () => {
         expect(l.discount).toBe(10)
         expect(l.tax_rate).toBe(0.16)
     })
+    it('carga parcial: el descuento en importe se prorratea a lo pendiente (no supera el importe)', () => {
+        // Cotización 4 llantas × $1,000 con $400 de descuento; 3 ya facturadas.
+        const rows = [{ id: 'q1', description: 'Llanta', quantity: 4, unit_price: 1000, discount_amount: 400, tax_rate: 16, source_quantity: 4, remaining_quantity: 1 }]
+        const [l] = linesFromSource(rows, { discount: 'discount_amount' }, { discountMode: 'amount' })
+        expect(l).toMatchObject({ quantity: 1, max_quantity: 1, discount: 100, discount_kind: 'amount' })
+        expect(validateLineItems([l]).errors).toEqual({})
+        // Sin lo pendiente servido (o completo) el importe queda intacto.
+        const [full] = linesFromSource([{ ...rows[0], remaining_quantity: 4 }], { discount: 'discount_amount' }, { discountMode: 'amount' })
+        expect(full.discount).toBe(400)
+        // Un porcentaje no depende de la cantidad.
+        const [pct] = linesFromSource([{ ...rows[0], discount_pct: 10 }], { discount: 'discount_pct' })
+        expect(pct.discount).toBe(10)
+    })
     it('NC (credit): la cantidad queda topada en lo facturado', () => {
         const [l] = linesFromSource([{ description: 'Llanta', quantity: 4, unit_price: 1500, tax_rate: 0.16 }], {}, { kind: 'credit' })
         expect(l.max_quantity).toBe(4)

package/src/__tests__/document-editor.test.tsx

@@ -224,6 +224,28 @@ describe('DocumentEditor — cobro / REP (lines.kind: allocation)', () => {
         expect(body.type).toBeUndefined()
     })
 
+    it('«crear desde» una factura: toma su cliente y lista sus facturas abiertas con saldo', async () => {
+        const fromInvoice: DocumentFormType = {
+            ...payment,
+            fields: payment.fields.map((f) => ({ ...f, default_from_record: undefined }) as any),
+            sources: [{ key: 'invoice', label: 'Factura', model: 'customers.Invoice', lines: 'items', header: { customer_id: 'customer_id' } }],
+        }
+        const api = makeApi({
+            ...routes,
+            '/data/customers.Invoice': (_url: string, cfg?: { params?: Record<string, unknown> }) =>
+                cfg?.params?.f_id
+                    ? { data: [{ id: 'inv-new', number: 'A-2', customer_id: 'c1', amount_due: 1000 }] }
+                    : (routes['/data/customers.Invoice'] as unknown),
+        })
+        renderEditor(fromInvoice, api, { initialSource: { key: 'invoice', id: 'inv-new' } })
+        await screen.findByText('A-1')
+        expect(screen.getByText('A-2')).toBeTruthy()
+        expect(api.get).toHaveBeenCalledWith('/data/customers.Invoice', expect.objectContaining({ params: expect.objectContaining({ f_id: 'eq:inv-new' }) }))
+        expect(api.get).toHaveBeenCalledWith('/data/customers.Invoice', expect.objectContaining({ params: expect.objectContaining({ f_customer_id: 'eq:c1' }) }))
+        // Sin renglones que copiar: no pide source-lines ni la relación.
+        expect(api.get.mock.calls.some(([u]) => String(u).includes('source-lines'))).toBe(false)
+    })
+
     it('editar un monto pasa a reparto manual; «Autoaplicar» regresa al automático', async () => {
         const api = makeApi(routes)
         renderEditor(payment, api, { record: { customer_id: 'c1' } })
@@ -298,7 +320,7 @@ describe('DocumentEditor — «crear desde» con lo pendiente del servidor', ()
         await screen.findByDisplayValue('Llanta 205/55R16')
         expect(screen.queryByDisplayValue('Balanceo')).toBeNull()
         expect(api.get).toHaveBeenCalledWith('/dynamic/customers.Invoice/source-lines', { params: { source: 'sales_order', id: 'so-1' } })
-        expect(await screen.findByText('1 renglones con lo pendiente · 1 ya cubiertos se omitieron')).toBeTruthy()
+        expect(await screen.findByText('1 renglones con lo que falta · 1 ya completos (omitidos)')).toBeTruthy()
     })
 
     it('si el host aún no sirve source-lines (404) cae a la relación del origen', async () => {

package/src/__tests__/document-form-dialog.no-stale-flash.test.tsx

@@ -0,0 +1,169 @@
+// @vitest-environment happy-dom
+// QA Pitsline r6: «al abrir una Nota de crédito se ve un instante el modal viejo»
+// antes del DocumentEditor. El host reutiliza el diálogo montado (misma ruta
+// /m/$model para Facturas → Notas de crédito, o formularios que cambian de la
+// caché a la metadata viva mientras está cerrado) y el primer render al abrir
+// pintaba el wizard con el tipo de la apertura anterior: el reinicio vivía en un
+// efecto, que corre DESPUÉS de que ese frame ya se pintó.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/react'
+
+vi.mock('@tanstack/react-router', () => ({ useNavigate: () => () => {} }))
+vi.mock('react-i18next', () => {
+    const i18n = { language: 'es' }
+    const t = (k: string, o?: { defaultValue?: string }) => o?.defaultValue ?? k
+    const value = { t, i18n }
+    return { useTranslation: () => value }
+})
+// Dialog sin portal ni Presence: cada commit de React llega tal cual al DOM. Con
+// el portal de Radix el primer commit al abrir queda vacío y, en act(), el efecto
+// de reinicio alcanza a correr antes del siguiente; en el navegador ese reinicio
+// va en otra prioridad y el frame intermedio sí se pinta.
+vi.mock('@asteby/metacore-ui/primitives', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>()
+    const React = await import('react')
+    return {
+        ...actual,
+        Dialog: ({ open, children }: { open?: boolean; children?: React.ReactNode }) =>
+            open ? React.createElement(React.Fragment, null, children) : null,
+        DialogContent: ({ children, ...rest }: Record<string, unknown> & { children?: React.ReactNode }) => {
+            const attrs: Record<string, unknown> = {}
+            for (const [k, v] of Object.entries(rest)) if (k.startsWith('data-')) attrs[k] = v
+            return React.createElement('div', { role: 'dialog', ...attrs }, children)
+        },
+        DialogHeader: ({ children }: { children?: React.ReactNode }) => React.createElement('div', null, children),
+        DialogFooter: ({ children }: { children?: React.ReactNode }) => React.createElement('div', null, children),
+        DialogTitle: ({ children }: { children?: React.ReactNode }) => React.createElement('h2', null, children),
+        DialogDescription: ({ children }: { children?: React.ReactNode }) => React.createElement('p', null, children),
+    }
+})
+
+import { DocumentFormDialog } from '../document-form-dialog'
+import { ApiProvider, type ApiClient } from '../api-context'
+import type { DocumentFormsManifest } from '../types'
+
+afterEach(cleanup)
+
+const client = {
+    get: vi.fn().mockResolvedValue({ data: { data: [] } }),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+} as unknown as ApiClient
+
+// Formularios genéricos con layout editor (cualquier document_form, no sólo fiscal).
+const formsA: DocumentFormsManifest = {
+    types: [
+        {
+            key: 'doc_a',
+            label: 'Documento A',
+            layout: 'editor',
+            fields: [{ key: 'party', label: 'Contraparte', type: 'text' }],
+        },
+    ],
+}
+const formsB: DocumentFormsManifest = {
+    types: [
+        {
+            key: 'doc_b',
+            label: 'Documento B',
+            layout: 'editor',
+            submit_action: 'create_doc_b',
+            fields: [{ key: 'origin', label: 'Origen', type: 'text' }],
+        },
+    ],
+}
+const formsAB: DocumentFormsManifest = { types: [...formsA.types, ...formsB.types] }
+
+/** Registra si el wizard llegó a montarse en el DOM, aunque sea un frame. */
+function watchLegacyDialog(forbiddenText?: string) {
+    let seen = false
+    let sawText = false
+    const hasText = (v: string | null | undefined) => !!forbiddenText && !!v && v.includes(forbiddenText)
+    const hit = (n: Node) =>
+        n instanceof Element &&
+        (n.matches('[data-slot="document-form-dialog"]') || !!n.querySelector('[data-slot="document-form-dialog"]'))
+    const check = () => {
+        if (document.querySelector('[data-slot="document-form-dialog"]')) seen = true
+    }
+    // React reutiliza el mismo nodo del Dialog entre ramas y sólo cambia
+    // `data-slot`: se mira también el valor anterior del atributo.
+    const scan = (records: MutationRecord[]) => {
+        for (const r of records) {
+            if (r.type === 'attributes' && r.oldValue === 'document-form-dialog') seen = true
+            if (r.type === 'characterData' && hasText(r.oldValue)) sawText = true
+            r.addedNodes.forEach((n) => {
+                if (hit(n)) seen = true
+                if (hasText(n.textContent)) sawText = true
+            })
+        }
+    }
+    const obs = new MutationObserver(scan)
+    obs.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeOldValue: true,
+        attributeFilter: ['data-slot'],
+        characterData: true,
+        characterDataOldValue: true,
+    })
+    return {
+        check,
+        seen: () => {
+            scan(obs.takeRecords())
+            obs.disconnect()
+            return seen
+        },
+        sawText: () => sawText,
+    }
+}
+
+function dialog(props: { open: boolean; forms: DocumentFormsManifest; initialType?: string }) {
+    return (
+        <ApiProvider client={client}>
+            <DocumentFormDialog
+                open={props.open}
+                onOpenChange={() => {}}
+                model="docs"
+                endpoint="/data/docs/me"
+                forms={props.forms}
+                initialType={props.initialType}
+            />
+        </ApiProvider>
+    )
+}
+
+describe('DocumentFormDialog no pinta el wizard antes del DocumentEditor', () => {
+    it('reutilizado con otros formularios (otra vista del mismo host): abre directo el editor', () => {
+        const { rerender } = render(dialog({ open: false, forms: formsA }))
+        rerender(dialog({ open: false, forms: formsB }))
+        const watch = watchLegacyDialog()
+        rerender(dialog({ open: true, forms: formsB, initialType: 'doc_b' }))
+        watch.check()
+        expect(watch.seen()).toBe(false)
+        expect(document.querySelector('[data-slot="document-editor"]')).toBeTruthy()
+    })
+
+    it('«Crear» sin tipo inicial en la vista nueva: tampoco hay frame del wizard', () => {
+        const { rerender } = render(dialog({ open: false, forms: formsA }))
+        rerender(dialog({ open: false, forms: formsB }))
+        const watch = watchLegacyDialog()
+        rerender(dialog({ open: true, forms: formsB }))
+        watch.check()
+        expect(watch.seen()).toBe(false)
+        expect(document.querySelector('[data-slot="document-editor"]')).toBeTruthy()
+    })
+
+    it('reabierto con otro initialType: el primer frame ya es el editor del tipo pedido', () => {
+        const { rerender } = render(dialog({ open: true, forms: formsAB, initialType: 'doc_a' }))
+        rerender(dialog({ open: false, forms: formsAB, initialType: 'doc_a' }))
+        const watch = watchLegacyDialog('Documento A')
+        rerender(dialog({ open: true, forms: formsAB, initialType: 'doc_b' }))
+        watch.check()
+        expect(watch.seen()).toBe(false)
+        // Ni un frame del editor del tipo de la apertura anterior.
+        expect(watch.sawText()).toBe(false)
+        expect(document.querySelector('[data-slot="document-editor"]')).toBeTruthy()
+    })
+})

package/src/__tests__/invoice-document-editor.test.tsx

@@ -164,7 +164,7 @@ describe('Factura con layout editor — pantalla única', () => {
 
     it('«Cargar desde» ofrece venta, OT y cotización como opciones', () => {
         renderInvoice(makeApi())
-        const group = screen.getByRole('radiogroup', { name: 'Tipo de documento origen' })
+        const group = screen.getByRole('radiogroup', { name: 'Documento de origen' })
         expect(within(group).getAllByRole('radio').map((r) => r.textContent)).toEqual(['Venta', 'Orden de trabajo', 'Cotización'])
         fireEvent.click(within(group).getByRole('radio', { name: 'Orden de trabajo' }))
         expect(within(group).getByRole('radio', { name: 'Orden de trabajo' }).getAttribute('aria-checked')).toBe('true')
@@ -180,7 +180,7 @@ describe('Factura — «Cargar desde» OT y cotización con lo restante', () =>
         expect(screen.getByDisplayValue('Alineación eje direccional')).toBeTruthy()
         expect(screen.queryByDisplayValue('Montaje y balanceo')).toBeNull()
         expect(api.get).toHaveBeenCalledWith('/dynamic/customers.Invoice/source-lines', { params: { source: 'work_order', id: 'wo-1' } })
-        expect(await screen.findByText('2 renglones con lo pendiente · 1 ya cubiertos se omitieron')).toBeTruthy()
+        expect(await screen.findByText('2 renglones con lo que falta · 1 ya completos (omitidos)')).toBeTruthy()
 
         // La tarjeta del cliente: datos fiscales con etiquetas del modelo.
         await waitFor(() => expect(slot('party-card')).toBeTruthy())
@@ -214,8 +214,9 @@ describe('Factura — «Cargar desde» OT y cotización con lo restante', () =>
         const [, body] = api.post.mock.calls[0] as [string, any]
         expect(body.quote_id).toBe('q-1')
         expect(body.currency_code).toBe('MXN')
+        // El descuento ($1,200 de las 6 piezas) se prorratea a las 4 pendientes.
         expect(body.items).toEqual([
-            expect.objectContaining({ product_id: 'p-llanta', quantity: 4, unit_price: 5890, discount: 1200, tax_rate: 0.16, quote_item_id: 'qi-1' }),
+            expect.objectContaining({ product_id: 'p-llanta', quantity: 4, unit_price: 5890, discount: 800, tax_rate: 0.16, quote_item_id: 'qi-1' }),
         ])
         expect(body.items[0]).not.toHaveProperty('work_order_item_id')
     })

package/src/__tests__/option-when-validation.test.tsx

@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+// Forma de pago «99 · Por definir» solo con método PPD, y con PPD solo «99»:
+// la regla viaja en el `when` de las opciones del manifest. El validador y el
+// render compartido de campos (renderField, que usan el DocumentEditor, el
+// diálogo de document_forms y los modales de acción) la respetan.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/react'
+
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (k: string, o?: { defaultValue?: string }) => o?.defaultValue ?? k, i18n: { language: 'es' } }),
+}))
+
+import { validateValues } from '../validator'
+import { renderField } from '../action-modal-dispatcher'
+import type { ActionFieldDef } from '../types'
+
+const notPPD = { field: 'fiscal_data.metodo_pago', not_in: ['PPD'] }
+const ppd = { field: 'fiscal_data.metodo_pago', in: ['PPD'] }
+const fields: ActionFieldDef[] = [
+    {
+        key: 'fiscal_data.metodo_pago',
+        label: 'Método',
+        type: 'select',
+        options: [
+            { value: 'PUE', label: 'PUE' },
+            { value: 'PPD', label: 'PPD' },
+        ],
+    },
+    {
+        key: 'fiscal_data.forma_pago',
+        label: 'Forma',
+        type: 'select',
+        options: [
+            { value: '01', label: 'Efectivo', when: notPPD },
+            { value: '03', label: 'Transferencia', when: notPPD },
+            { value: '99', label: 'Por definir', when: ppd },
+        ],
+    },
+]
+
+const header = (metodo: string, forma: string) => ({ 'fiscal_data.metodo_pago': metodo, 'fiscal_data.forma_pago': forma })
+
+afterEach(cleanup)
+
+describe('validateValues con options[].when', () => {
+    it('99 con PUE es invalid_option', () => {
+        const bag = validateValues(fields, header('PUE', '99'))
+        expect(bag['fiscal_data.forma_pago']?.[0]?.code).toBe('invalid_option')
+        expect(bag['fiscal_data.forma_pago']?.[0]?.params).toEqual({ allowed: ['01', '03'] })
+    })
+    it('PPD exige 99', () => {
+        const bag = validateValues(fields, header('PPD', '01'))
+        expect(bag['fiscal_data.forma_pago']?.[0]).toEqual({ code: 'invalid_option', params: { allowed: ['99'] } })
+    })
+    it('PPD + 99 y PUE + 01 pasan', () => {
+        expect(validateValues(fields, header('PPD', '99'))).toEqual({})
+        expect(validateValues(fields, header('PUE', '01'))).toEqual({})
+    })
+    it('una celda de renglón se evalúa contra su renglón y el encabezado', () => {
+        const lines: ActionFieldDef = {
+            key: 'items',
+            label: 'Renglones',
+            type: 'array',
+            itemFields: [{ ...fields[1]!, key: 'forma' }],
+        }
+        const bag = validateValues([fields[0]!, lines], { 'fiscal_data.metodo_pago': 'PPD', items: [{ forma: '03' }, { forma: '99' }] })
+        expect(bag['items.0.forma']?.[0]?.code).toBe('invalid_option')
+        expect(bag['items.1.forma']).toBeUndefined()
+    })
+})
+
+describe('renderField con options[].when', () => {
+    const trigger = (metodo: string, forma: string) => {
+        const { container } = render(<>{renderField(fields[1]!, forma, () => {}, header(metodo, forma))}</>)
+        return container.querySelector('[aria-invalid], button, [role="combobox"]') as HTMLElement
+    }
+    it('marca en el acto una forma que el método ya no permite', () => {
+        const el = trigger('PUE', '99')
+        expect(el.getAttribute('aria-invalid')).toBe('true')
+        expect(el.getAttribute('data-stale-option')).toBe('true')
+    })
+    it('una combinación válida no se marca', () => {
+        const el = trigger('PPD', '99')
+        expect(el.getAttribute('aria-invalid')).toBeNull()
+        expect(el.getAttribute('data-stale-option')).toBeNull()
+    })
+})

package/src/__tests__/r6-editor-option-when.test.tsx

@@ -0,0 +1,104 @@
+// @vitest-environment happy-dom
+// Retest Pitsline r6 (P0 UX): en el editor de la factura, método PPD exige
+// forma de pago 99 (`options[].when` del manifest). Elegir PPD fija 99 solo y
+// el alta lleva los dos valores, no solo el diálogo de Timbrar.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+
+vi.mock('@tanstack/react-router', () => ({ useNavigate: () => () => {} }))
+vi.mock('react-i18next', () => {
+    const value = { t: (k: string, o?: Record<string, any>) => o?.defaultValue ?? k, i18n: { language: 'es' } }
+    return { useTranslation: () => value }
+})
+
+import { DocumentFormDialog } from '../document-form-dialog'
+import { ApiProvider, type ApiClient } from '../api-context'
+import { TaxRateContext } from '../org-runtime-context'
+import { gatedOptionFixes } from '../business/document-editor-model'
+import type { ActionFieldDef, DocumentFormsManifest, DocumentFormType } from '../types'
+
+afterEach(cleanup)
+
+const notPPD = { field: 'fiscal_data.metodo_pago', not_in: ['PPD'] }
+const formaPago: ActionFieldDef = {
+    key: 'fiscal_data.forma_pago',
+    label: 'Forma de pago',
+    type: 'select',
+    required: true,
+    defaultValue: '01',
+    options: [
+        { value: '01', label: 'Efectivo · 01', when: notPPD },
+        { value: '03', label: 'Transferencia · 03', when: notPPD },
+        { value: '99', label: 'Por definir · 99', when: { field: 'fiscal_data.metodo_pago', in: ['PPD'] } },
+    ],
+} as ActionFieldDef
+const metodoPago: ActionFieldDef = {
+    key: 'fiscal_data.metodo_pago',
+    label: 'Método de pago',
+    type: 'select',
+    required: true,
+    defaultValue: 'PUE',
+    options: [
+        { value: 'PUE', label: 'Una sola exhibición · PUE' },
+        { value: 'PPD', label: 'Parcialidades o diferido · PPD' },
+    ],
+}
+
+const invoice: DocumentFormType = {
+    key: 'invoice',
+    label: 'Factura',
+    layout: 'editor',
+    fields: [{ key: 'customer_id', label: 'Cliente', type: 'text', required: true }, metodoPago, formaPago],
+    defaults: { 'fiscal_data.metodo_pago': 'PUE', 'fiscal_data.forma_pago': '01' },
+    lines: { title: 'Renglones', required: false },
+    submit_label: 'Crear factura',
+}
+
+function renderInvoice(post: ReturnType<typeof vi.fn>) {
+    const client = { get: vi.fn(async () => ({ data: { data: [] } })), post, put: vi.fn(), delete: vi.fn() } as unknown as ApiClient
+    const forms: DocumentFormsManifest = { lines_field: 'items', types: [invoice] }
+    return render(
+        <ApiProvider client={client}>
+            <TaxRateContext.Provider value={0.16}>
+                <DocumentFormDialog open onOpenChange={() => {}} model="customers.Invoice" forms={forms} initialType="invoice" currency="MXN" />
+            </TaxRateContext.Provider>
+        </ApiProvider>,
+    )
+}
+
+async function pick(fieldLabel: RegExp, option: RegExp) {
+    const trigger = screen.getAllByRole('combobox').find((el) => fieldLabel.test(el.closest('[data-slot="field-cell"], div')?.textContent ?? '')) as HTMLElement
+    fireEvent.pointerDown(trigger, { button: 0, ctrlKey: false, pointerType: 'mouse' })
+    fireEvent.click(await screen.findByRole('option', { name: option }))
+}
+
+describe('factura: método PPD ⇒ forma de pago 99', () => {
+    it('elegir PPD fija la forma 99 y el alta la lleva', async () => {
+        const post = vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'inv-1' } } })
+        renderInvoice(post)
+        fireEvent.change(document.getElementById('customer_id')!, { target: { value: 'c-1' } })
+
+        await pick(/Método de pago/, /PPD/)
+        await waitFor(() => expect(screen.getAllByText('Por definir · 99').length).toBeGreaterThan(0))
+        fireEvent.click(screen.getByRole('button', { name: 'Crear factura' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        const body = post.mock.calls[0][1] as Record<string, unknown>
+        expect(body['fiscal_data.metodo_pago']).toBe('PPD')
+        expect(body['fiscal_data.forma_pago']).toBe('99')
+    })
+})
+
+describe('gatedOptionFixes', () => {
+    const fields = [metodoPago, formaPago]
+    it('PPD con forma 01 → 99 (la única que aplica)', () => {
+        expect(gatedOptionFixes(fields, { 'fiscal_data.metodo_pago': 'PPD', 'fiscal_data.forma_pago': '01' })).toEqual({ 'fiscal_data.forma_pago': '99' })
+    })
+    it('PUE con forma 99 → el default del campo', () => {
+        expect(gatedOptionFixes(fields, { 'fiscal_data.metodo_pago': 'PUE', 'fiscal_data.forma_pago': '99' })).toEqual({ 'fiscal_data.forma_pago': '01' })
+    })
+    it('valor válido o vacío con varias opciones: sin cambios (converge)', () => {
+        expect(gatedOptionFixes(fields, { 'fiscal_data.metodo_pago': 'PUE', 'fiscal_data.forma_pago': '03' })).toEqual({})
+        expect(gatedOptionFixes(fields, { 'fiscal_data.metodo_pago': 'PUE', 'fiscal_data.forma_pago': '' })).toEqual({})
+        expect(gatedOptionFixes(fields, { 'fiscal_data.metodo_pago': 'PPD', 'fiscal_data.forma_pago': '99' })).toEqual({})
+    })
+})

package/src/action-modal-dispatcher.tsx

@@ -69,7 +69,7 @@ import { DynamicRelations } from './dynamic-relations'
 import { DynamicSelectField } from './dynamic-select-field'
 import { DynamicDateField } from './dynamic-date-field'
 import { UploadField } from './upload-field'
-import { isLineItemsField, resolveWidget, resolveDependsValue, getDependsOn, getFieldRef } from './dynamic-form-schema'
+import { isLineItemsField, resolveWidget, resolveDependsValue, getDependsOn, getFieldRef, applyOptionWhen } from './dynamic-form-schema'
 import { FieldGrid, FieldCell, FieldLabel } from './field-grid'
 import { useMetadataCache } from './metadata-cache'
 import {
@@ -1752,15 +1752,24 @@ export function renderField(
     switch (widget) {
         case 'textarea':
             return <Textarea id={field.key} value={value || ''} onChange={(e: React.ChangeEvent<HTMLTextAreaElement>) => onChange(e.target.value)} placeholder={field.placeholder} aria-invalid={invalid || undefined} className={invalidCls || undefined} />
-        case 'select':
+        case 'select': {
+            // Opciones condicionadas por un campo hermano (`options[].when`, p. ej.
+            // forma de pago «99» solo con método PPD): solo se ofrecen las que
+            // aplican, y un valor ya elegido que dejó de aplicar se marca en el
+            // acto (el validador y el kernel lo rechazan como invalid_option).
+            const options = formValues ? applyOptionWhen(field.options, formValues, getDependsOn(field)) : field.options ?? []
+            const stale = !!value && !options.some((o) => String(o.value) === String(value))
+            const selectInvalid = invalid || stale
+            const selectCls = selectInvalid ? 'border-destructive ring-1 ring-destructive/30 focus-visible:ring-destructive' : ''
             return (
-                <Select value={value || ''} onValueChange={onChange}>
-                    <SelectTrigger className={'w-full' + (invalidCls ? ` ${invalidCls}` : '')} aria-invalid={invalid || undefined}><SelectValue placeholder={field.placeholder || 'Seleccionar...'} /></SelectTrigger>
+                <Select value={stale ? '' : value || ''} onValueChange={onChange}>
+                    <SelectTrigger className={'w-full' + (selectCls ? ` ${selectCls}` : '')} aria-invalid={selectInvalid || undefined} data-stale-option={stale || undefined}><SelectValue placeholder={field.placeholder || 'Seleccionar...'} /></SelectTrigger>
                     <SelectContent>
-                        {field.options?.map((opt) => <SelectItem key={opt.value} value={opt.value}>{opt.label}</SelectItem>)}
+                        {options.map((opt) => <SelectItem key={opt.value} value={opt.value}>{opt.label}</SelectItem>)}
                     </SelectContent>
                 </Select>
             )
+        }
         case 'switch':
             return <Switch id={field.key} checked={!!value} onCheckedChange={onChange} />
         case 'number':

package/src/business/document-editor-model.ts

@@ -6,6 +6,7 @@
 import { roundMoney, toAmount } from './format'
 import { computeTotals, makeLine, type LineItem } from './line-items'
 import { optionPassesRule, getOptionFilter } from '../option-filter'
+import { applyOptionWhen, getDependsOn } from '../dynamic-form-schema'
 import type { ResolvedOption } from '../use-options-resolver'
 import type { Allocation, AllocationIssue, OpenDocument } from '../primitives/allocation'
 import type {
@@ -119,6 +120,40 @@ export function withFriendlyOptions(f: ActionFieldDef): ActionFieldDef {
     return { ...f, options: f.options.map((o) => ({ ...o, label: friendlyOptionLabel(String(o.label ?? o.value)) })) }
 }
 
+/** Select estático con alguna opción condicionada por otro campo (`options[].when`). */
+function isGatedSelect(f: ActionFieldDef): boolean {
+    return Array.isArray(f.options) && f.options.some((o) => !!o?.when)
+}
+
+/** Opciones del select que aplican con los valores actuales (`options[].when`). */
+export function gatedOptions(f: ActionFieldDef, values: Record<string, unknown>): ActionFieldDef {
+    if (!isGatedSelect(f)) return f
+    return { ...f, options: applyOptionWhen(f.options, values, getDependsOn(f)) }
+}
+
+/**
+ * Selects con opciones condicionadas (`options[].when`, p. ej. forma de pago
+ * «99» solo con método PPD): cuando el valor actual deja de aplicar —o está
+ * vacío y solo queda una opción— devuelve el que toca. Una sola opción
+ * permitida se elige sola; si hay varias, el default del campo si aplica; si
+ * no, vacío. Sin cambios devuelve `{}`, así que aplicarlo converge.
+ */
+export function gatedOptionFixes(fields: readonly ActionFieldDef[], values: Record<string, unknown>): Record<string, unknown> {
+    const out: Record<string, unknown> = {}
+    for (const f of fields) {
+        if (!isGatedSelect(f)) continue
+        const allowed = applyOptionWhen(f.options, values, getDependsOn(f))
+        const cur = values[f.key]
+        const ok = (v: unknown) => hasValue(v) && allowed.some((o) => String(o.value) === String(v))
+        if (ok(cur)) continue
+        if (!hasValue(cur) && allowed.length !== 1) continue
+        const def = declaredDefault(f)
+        const next = allowed.length === 1 ? allowed[0].value : ok(def) ? def : ''
+        if (String(next ?? '') !== String(cur ?? '')) out[f.key] = next
+    }
+    return out
+}
+
 /**
  * Defaults del encabezado que salen de la contraparte: los campos de extensión
  * con la MISMA clave en ambos modelos (p. ej. `fiscal_data.uso_cfdi` de Customer
@@ -200,7 +235,8 @@ export function creditStatus(
  *
  * Con `remaining_quantity` (lo sirve el host: cantidad − lo ya facturado o
  * devuelto) la cantidad sugerida y el tope son lo pendiente y los renglones ya
- * cubiertos se omiten. Cada línea guarda `source_line_id` para el vínculo.
+ * cubiertos se omiten; un descuento en importe se prorratea a lo pendiente (un
+ * porcentaje no cambia). Cada línea guarda `source_line_id` para el vínculo.
  */
 export function linesFromSource(
     rows: unknown,
@@ -237,7 +273,16 @@ export function linesFromSource(
         })
         // El descuento del origen se lee en la unidad del documento (importe en
         // modelos cuyo subtotal resta un monto).
-        if (opts.discountMode === 'amount') line.discount_kind = 'amount'
+        if (opts.discountMode === 'amount') {
+            line.discount_kind = 'amount'
+            // Un importe es de TODO el renglón de origen: al cargar solo lo
+            // pendiente se prorratea a esa cantidad (4 llantas con $400 de
+            // descuento, 1 pendiente → $100), si no superaría el importe.
+            const sourceQty = toAmount(r.source_quantity ?? get('quantity'))
+            if (pending != null && sourceQty > 0 && pending < sourceQty) {
+                line.discount = roundMoney((toAmount(line.discount) * pending) / sourceQty)
+            }
+        }
         if (pending != null) line.max_quantity = pending
         else if (opts.kind === 'credit') line.max_quantity = hasValue(get('max_quantity')) ? toAmount(get('max_quantity')) : qty
         const sourceLine = r.source_line_id ?? r.id
@@ -384,7 +429,7 @@ export function localIssues(lines: LineItem[], opts: { requireLines?: boolean; r
             issues.push({
                 field: `lines.${i}`,
                 severity: 'error',
-                message: `Renglón ${i + 1}: la cantidad excede lo pendiente del documento origen (${l.max_quantity}).`,
+                message: `Renglón ${i + 1}: la cantidad excede lo pendiente del documento origen (quedan ${l.max_quantity}).`,
             })
         }
         if (opts.requireTax && toAmount(l.tax_rate) === 0) {