@asteby/metacore-runtime-react 49.2.0 → 49.3.0

package/src/__tests__/r6-editor-source-seeds.test.tsx

@@ -0,0 +1,137 @@
+// @vitest-environment happy-dom
+// Retest Pitsline r6 (P0 UX): «Cargar desde» venta/OT/cotización debe dejar el
+// CLIENTE elegido (su nombre en el selector y su tarjeta), aunque los renglones
+// del origen fallen; y el selector «Factura a abonar» de la NC abierta desde una
+// factura muestra el folio, no el UUID. El selector es el dynamic_select real
+// (cerrado: no consulta opciones), así que la etiqueta sale de lo que el editor
+// ya sabe del registro.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, 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>) => {
+            let s: string = o?.defaultValue ?? k
+            for (const [key, v] of Object.entries(o ?? {})) s = s.replace(`{{${key}}}`, String(v))
+            return s
+        },
+        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 { seedRecord, sourceHeaderSeeds } from '../business/document-editor-model'
+import type { DocumentFormsManifest, DocumentFormType } from '../types'
+
+afterEach(cleanup)
+
+const CUSTOMER = '6f1c2a9e-3b7d-4c55-9a51-0d2b8e7f4a10'
+const INVOICE = '0b9d7c1e-5a4f-4e2b-8c3d-7f6e5d4c3b2a'
+
+const invoice: DocumentFormType = {
+    key: 'invoice',
+    label: 'Factura',
+    layout: 'editor',
+    party: { field: 'customer_id', model: 'customers.Customer', summary: ['tax_id'] },
+    fields: [
+        { key: 'customer_id', label: 'Cliente', type: 'dynamic_select', ref: 'customers.Customer', required: true } as any,
+        { key: 'work_order_id', label: 'Orden de trabajo', type: 'dynamic_select', ref: 'workshop.WorkOrder' } as any,
+    ],
+    lines: { title: 'Renglones' },
+    sources: [
+        { key: 'work_order', label: 'Orden de trabajo', model: 'workshop.WorkOrder', lines: 'items', header: { customer_id: 'customer_id' }, link_field: 'work_order_id', line_link_field: 'work_order_item_id' },
+    ],
+    submit_label: 'Crear factura',
+}
+
+const creditNote: DocumentFormType = {
+    key: 'credit_note',
+    label: 'Nota de crédito',
+    layout: 'editor',
+    fields: [
+        { key: 'invoice_id', label: 'Factura a abonar', type: 'dynamic_select', ref: 'customers.Invoice', required: true, options: { source: 'customers.Invoice', value: 'id', label: 'number' } } as any,
+    ],
+    lines: { kind: 'credit', title: 'Conceptos' },
+    sources: [{ key: 'invoice', label: 'Factura', model: 'customers.Invoice', lines: 'items', link_field: 'invoice_id', line_link_field: 'invoice_item_id' }],
+    submit_label: 'Crear nota de crédito',
+}
+
+function makeApi(rows: Record<string, unknown[]>) {
+    const get = vi.fn(async (url: string) => {
+        if (url === '/data/customers.Customer') return { data: { data: [{ id: CUSTOMER, name: 'Transportes del Bajío', tax_id: 'TBA850312KJ9' }] } }
+        if (url.startsWith('/data/')) return { data: { data: rows[url.slice(6)] ?? [] } }
+        // Los renglones del origen no cargan (host sin source-lines ni relación).
+        if (url.endsWith('/source-lines') || url.startsWith('/metadata/table/')) throw new Error('boom')
+        return { data: { data: [] } }
+    })
+    const client = { get, post: vi.fn(), put: vi.fn(), delete: vi.fn() }
+    return client as unknown as ApiClient
+}
+
+function open(model: string, type: DocumentFormType, api: ApiClient, initialSource: { key: string; id: string }) {
+    const forms: DocumentFormsManifest = { lines_field: 'items', types: [type] }
+    return render(
+        <ApiProvider client={api}>
+            <TaxRateContext.Provider value={0.16}>
+                <DocumentFormDialog open onOpenChange={() => {}} model={model} forms={forms} initialType={type.key} initialSource={initialSource} currency="MXN" />
+            </TaxRateContext.Provider>
+        </ApiProvider>,
+    )
+}
+
+const trigger = (key: string) => document.getElementById(key) as HTMLElement
+
+describe('«Cargar desde» llena el cliente', () => {
+    it('OT: el selector muestra el cliente por nombre y su tarjeta carga aunque los renglones fallen', async () => {
+        const api = makeApi({ 'workshop.WorkOrder': [{ id: 'wo-1', order_number: 'OT-00031', customer_id: CUSTOMER }] })
+        open('customers.Invoice', invoice, api, { key: 'work_order', id: 'wo-1' })
+        await waitFor(() => expect(trigger('customer_id').textContent).toContain('Transportes del Bajío'))
+        expect(trigger('customer_id').textContent).not.toContain(CUSTOMER)
+        expect(document.querySelector('[data-slot="party-card"]')).toBeTruthy()
+        expect(trigger('work_order_id').textContent).toContain('OT-00031')
+    })
+
+    it('el nombre del cliente que el host sirve junto a la FK se usa de inmediato', async () => {
+        const api = makeApi({
+            'workshop.WorkOrder': [{ id: 'wo-1', customer_id: CUSTOMER, customer: { value: CUSTOMER, label: 'Transportes del Bajío' } }],
+        })
+        open('customers.Invoice', invoice, api, { key: 'work_order', id: 'wo-1' })
+        await waitFor(() => expect(trigger('customer_id').textContent).toContain('Transportes del Bajío'))
+    })
+})
+
+describe('NC desde la factura', () => {
+    it('«Factura a abonar» muestra el folio, no el UUID', async () => {
+        const api = makeApi({ 'customers.Invoice': [{ id: INVOICE, number: 'FAC-00014', customer_id: CUSTOMER }] })
+        open('fiscal_mexico.CreditNote', creditNote, api, { key: 'invoice', id: INVOICE })
+        await waitFor(() => expect(trigger('invoice_id').textContent).toContain('FAC-00014'))
+        expect(trigger('invoice_id').textContent).not.toContain(INVOICE)
+        expect(screen.queryByText(INVOICE)).toBeNull()
+    })
+})
+
+describe('reglas puras', () => {
+    it('sourceHeaderSeeds: hermano {value,label} de la FK y folio del origen', () => {
+        const seeds = sourceHeaderSeeds(
+            invoice.sources![0],
+            { id: 'wo-1', order_number: 'OT-7', customer_id: 'c-1', customer: { value: 'c-1', label: 'Ana' } },
+            'wo-1',
+            invoice.fields,
+        )
+        expect(seeds).toEqual({ customer_id: { value: 'c-1', label: 'Ana' }, work_order_id: { value: 'wo-1', label: 'OT-7' } })
+        expect(sourceHeaderSeeds(invoice.sources![0], { id: 'wo-1', customer_id: 'c-1' }, 'wo-1')).toEqual({})
+    })
+
+    it('seedRecord: siembra el hermano y conserva el registro de origen', () => {
+        expect(seedRecord({}, undefined)).toBeUndefined()
+        expect(seedRecord({ customer_id: { value: 'c-1', label: 'Ana' } }, { id: 'inv-1', number: 'F-1' })).toEqual({
+            id: 'inv-1',
+            number: 'F-1',
+            customer: { value: 'c-1', label: 'Ana' },
+        })
+    })
+})

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

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

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
@@ -292,6 +337,74 @@ export function sourceTracksRemaining(src: Pick<DocumentFormSource, 'line_link_f
     return !!(src.line_link_field || src.remaining_qty_field || src.remaining_endpoint)
 }
 
+/** Opción ya resuelta de un selector de la cabecera que el editor llenó por código. */
+export interface SeedLabel {
+    value: string
+    label: string
+}
+
+/** Columnas con las que se nombra un documento (folio antes que nombre). */
+const DOCUMENT_LABEL_COLUMNS = ['number', 'folio', 'order_number', 'name', 'title', 'code']
+
+function declaredOptionLabel(f: ActionFieldDef | undefined): string | undefined {
+    const opts = (f as { options?: unknown } | undefined)?.options
+    const l = opts && !Array.isArray(opts) && typeof opts === 'object' ? (opts as { label?: unknown }).label : undefined
+    return typeof l === 'string' && l ? l : undefined
+}
+
+/** Nombre visible de un registro: la columna declarada por el campo, luego folio/nombre. */
+export function recordLabel(rec: Record<string, any> | null | undefined, preferred?: string): string | undefined {
+    if (!rec) return undefined
+    for (const c of preferred ? [preferred, ...DOCUMENT_LABEL_COLUMNS] : DOCUMENT_LABEL_COLUMNS) {
+        const v = rec[c]
+        if ((typeof v === 'string' && v.trim()) || typeof v === 'number') return String(v)
+    }
+    return undefined
+}
+
+/**
+ * Etiquetas de lo que «Cargar desde…» escribe en la cabecera, para que el
+ * selector muestre el nombre y no el UUID sin abrirse:
+ *  - `header` (`customer_id ← customer_id`): el objeto hermano `{value,label}`
+ *    que el host sirve junto a la FK (`customer`);
+ *  - `link_field`: el propio documento origen, con su folio.
+ */
+export function sourceHeaderSeeds(
+    src: Pick<DocumentFormSource, 'header' | 'link_field'>,
+    rec: Record<string, any>,
+    id: string,
+    fields: readonly ActionFieldDef[] = [],
+): Record<string, SeedLabel> {
+    const out: Record<string, SeedLabel> = {}
+    for (const [to, from] of Object.entries(src.header ?? {})) {
+        if (!from.endsWith('_id')) continue
+        const v = refValue(rec[from])
+        const label = refLabel(rec[from]) ?? refLabel(rec[from.slice(0, -3)])
+        if (v && label) out[to] = { value: v, label }
+    }
+    if (src.link_field) {
+        const label = recordLabel(rec, declaredOptionLabel(fields.find((f) => f.key === src.link_field)))
+        if (label) out[src.link_field] = { value: id, label }
+    }
+    return out
+}
+
+/**
+ * Registro para `renderField` con las etiquetas sembradas como objeto hermano
+ * (`customer_id` → `customer: {value,label}`), el mismo contrato que sirve el
+ * host en una fila. Conserva el registro desde el que se abrió.
+ */
+export function seedRecord(
+    seeds: Record<string, SeedLabel>,
+    record?: Record<string, any>,
+): Record<string, any> | undefined {
+    const keys = Object.keys(seeds).filter((k) => k.endsWith('_id'))
+    if (keys.length === 0) return record
+    const out: Record<string, any> = { ...(record ?? {}) }
+    for (const k of keys) out[k.slice(0, -3)] = seeds[k]
+    return out
+}
+
 export interface EditorIssue {
     field?: string
     severity: 'error' | 'warning'
@@ -316,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

@@ -42,11 +42,17 @@ import {
     sourceTracksRemaining,
     partyDefaults,
     partySummaryRows,
+    recordLabel,
+    seedRecord,
+    sourceHeaderSeeds,
     splitEditorFields,
     toOpenDocuments,
     friendlyOptionLabel,
+    gatedOptionFixes,
+    gatedOptions,
     withFriendlyOptions,
     type EditorIssue,
+    type SeedLabel,
 } from './document-editor-model'
 import {
     CollapsibleSection,
@@ -140,6 +146,9 @@ export function DocumentEditor({
     const [extFields, setExtFields] = useState<ActionFieldDef[]>([])
     const [party, setParty] = useState<Record<string, any> | null>(null)
     const [partyLabels, setPartyLabels] = useState<Record<string, string>>({})
+    // Etiquetas de los selectores que el editor llena por código (contraparte y
+    // documento origen de «Cargar desde…»): sin ellas el selector cerrado pinta el UUID.
+    const [seeds, setSeeds] = useState<Record<string, SeedLabel>>({})
     const [openDocs, setOpenDocs] = useState<OpenDocument[]>([])
     const [docsLoading, setDocsLoading] = useState(false)
     const [alloc, setAlloc] = useState<PaymentAllocatorValue>({ strategy: 'oldest_due_first', manual: {} })
@@ -159,6 +168,7 @@ export function DocumentEditor({
     // renglón para que el servidor descuente lo ya facturado/devuelto y valide.
     const [loadedSource, setLoadedSource] = useState<DocumentFormSource | null>(null)
     const [sourceNote, setSourceNote] = useState<string | undefined>()
+    const [sourceSeed, setSourceSeed] = useState<SeedLabel | null>(null)
     const relCache = useRef(new Map<string, Promise<any[]>>())
 
     const taxRate = defaultTaxRate ?? orgTaxRate
@@ -207,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(() => {
@@ -223,6 +242,11 @@ export function DocumentEditor({
                 if (cancelled) return
                 setParty(rec)
                 setHeader((h) => ({ ...h, ...partyDefaults(rec, fieldKeys.current, h) }))
+                const label = recordLabel(rec, 'name') ?? recordLabel(rec, 'legal_name')
+                if (label && type.party) {
+                    const key = type.party.field
+                    setSeeds((s) => ({ ...s, [key]: { value: String(partyId), label } }))
+                }
             })
             .catch(() => !cancelled && setParty(null))
         return () => {
@@ -392,6 +416,26 @@ export function DocumentEditor({
             if (!lineCfg || !id) return
             setBusy('source')
             try {
+                // Cabecera primero (cliente, moneda, vínculo): llega aunque los
+                // renglones del origen fallen, y la tarjeta del cliente se carga.
+                if (src.header || src.link_field) {
+                    const h = await api.get(`/data/${src.model}`, { params: { f_id: `eq:${id}`, per_page: 1 } })
+                    const rec = ((h?.data?.data ?? [])[0] ?? {}) as Record<string, any>
+                    setHeader((prev) => {
+                        const next = { ...prev }
+                        for (const [to, from] of Object.entries(src.header ?? {})) {
+                            const v = rec[from]
+                            if (v == null || v === '') continue
+                            next[to] = typeof v === 'object' && !Array.isArray(v) ? v.value ?? v.id ?? v : v
+                        }
+                        if (src.link_field) next[src.link_field] = id
+                        return next
+                    })
+                    const seeded = sourceHeaderSeeds(src, rec, id, type.fields)
+                    setSeeds((s) => ({ ...s, ...seeded }))
+                    const label = src.link_field ? seeded[src.link_field]?.label : recordLabel(rec)
+                    setSourceSeed(label ? { value: id, label } : null)
+                }
                 if (!isAllocation) {
                     const rows = await fetchSourceRows(src, id)
                     const loaded = linesFromSource(rows, src.map, { kind, discountMode: lineCfg.discount_mode, defaultTaxRate: taxRate })
@@ -402,27 +446,17 @@ 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,
                                 })
                               : t('documentEditor.source_loaded', { defaultValue: '{{count}} renglones cargados', count: loaded.length }),
                     )
                 }
-                if (src.header || src.link_field) {
-                    const h = await api.get(`/data/${src.model}`, { params: { f_id: `eq:${id}`, per_page: 1 } })
-                    const rec = ((h?.data?.data ?? [])[0] ?? {}) as Record<string, any>
-                    setHeader((prev) => {
-                        const next = { ...prev }
-                        for (const [to, from] of Object.entries(src.header ?? {})) if (rec[from] != null) next[to] = rec[from]
-                        if (src.link_field) next[src.link_field] = id
-                        return next
-                    })
-                }
                 setServerIssues([])
             } catch (err) {
                 toast.error(t('documentEditor.source_failed', { defaultValue: 'No se pudo cargar el documento' }), {
@@ -432,7 +466,7 @@ export function DocumentEditor({
                 setBusy(null)
             }
         },
-        [api, lineCfg, isAllocation, kind, t, fetchSourceRows, taxRate],
+        [api, lineCfg, isAllocation, kind, t, fetchSourceRows, taxRate, type.fields],
     )
 
     // Prefill al abrir desde un documento origen (acción de fila «Crear NC», «Facturar venta»…).
@@ -549,13 +583,14 @@ export function DocumentEditor({
         setFieldErrors((prev) => clearFieldErrorTree(prev, key))
     }
 
+    const fieldRecord = useMemo(() => seedRecord(seeds, record), [seeds, record])
     const fieldCell = (field: ActionFieldDef, fullWidth = false) =>
         visible(field) ? (
             <FieldCell key={field.key} fullWidth={fullWidth}>
                 <FieldLabel htmlFor={field.key} required={field.required}>
                     {tl(field.label)}
                 </FieldLabel>
-                {renderField(withFriendlyOptions(field), header[field.key], (v: any) => updateField(field.key, v), header, undefined, 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
@@ -569,7 +604,7 @@ export function DocumentEditor({
         .map((f) => {
             const v = header[f.key]
             if (v == null || v === '') return null
-            const opt = f.options?.find((o) => String(o.value) === String(v))
+            const opt = Array.isArray(f.options) ? f.options.find((o) => String(o.value) === String(v)) : undefined
             return opt ? String(opt.value) : String(v)
         })
         .filter(Boolean)
@@ -630,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) => (
@@ -658,6 +693,7 @@ export function DocumentEditor({
                         key={activeSource.key}
                         source={activeSource}
                         value={sourceId}
+                        seed={sourceSeed}
                         header={header}
                         label={tl(activeSource.label)}
                         onPick={(id) => {
@@ -769,8 +805,9 @@ export function DocumentEditor({
                     .filter(visible)
                     .map((f) => {
                         const v = header[f.key]
-                        const opt = f.options?.find((o) => String(o.value) === String(v))
-                        return { label: tl(f.label), value: v == null || v === '' ? '' : opt ? friendlyOptionLabel(tl(String(opt.label ?? v))) : String(v) }
+                        const opt = Array.isArray(f.options) ? f.options.find((o) => String(o.value) === String(v)) : undefined
+                        const seeded = seeds[f.key] && String(seeds[f.key].value) === String(v) ? seeds[f.key].label : undefined
+                        return { label: tl(f.label), value: v == null || v === '' ? '' : opt ? friendlyOptionLabel(tl(String(opt.label ?? v))) : seeded ?? String(v) }
                     })
                     .filter((r) => r.value)}
                 lines={lines}
@@ -835,12 +872,15 @@ export function DocumentEditor({
 function SourcePicker({
     source,
     value,
+    seed,
     header,
     label,
     onPick,
 }: {
     source: DocumentFormSource
     value: string
+    /** Folio del origen ya cargado: el selector cerrado lo muestra en vez del UUID. */
+    seed?: SeedLabel | null
     header: Record<string, any>
     label: string
     onPick: (id: string) => void
@@ -858,7 +898,7 @@ function SourcePicker({
     )
     return (
         <div className="min-w-[240px] flex-1" data-source={source.key}>
-            {renderField(field, value, (v: any) => onPick(v == null || v === '' ? '' : String(v)), header)}
+            {renderField(field, value, (v: any) => onPick(v == null || v === '' ? '' : String(v)), header, seed ? { id: seed.value, label: seed.label } : undefined)}
         </div>
     )
 }

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