@asteby/metacore-runtime-react 47.0.0 → 48.0.0

package/src/dynamic-crud-page.tsx

@@ -33,7 +33,7 @@ import { useApi } from './api-context'
 import { useMetadataCache } from './metadata-cache'
 import { DynamicTable } from './dynamic-table'
 import { DynamicRecordDialog } from './dialogs/dynamic-record'
-import { DocumentFormDialog, resolveDocumentForms } from './document-form-dialog'
+import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from './document-form-dialog'
 import { ExportDialog } from './dialogs/export'
 import { ImportDialog } from './dialogs/import'
 import { getModelExtension } from './model-extension-registry'
@@ -96,6 +96,12 @@ export interface DynamicCRUDPageProps {
      * with neither, the generic record dialog is used as before.
      */
     documentForms?: DocumentFormsManifest
+    /**
+     * Filtro fijo de la vista (el `filter` del nav). Si va sobre el `type_field`
+     * del alta guiada, «Crear» abre ese tipo directo o se oculta cuando no hay
+     * formulario para él.
+     */
+    filter?: Record<string, string>
 }
 
 /**
@@ -119,6 +125,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
         classes,
         onChange,
         documentForms,
+        filter,
     } = props
 
     const strings = { ...defaultStrings, ...(i18n ?? {}) }
@@ -189,11 +196,22 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
     // (useCan defaults to always-true), in which case create/export/import
     // require `lowercase(model).create|export|import`.
     const can = useCan()
-    const showCreate = primary.showGenericCreate && can(modelCapability(model, 'create'))
+    const scoped = scopeDocumentFormsToFilter(resolveDocumentForms(metadata, documentForms), filter)
+    const guidedForms = scoped.forms
+    const showCreate = primary.showGenericCreate && !scoped.hideCreate && can(modelCapability(model, 'create'))
     const showImport = enableCRUD && !effectiveHideImport && can(modelCapability(model, 'import'))
     const showExport = !effectiveHideExport && can(modelCapability(model, 'export'))
     const showRefresh = !effectiveHideRefresh
-    const guidedForms = resolveDocumentForms(metadata, documentForms)
+
+    // El mismo filtro acota la tabla (forma `eq:<valor>` que espera DynamicTable).
+    const filterKey = filter ? JSON.stringify(filter) : ''
+    const tableFilters = useMemo(() => {
+        if (!filter || Object.keys(filter).length === 0) return undefined
+        return Object.fromEntries(
+            Object.entries(filter).map(([k, v]) => [k, String(v).includes(':') ? String(v) : `eq:${v}`]),
+        )
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [filterKey])
 
     const handleRefresh = useCallback(() => {
         setRefreshKey((k) => k + 1)
@@ -278,6 +296,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
                         model={model}
                         endpoint={dataEndpoint}
                         refreshTrigger={refreshKey}
+                        defaultFilters={tableFilters}
                     />
                 </div>
             </div>

package/src/dynamic-form-schema.ts

@@ -107,12 +107,25 @@ export function computeLineItemTotals(
     field: ActionFieldDef,
     rows: any[] | undefined,
 ): Record<string, number> {
-    const cols = getItemFields(field).filter((c) => c.total)
+    const itemFields = getItemFields(field)
+    const cols = itemFields.filter((c) => c.total)
+    // A `total` UNIT PRICE column on a grid with a quantity and no line amount
+    // column sums the line amounts (qty × price − discount): adding unit prices
+    // is meaningless once a quantity exists (2 × 750 footed 750, not 1500).
+    const qtyKey = firstKey(itemFields, LINE_QTY_KEYS)
+    const lineValued = !!qtyKey && !firstKey(itemFields, LINE_AMOUNT_KEYS)
+    const discountKey = firstKey(itemFields, LINE_DISCOUNT_KEYS)
     const totals: Record<string, number> = {}
     for (const c of cols) totals[c.key] = 0
     if (Array.isArray(rows)) {
         for (const row of rows) {
-            for (const c of cols) totals[c.key] += toNumber(row?.[c.key])
+            for (const c of cols) {
+                const v = toNumber(row?.[c.key])
+                totals[c.key] +=
+                    lineValued && LINE_PRICE_KEYS.has(c.key)
+                        ? toNumber(row?.[qtyKey!]) * v - (discountKey ? toNumber(row?.[discountKey]) : 0)
+                        : v
+            }
         }
     }
     for (const k of Object.keys(totals)) totals[k] = Math.round(totals[k] * 100) / 100

package/src/dynamic-form.tsx

@@ -1,7 +1,7 @@
 // Minimal standalone DynamicForm. Factored from the dynamic-record-dialog
 // pattern + ActionFieldDef renderer so callers can reuse the form layout
 // outside the full record-edit modal.
-import { useEffect, useMemo, useState } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
 import { groupFieldsBySection, type FormLayout } from './form-layout'
 import { FieldSection, WizardProgress } from './form-layout-ui'
 import { AssistInterview } from './assist-interview'
@@ -30,6 +30,7 @@ import {
 } from './dynamic-form-schema'
 import { ScanLine } from 'lucide-react'
 import { BarcodeScanner } from './barcode-scanner'
+import { getOptionFilter } from './option-filter'
 import { useOptionsResolver, type ResolvedOption } from './use-options-resolver'
 import { DynamicLineItems } from './dynamic-line-items'
 import { DynamicSelectField } from './dynamic-select-field'
@@ -64,8 +65,35 @@ export interface DynamicFormProps {
      * legacy flat list (unchanged).
      */
     formLayout?: FormLayout
+    /**
+     * Para formularios dentro de un modal con alto acotado: el cuerpo de campos
+     * hace scroll propio y la barra de botones (Guardar/Cancelar) queda fija
+     * abajo, así nunca queda fuera de pantalla con muchos campos. El contenedor
+     * debe ser flex-col con alto máximo (p.ej. `max-h-[90dvh]`).
+     */
+    scrollableBody?: boolean
 }
 
+// Valores iniciales del formulario: el registro (edición) gana sobre el default
+// del campo. Se calcula de forma síncrona en el primer render para que ningún
+// widget (p.ej. un Select de Radix) monte con '' y emita un cambio espurio que
+// pise el valor real del registro.
+function seedValues(fields: ActionFieldDef[], initialValues?: Record<string, any>): Record<string, any> {
+    const defaults: Record<string, any> = {}
+    for (const f of fields) {
+        if (isLineItemsField(f)) {
+            defaults[f.key] = initialValues?.[f.key] ?? f.defaultValue ?? []
+            continue
+        }
+        defaults[f.key] = initialValues?.[f.key] ?? f.defaultValue ?? (f.type === 'boolean' ? false : '')
+    }
+    return defaults
+}
+
+const isReadonlyField = (f: ActionFieldDef) =>
+    !!(f as { readonly?: boolean; readOnly?: boolean }).readonly ||
+    !!(f as { readonly?: boolean; readOnly?: boolean }).readOnly
+
 export function DynamicForm({
     fields,
     initialValues,
@@ -75,8 +103,8 @@ export function DynamicForm({
     cancelLabel = 'Cancelar',
     disabled = false,
     formLayout,
+    scrollableBody = false,
 }: DynamicFormProps) {
-    const [values, setValues] = useState<Record<string, any>>({})
     const [errors, setErrors] = useState<Record<string, string>>({})
     const [submitting, setSubmitting] = useState(false)
 
@@ -86,10 +114,15 @@ export function DynamicForm({
     // (ColumnDef.Readonly). They are also excluded from defaults/submit so a
     // create never posts e.g. `status: ""` over the column default.
     const editableFields = useMemo(
-        () => fields.filter((f) => !(f as { readonly?: boolean }).readonly),
+        () => fields.filter((f) => !isReadonlyField(f)),
         [fields],
     )
 
+    const [values, setValues] = useState<Record<string, any>>(() => seedValues(editableFields, initialValues))
+    // Campos que el usuario (o un reset dependiente) cambió desde la siembra.
+    // En edición, un select que sigue vacío y nadie tocó no viaja en el PATCH.
+    const touched = useRef<Set<string>>(new Set())
+
     // Conditional visibility: a field carrying `visible_when` is rendered — and
     // validated — only while the referenced sibling field's current value
     // matches the predicate. Driving BOTH the schema and the render off the same
@@ -132,21 +165,22 @@ export function DynamicForm({
         setStepIndex((i) => Math.min(i, Math.max(groups.length - 1, 0)))
     }, [groups.length])
 
+    // Re-siembra cuando cambia el registro o los campos DESPUÉS del montaje (el
+    // primer render ya quedó sembrado por el inicializador de useState).
+    const seededFrom = useRef({ editableFields, initialValues })
     useEffect(() => {
-        const defaults: Record<string, any> = {}
-        for (const f of editableFields) {
-            if (isLineItemsField(f)) {
-                defaults[f.key] = initialValues?.[f.key] ?? f.defaultValue ?? []
-                continue
-            }
-            defaults[f.key] = initialValues?.[f.key] ?? f.defaultValue ?? (f.type === 'boolean' ? false : '')
-        }
-        setValues(defaults)
+        const prev = seededFrom.current
+        if (prev.editableFields === editableFields && prev.initialValues === initialValues) return
+        seededFrom.current = { editableFields, initialValues }
+        touched.current = new Set()
+        setValues(seedValues(editableFields, initialValues))
         setErrors({})
     }, [editableFields, initialValues])
 
-    const update = (k: string, v: any) =>
+    const update = (k: string, v: any) => {
+        touched.current.add(k)
         setValues((prev: Record<string, any>) => ({ ...prev, [k]: v }))
+    }
 
     const handleSubmit = async (e: React.FormEvent) => {
         e.preventDefault()
@@ -162,8 +196,19 @@ export function DynamicForm({
             return
         }
         setErrors({})
+        const data = { ...(result.data as Record<string, any>) }
+        // Edición: un select vacío que el usuario no tocó no se manda — el update
+        // es parcial, así que omitirlo conserva lo que tenga el registro en vez de
+        // pisarlo con ''.
+        if (initialValues) {
+            for (const f of visibleFields) {
+                if (resolveWidget(f) !== 'select') continue
+                if (touched.current.has(f.key)) continue
+                if (data[f.key] === '' || data[f.key] == null) delete data[f.key]
+            }
+        }
         setSubmitting(true)
-        try { await onSubmit(result.data as Record<string, any>) } finally { setSubmitting(false) }
+        try { await onSubmit(data) } finally { setSubmitting(false) }
     }
 
     // Renders one group's fields into the responsive 2-column grid: scalar
@@ -185,6 +230,11 @@ export function DynamicForm({
         </div>
     )
 
+    // scrollableBody: el cuerpo hace scroll y el footer de botones queda fijo.
+    const formClass = scrollableBody ? 'flex min-h-0 flex-1 flex-col gap-4' : 'grid gap-4'
+    const bodyClass = scrollableBody ? '-mx-1 grid min-h-0 flex-1 gap-4 overflow-y-auto px-1' : 'grid gap-4'
+    const footerExtra = scrollableBody ? ' shrink-0 border-t' : ''
+
     // ── Steps (wizard) mode ────────────────────────────────────────────────
     // One step per section; Anterior/Siguiente navigate, submit only on the
     // last step. Advancing validates just the current step's fields so a later
@@ -211,20 +261,22 @@ export function DynamicForm({
         const goBack = () => setStepIndex((i) => Math.max(i - 1, 0))
 
         return (
-            <form onSubmit={handleSubmit} className="grid gap-4">
-                <WizardProgress groups={groups} stepIndex={stepIndex} onStepClick={i => setStepIndex(i)} />
-                {step.assist ? (
-                    <AssistInterview
-                        assist={step.assist}
-                        values={values}
-                        eyebrow={step.title}
-                        autoStart={step.assist.trigger !== 'button'}
-                        onApply={fields => setValues(prev => ({ ...prev, ...fields }))}
-                    />
-                ) : (
-                    renderGrid(step.fields)
-                )}
-                <div className="flex justify-between gap-2 pt-2">
+            <form onSubmit={handleSubmit} className={formClass}>
+                <div className={bodyClass}>
+                    <WizardProgress groups={groups} stepIndex={stepIndex} onStepClick={i => setStepIndex(i)} />
+                    {step.assist ? (
+                        <AssistInterview
+                            assist={step.assist}
+                            values={values}
+                            eyebrow={step.title}
+                            autoStart={step.assist.trigger !== 'button'}
+                            onApply={fields => setValues(prev => ({ ...prev, ...fields }))}
+                        />
+                    ) : (
+                        renderGrid(step.fields)
+                    )}
+                </div>
+                <div className={'flex justify-between gap-2 pt-2' + footerExtra}>
                     {stepIndex > 0 ? (
                         <Button type="button" variant="outline" onClick={goBack} disabled={submitting || disabled}>
                             Anterior
@@ -257,13 +309,15 @@ export function DynamicForm({
     // stays fully declarative — driven only by field shape. With no layout this
     // is a single default group rendered without section chrome (unchanged).
     return (
-        <form onSubmit={handleSubmit} className="grid gap-4">
-            {groups.map((group) => (
-                <FieldSection key={group.key} group={group}>
-                    {renderGrid(group.fields)}
-                </FieldSection>
-            ))}
-            <div className="flex justify-end gap-2 pt-2">
+        <form onSubmit={handleSubmit} className={formClass}>
+            <div className={bodyClass}>
+                {groups.map((group) => (
+                    <FieldSection key={group.key} group={group}>
+                        {renderGrid(group.fields)}
+                    </FieldSection>
+                ))}
+            </div>
+            <div className={'flex justify-end gap-2 pt-2' + footerExtra}>
                 {onCancel && (
                     <Button type="button" variant="outline" onClick={onCancel} disabled={submitting || disabled}>
                         {cancelLabel}
@@ -427,15 +481,17 @@ function FieldRenderer({
                     onChange={onChange}
                 />
             )
-        case 'select':
+        case 'select': {
+            const opts = effectiveOptions ?? field.options
             return (
-                <Select value={value || ''} onValueChange={onChange}>
+                <Select value={value || ''} onValueChange={guardEmptySelect(value, onChange, (opts ?? []).map((o) => o.value))}>
                     <SelectTrigger className="w-full"><SelectValue placeholder={field.placeholder || 'Seleccionar...'} /></SelectTrigger>
                     <SelectContent>
-                        {(effectiveOptions ?? field.options)?.map((opt) => <SelectItem key={opt.value} value={opt.value}>{opt.label}</SelectItem>)}
+                        {opts?.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':
@@ -525,14 +581,39 @@ function ScannableInput({
     )
 }
 
+/**
+ * Radix Select puede emitir `onValueChange('')` sin interacción del usuario (su
+ * <select> nativo oculto colapsa a '' si recibe el valor antes que sus
+ * <option>s, p.ej. dentro de un <form> en el primer render). Ese '' pisaría el
+ * valor real del registro y viajaría en el PATCH. Se ignora cuando ya hay un
+ * valor y '' no es una opción válida — el usuario nunca puede elegir '' así.
+ */
+export function guardEmptySelect(
+    current: unknown,
+    onChange: (v: any) => void,
+    optionValues: readonly unknown[],
+): (v: string) => void {
+    return (v: string) => {
+        const hasValue = current !== undefined && current !== null && current !== ''
+        if (v === '' && hasValue && !optionValues.some((o) => String(o) === '')) return
+        onChange(v)
+    }
+}
+
 function RefSelect({ field, value, onChange }: FieldRendererProps) {
     const { options, loading } = useOptionsResolver({
         modelKey: '',          // unused — `ref` drives the URL
         fieldKey: 'id',
         ref: field.ref,
+        optionFilter: getOptionFilter(field),
+        keepValue: value,
     })
     return (
-        <Select value={value || ''} onValueChange={onChange} disabled={loading}>
+        <Select
+            value={value || ''}
+            onValueChange={guardEmptySelect(value, onChange, options.map((o: ResolvedOption) => String(o.id)))}
+            disabled={loading}
+        >
             <SelectTrigger className="w-full">
                 <SelectValue placeholder={loading ? 'Cargando…' : (field.placeholder || 'Seleccionar...')} />
             </SelectTrigger>

package/src/dynamic-kanban.tsx

@@ -94,9 +94,6 @@ import {
     Button,
     Card,
     CardContent,
-    DropdownMenu,
-    DropdownMenuContent,
-    DropdownMenuTrigger,
     Input,
     Popover,
     PopoverContent,
@@ -113,6 +110,13 @@ import {
     SheetTrigger,
     Skeleton,
 } from '@asteby/metacore-ui/primitives'
+// The card "…" menu renders RowActionMenuItem (dynamic-columns), whose
+// DropdownMenuItem comes from the ROOT '@asteby/metacore-ui' entry. The menu
+// shell MUST come from that same entry: hosts share the root entry as a Module
+// Federation singleton while '/primitives' is bundled locally, so mixing them
+// yields two Radix Menu contexts and the click crashes the app with
+// "`MenuItem` must be used within `Menu`" (Pitsline taller kanban, 2026-10-05).
+import { DropdownMenu, DropdownMenuContent, DropdownMenuTrigger } from '@asteby/metacore-ui'
 import { ColumnFilterControl, FilterValueCombobox, type ColumnFilterType } from '@asteby/metacore-ui/data-table'
 import { generateBadgeStyles, optionColor } from '@asteby/metacore-ui/lib'
 import { useApi } from './api-context'
@@ -161,6 +165,7 @@ import {
     aggregateOf,
     formatAggregateTotal,
     isRowActionVisible,
+    lifecycleStageField,
     relationKeyFor,
     RowActionMenuItem,
 } from './dynamic-columns'
@@ -420,18 +425,39 @@ export function isCardOverdue(card: any, col: ColumnDefinition, now: number = Da
  * The stage machine (stages, transitions, smart lanes) belongs to the model's
  * stage column (`stage_field`; older hosts that do not serve it: the served
  * group_by): grouping by it keeps the machine, grouping by anything else drops
- * it and the lanes come from the new column. Returns the SAME object when there
- * is nothing to change (no override, the served group_by already, or a column the
- * model does not have). Pure — exported for unit tests.
+ * it and the lanes come from the new column.
+ *
+ * The served group_by is the LAST kanban nav entry's, which need not be the
+ * stage column: a board opened without `?group_by=` (the list's view toggle)
+ * groups by the stage column, and a board grouped by the served column keeps
+ * the machine only when that column IS the stage column. Otherwise the stage
+ * lanes were painted over another column (by bay: every card under «Sin etapa»
+ * and a drop wrote `service_bay_id = 'diagnosis'`, 422). Returns the SAME
+ * object when there is nothing to change. Pure — exported for unit tests.
  */
 export function withGroupBy(
     metadata: TableMetadata | null,
     groupBy: string | undefined,
 ): TableMetadata | null {
-    if (!metadata || !groupBy || groupBy === metadata.group_by) return metadata
+    if (!metadata) return metadata
+    const hasMachine = (metadata.stages?.length ?? 0) > 0
+    const stageColumn = metadata.stage_field ?? (hasMachine ? metadata.group_by : undefined)
+    if (!groupBy) {
+        if (!hasMachine || !stageColumn || stageColumn === metadata.group_by) return metadata
+        return { ...metadata, group_by: stageColumn }
+    }
+    if (groupBy === stageColumn) {
+        return groupBy === metadata.group_by ? metadata : { ...metadata, group_by: groupBy }
+    }
     if (!metadata.columns.some((c) => c.key === groupBy)) return metadata
-    const stageColumn = metadata.stage_field ?? (metadata.stages?.length ? metadata.group_by : undefined)
-    if (groupBy === stageColumn) return { ...metadata, group_by: groupBy }
+    if (
+        groupBy === metadata.group_by &&
+        !hasMachine &&
+        !metadata.transitions &&
+        !metadata.smart_lanes
+    ) {
+        return metadata
+    }
     return {
         ...metadata,
         group_by: groupBy,
@@ -2115,6 +2141,7 @@ function DynamicKanbanBoard({
                             fieldCols={fieldCols}
                             showAllFields={explicitCard}
                             actions={rowActions}
+                            stageField={lifecycleStageField(metadata)}
                             locale={i18n.language}
                             timeZone={timeZone}
                             currency={currency}
@@ -2147,6 +2174,7 @@ function DynamicKanbanBoard({
                 fieldCols={fieldCols}
                 showAllFields={explicitCard}
                 actions={rowActions}
+                stageField={lifecycleStageField(metadata)}
                 locale={i18n.language}
                 timeZone={timeZone}
                 currency={currency}
@@ -3179,6 +3207,8 @@ interface KanbanCardProps {
     /** The model laid its card out explicitly: show every field with a value. */
     showAllFields?: boolean
     actions: ActionDefinition[]
+    /** Column the actions' requiresState reads (the model's stage_field). */
+    stageField?: string
     locale: string
     timeZone?: string
     currency?: string
@@ -3256,6 +3286,7 @@ function KanbanCard({
     fieldCols,
     showAllFields,
     actions,
+    stageField,
     locale,
     timeZone,
     currency,
@@ -3270,7 +3301,7 @@ function KanbanCard({
         disabled: !draggable,
     })
 
-    const visibleActions = actions.filter((a) => isRowActionVisible(a, card))
+    const visibleActions = actions.filter((a) => isRowActionVisible(a, card, stageField))
 
     const menu =
         visibleActions.length > 0 ? (

package/src/dynamic-line-items.tsx

@@ -36,6 +36,7 @@ import {
     applyOptionWhen,
 } from './dynamic-form-schema'
 import { DynamicSelectField, DEFAULT_DEPENDS_HINT } from './dynamic-select-field'
+import { getOptionFilter } from './option-filter'
 import { useOptionsResolver, type ResolvedOption } from './use-options-resolver'
 
 export interface DynamicLineItemsProps {
@@ -575,6 +576,8 @@ function RefCell({ field, value, onChange, onPick, disabled, formValues, rowValu
         ref: optSource.ref,
         endpoint: optSource.endpoint,
         filterValue: dependsOn ? scope : undefined,
+        optionFilter: getOptionFilter(field),
+        keepValue: value,
         enabled: !blockedByDependency,
     })
 

package/src/dynamic-multi-select-field.tsx

@@ -19,6 +19,7 @@
 // value instead.
 import { useMemo } from 'react'
 import { MultiSelect } from '@asteby/metacore-ui/primitives'
+import { getOptionFilter } from './option-filter'
 import { useOptionsResolver } from './use-options-resolver'
 import { getFieldRef } from './dynamic-form-schema'
 import type { ActionFieldDef } from './types'
@@ -38,6 +39,7 @@ export function DynamicMultiSelectField({ field, value, onChange }: DynamicMulti
         ref,
         endpoint: !ref && field.searchEndpoint ? field.searchEndpoint : undefined,
         limit: 200,
+        optionFilter: getOptionFilter(field),
     })
 
     const selected = useMemo(() => (Array.isArray(value) ? value.map(String) : []), [value])

package/src/dynamic-relation-helpers.ts

@@ -175,11 +175,20 @@ export function deriveRelationFormFields(
             // than a raw uuid text input. Without this the column lost its `ref`
             // crossing the column→field boundary and degraded to plain text.
             ref: col.ref,
+            // Columnas de solo lectura (escritas por el servidor/sistema): el
+            // DynamicForm las oculta y no las manda en el submit. Sin copiarla,
+            // el renglón las exponía editables y el PATCH las pisaba.
+            ...(isReadonlyColumn(col) ? { readonly: true } : {}),
         })
     }
     return out
 }
 
+function isReadonlyColumn(col: ColumnDefinition): boolean {
+    const c = col as ColumnDefinition & { readonly?: boolean; readOnly?: boolean; read_only?: boolean }
+    return c.readonly === true || c.readOnly === true || c.read_only === true
+}
+
 function columnTypeToFieldType(col: ColumnDefinition): string {
     switch (col.type) {
         case 'number': return 'number'

package/src/dynamic-relation.tsx

@@ -636,11 +636,16 @@ function OneToManyRelation({
             )}
 
             <Dialog open={formOpen} onOpenChange={(open: boolean) => { setFormOpen(open); if (!open) setEditingRow(null) }}>
-                <DialogContent>
-                    <DialogHeader>
+                {/* Alto acotado al viewport: el cuerpo del form hace scroll y el
+                    footer (Guardar) queda fijo, para que un renglón con muchos
+                    campos no deje el botón fuera de pantalla. */}
+                <DialogContent className="flex max-h-[90dvh] flex-col overflow-hidden">
+                    <DialogHeader className="shrink-0">
                         <DialogTitle>{editingRow ? labels.editLabel : labels.addLabel}</DialogTitle>
                     </DialogHeader>
                     <DynamicForm
+                        key={editingRow ? `edit-${editingRow.id ?? ''}` : 'new'}
+                        scrollableBody
                         fields={formFields}
                         initialValues={editingRow || undefined}
                         onSubmit={handleSubmit}

package/src/dynamic-select-field.tsx

@@ -22,6 +22,7 @@
 // value). A dedicated `?ids=` lookup is a follow-up; create flows — the common
 // case — start empty and never hit this.
 import { useEffect, useRef, useState } from 'react'
+import { getOptionFilter } from './option-filter'
 import { useTranslation } from 'react-i18next'
 import {
     Badge,
@@ -266,6 +267,7 @@ export function DynamicSelectField({
     const blockedByDependency = !!dependsOn && scope === ''
 
     const useStatic = Array.isArray(staticOptions)
+    const optionFilter = getOptionFilter(field)
 
     const { options: fetchedOptions, loading: fetchLoading } = useOptionsResolver({
         modelKey: '',
@@ -280,6 +282,8 @@ export function DynamicSelectField({
         // Cascade scope forwarded as filter_value (only when this field
         // declares a dependency). Re-fetches when the parent value changes.
         filterValue: dependsOn ? scope : undefined,
+        optionFilter,
+        keepValue: value,
         // Don't fetch until the popover opens (and keep fetching as the query
         // changes while open). A picker blocked by an unset dependency never
         // fetches. A readonly cell fetches eagerly so its value's label resolves

package/src/index.ts

@@ -206,6 +206,7 @@ export {
 export {
     DocumentFormDialog,
     resolveDocumentForms,
+    scopeDocumentFormsToFilter,
     type DocumentFormDialogProps,
 } from './document-form-dialog'
 export {
@@ -359,6 +360,10 @@ export {
 } from './sidebar-layout-manager'
 export * from './org-runtime-context'
 export * from './business'
+// Primitivos de negocio (PaymentAllocator, AgingTable, ApprovalInbox,
+// contribuciones/modales federados, tipos de documento y contratos de paneles).
+// Ver primitives/index.ts para el mapa completo.
+export * from './primitives'
 export * from './org-runtime-provider'
 export * from './navigation-builder'
 export * from './i18n-provider'
@@ -422,7 +427,7 @@ export {
     resolveRelationLabel,
     type DynamicColumnsHelpers,
 } from './dynamic-columns'
-export { humanizeToken, translateMetadataLabel } from './dynamic-columns-helpers'
+export { humanizeToken, localizeFieldLabel, translateMetadataLabel } from './dynamic-columns-helpers'
 export type { MetadataTranslator } from './dynamic-columns-helpers'
 export {
     UrlChip,
@@ -584,6 +589,14 @@ export {
     type ActivityEvent,
     type ActivityDiffProps,
 } from './activity-diff'
+export {
+    AuditInfo,
+    readAuditMeta,
+    resolveAuditActor,
+    SYSTEM_ACTOR_ID,
+    type AuditInfoProps,
+    type AuditActor,
+} from './audit-info'
 export {
     RecordHistory,
     type RecordHistoryProps,
@@ -661,3 +674,23 @@ export {
 
 // Página de documento (benchmark §5/§6): cabecera, badges, acciones por estado, botones inteligentes.
 export * from './document'
+
+// Option filter — hide options of a relation / dynamic picker from the manifest
+// (`option_filter` / `optionFilter` on the field).
+export { getOptionFilter, applyOptionFilter, optionPassesRule } from './option-filter'
+export type { OptionFilter, OptionFilterRule } from './option-filter'
+
+// Addons instalados / capacidades provistas — primitivo único de «¿qué hay
+// instalado?» para hosts y remotes federados. Sin provider los hooks devuelven
+// `undefined` (desconocido): el consumidor NUNCA debe asumir ausente.
+export {
+    InstalledAddonsProvider,
+    useAddonInstalled,
+    useCapabilityProvided,
+    useInstalledAddons,
+    type InstalledAddonsValue,
+} from './installed-addons-context'
+
+// Ayudantes de captura (registerRecordPrefill de @asteby/metacore-sdk) arriba
+// del formulario genérico de un modelo; DynamicRecordDialog ya lo monta.
+export { RecordPrefillBar, type RecordPrefillBarProps } from './record-prefill-bar'