@asteby/metacore-runtime-react 49.2.1 → 49.3.0

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__/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) {

package/src/business/document-editor.tsx

@@ -48,6 +48,8 @@ import {
     splitEditorFields,
     toOpenDocuments,
     friendlyOptionLabel,
+    gatedOptionFixes,
+    gatedOptions,
     withFriendlyOptions,
     type EditorIssue,
     type SeedLabel,
@@ -215,6 +217,15 @@ export function DocumentEditor({
     const fieldKeys = useRef<string[]>([])
     fieldKeys.current = allFields.map((f) => f.key)
 
+    // Opciones condicionadas (`options[].when`): al cambiar el campo del que
+    // dependen —a mano, por la contraparte o por «Cargar desde…»— el valor que
+    // dejó de aplicar se ajusta solo (método PPD → forma de pago 99) y viaja así
+    // en el alta, no solo en el diálogo de timbrado.
+    useEffect(() => {
+        const fixes = gatedOptionFixes(allFields, header)
+        if (Object.keys(fixes).length > 0) setHeader((h) => ({ ...h, ...gatedOptionFixes(allFields, h) }))
+    }, [allFields, header])
+
     // Contraparte: tarjeta + defaults de las extensiones con la misma clave.
     const partyId = type.party ? header[type.party.field] : undefined
     useEffect(() => {
@@ -435,11 +446,11 @@ export function DocumentEditor({
                     setSourceNote(
                         loaded.length === 0 && covered > 0
                             ? t('documentEditor.source_all_covered', {
-                                  defaultValue: 'Todo el documento ya está registrado en otros documentos; no queda nada pendiente.',
+                                  defaultValue: 'Ese documento ya se registró completo; no queda nada pendiente.',
                               })
                             : covered > 0
                               ? t('documentEditor.source_loaded_partial', {
-                                    defaultValue: '{{count}} renglones con lo pendiente · {{covered}} ya cubiertos se omitieron',
+                                    defaultValue: '{{count}} renglones con lo que falta · {{covered}} ya completos (omitidos)',
                                     count: loaded.length,
                                     covered,
                                 })
@@ -579,7 +590,7 @@ export function DocumentEditor({
                 <FieldLabel htmlFor={field.key} required={field.required}>
                     {tl(field.label)}
                 </FieldLabel>
-                {renderField(withFriendlyOptions(field), header[field.key], (v: any) => updateField(field.key, v), header, fieldRecord, fieldErrors)}
+                {renderField(withFriendlyOptions(gatedOptions(field, header)), header[field.key], (v: any) => updateField(field.key, v), header, fieldRecord, fieldErrors)}
                 {fieldErrors[field.key] && <p className="mt-1 text-xs text-destructive">{fieldErrors[field.key]}</p>}
             </FieldCell>
         ) : null
@@ -654,7 +665,7 @@ export function DocumentEditor({
                 {sources.length > 1 && (
                     <div
                         role="radiogroup"
-                        aria-label={t('documentEditor.source_kind', { defaultValue: 'Tipo de documento origen' })}
+                        aria-label={t('documentEditor.source_kind', { defaultValue: 'Documento de origen' })}
                         className="inline-flex flex-wrap gap-1 rounded-md border p-1"
                     >
                         {sources.map((s) => (

package/src/dynamic-form-schema.ts

@@ -4,8 +4,13 @@
 import { z, type ZodTypeAny } from 'zod'
 import type { ActionFieldDef, FieldOptionsConfig, OptionDef, VisibleWhen } from './types'
 import { fieldValidationOf } from './validator'
+import { applyOptionWhen, getDependsOn } from './option-when'
 import { resolveValidatorToken } from './use-org-config-bridge'
 
+// Viven en option-when.ts (el validador también los usa); se re-exportan aquí
+// para no romper a quien los importaba de este módulo.
+export { applyOptionWhen, getDependsOn }
+
 /**
  * Built-in validators the SDK knows how to apply by symbolic name. Apps
  * that wire `OrgConfigProvider` map `$org.<key>` references to one of
@@ -389,18 +394,6 @@ export function fieldHasRef(field: ActionFieldDef): boolean {
     return getFieldRef(field) !== undefined
 }
 
-/**
- * Resolves a field's cascade dependency — the key of another form field whose
- * current value scopes this picker's options (`filter_value`). Tolerates the
- * camelCase `dependsOn` (authored SDK shape) and the snake_case `depends_on`
- * the kernel manifest serves. Returns the trimmed field key, or `undefined`
- * when the field declares no dependency.
- */
-export function getDependsOn(field: ActionFieldDef): string | undefined {
-    const dep = field.dependsOn ?? field.depends_on
-    if (typeof dep === 'string' && dep.trim() !== '') return dep.trim()
-    return undefined
-}
 
 /**
  * Resolves the cascade `filter_value` for a field from the surrounding form
@@ -424,49 +417,6 @@ export function resolveDependsValue(
     return String(raw)
 }
 
-/**
- * Filters a STATIC enum's `options[]` by each option's `when` gate against the
- * current form values. Pure — no React, no side effects.
- *
- * Rule per option:
- * - No `when` → always included (retrocompat; existing enums untouched).
- * - With `when`: the gating field is `when.field ?? dependsOn`. If neither is
- *   present the option is included (nothing to gate on). Otherwise the form's
- *   value for that field is compared AS STRING: included when (no `in`, or
- *   value ∈ `in`) AND (no `not_in`, or value ∉ `not_in`). Tolerates the
- *   snake_case `not_in` the kernel serves alongside camelCase `notIn`.
- *
- * `formValues` is the flat map of the surrounding form/row values the gating
- * field is read from; `dependsOn` is the containing field's declared dependency
- * used as the default gating field.
- */
-export function applyOptionWhen(
-    options: OptionDef[] | undefined,
-    formValues: Record<string, any> | null | undefined,
-    dependsOn?: string,
-): OptionDef[] {
-    if (!Array.isArray(options)) return []
-    return options.filter((opt) => {
-        const when = opt?.when
-        if (!when) return true
-        const gate = (typeof when.field === 'string' && when.field.trim() !== '')
-            ? when.field.trim()
-            : dependsOn
-        if (!gate) return true
-        const raw = formValues ? formValues[gate] : undefined
-        const current = raw == null ? '' : String(raw)
-        const inList = when.in
-        const notIn = when.notIn ?? when.not_in
-        if (Array.isArray(inList) && inList.length > 0) {
-            if (!inList.some((v) => String(v) === current)) return false
-        }
-        if (Array.isArray(notIn) && notIn.length > 0) {
-            if (notIn.some((v) => String(v) === current)) return false
-        }
-        return true
-    })
-}
-
 /**
  * Reads a field's `visible_when` predicate, tolerating the camelCase alias
  * (`visibleWhen`) an app may author and the snake_case (`visible_when`) the

package/src/option-when.ts

@@ -0,0 +1,61 @@
+// option-when.ts — opciones estáticas de un select condicionadas por el valor
+// de un campo hermano (`options[].when`) y la dependencia declarada del campo
+// (`dependsOn`). Módulo hoja: lo usan el formulario (dynamic-form-schema), el
+// render compartido de campos (renderField) y el validador, sin ciclos.
+import type { ActionFieldDef, OptionDef } from './types'
+
+/**
+ * Resolves a field's cascade dependency — the key of another form field whose
+ * current value scopes this picker's options (`filter_value`). Tolerates the
+ * camelCase `dependsOn` (authored SDK shape) and the snake_case `depends_on`
+ * the kernel manifest serves. Returns the trimmed field key, or `undefined`
+ * when the field declares no dependency.
+ */
+export function getDependsOn(field: ActionFieldDef): string | undefined {
+    const dep = field.dependsOn ?? field.depends_on
+    if (typeof dep === 'string' && dep.trim() !== '') return dep.trim()
+    return undefined
+}
+
+/**
+ * Filters a STATIC enum's `options[]` by each option's `when` gate against the
+ * current form values. Pure — no React, no side effects.
+ *
+ * Rule per option:
+ * - No `when` → always included (retrocompat; existing enums untouched).
+ * - With `when`: the gating field is `when.field ?? dependsOn`. If neither is
+ *   present the option is included (nothing to gate on). Otherwise the form's
+ *   value for that field is compared AS STRING: included when (no `in`, or
+ *   value ∈ `in`) AND (no `not_in`, or value ∉ `not_in`). Tolerates the
+ *   snake_case `not_in` the kernel serves alongside camelCase `notIn`.
+ *
+ * `formValues` is the flat map of the surrounding form/row values the gating
+ * field is read from; `dependsOn` is the containing field's declared dependency
+ * used as the default gating field.
+ */
+export function applyOptionWhen(
+    options: OptionDef[] | undefined,
+    formValues: Record<string, any> | null | undefined,
+    dependsOn?: string,
+): OptionDef[] {
+    if (!Array.isArray(options)) return []
+    return options.filter((opt) => {
+        const when = opt?.when
+        if (!when) return true
+        const gate = (typeof when.field === 'string' && when.field.trim() !== '')
+            ? when.field.trim()
+            : dependsOn
+        if (!gate) return true
+        const raw = formValues ? formValues[gate] : undefined
+        const current = raw == null ? '' : String(raw)
+        const inList = when.in
+        const notIn = when.notIn ?? when.not_in
+        if (Array.isArray(inList) && inList.length > 0) {
+            if (!inList.some((v) => String(v) === current)) return false
+        }
+        if (Array.isArray(notIn) && notIn.length > 0) {
+            if (notIn.some((v) => String(v) === current)) return false
+        }
+        return true
+    })
+}