@asteby/metacore-runtime-react 47.1.0 → 48.0.0

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'
@@ -65,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,
@@ -76,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)
 
@@ -87,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
@@ -133,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()
@@ -163,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
@@ -186,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
@@ -212,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
@@ -258,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}
@@ -428,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':
@@ -526,6 +581,25 @@ 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
@@ -535,7 +609,11 @@ function RefSelect({ field, value, onChange }: FieldRendererProps) {
         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

@@ -165,6 +165,7 @@ import {
     aggregateOf,
     formatAggregateTotal,
     isRowActionVisible,
+    lifecycleStageField,
     relationKeyFor,
     RowActionMenuItem,
 } from './dynamic-columns'
@@ -424,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,
@@ -2119,6 +2141,7 @@ function DynamicKanbanBoard({
                             fieldCols={fieldCols}
                             showAllFields={explicitCard}
                             actions={rowActions}
+                            stageField={lifecycleStageField(metadata)}
                             locale={i18n.language}
                             timeZone={timeZone}
                             currency={currency}
@@ -2151,6 +2174,7 @@ function DynamicKanbanBoard({
                 fieldCols={fieldCols}
                 showAllFields={explicitCard}
                 actions={rowActions}
+                stageField={lifecycleStageField(metadata)}
                 locale={i18n.language}
                 timeZone={timeZone}
                 currency={currency}
@@ -3183,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
@@ -3260,6 +3286,7 @@ function KanbanCard({
     fieldCols,
     showAllFields,
     actions,
+    stageField,
     locale,
     timeZone,
     currency,
@@ -3274,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-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/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,
@@ -674,3 +679,18 @@ export * from './document'
 // (`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'

package/src/installed-addons-context.tsx

@@ -0,0 +1,58 @@
+// InstalledAddonsProvider / useAddonInstalled / useCapabilityProvided —
+// primitivo ÚNICO de "¿qué hay instalado?" para hosts y addons.
+//
+// Hoy cada addon lo resuelve a su manera: POS lee `installedAddons` del host
+// (lib/host.ts addonKnownMissing), sondea `/options/<Model>` (use-model-available:
+// 403/404 = ausente) o hardcodea claves (caja-policy useAnyFiscalAddonInstalled);
+// `useInstalledAddons` vive sólo en @asteby/metacore-marketplace. Esto lo sube a
+// runtime-react con dos niveles:
+//   - addon key  (useAddonInstalled('fiscal_mexico'))
+//   - capability (useCapabilityProvided('fiscal.invoice_issuer')) — contrato
+//     independiente del país/vertical: fiscal_mexico, fiscal_colombia… lo proveen
+//     vía manifest `provides_capabilities`; caja pregunta por la capacidad,
+//     no por la clave del addon.
+// Fuente: el host monta el provider con lo que ya trae su bootstrap
+// (installed addons + provides_capabilities del manifest). Sin provider:
+// `undefined` = desconocido (el consumidor decide; NUNCA asume ausente).
+import { createContext, useContext, useMemo, type ReactNode } from 'react'
+
+export interface InstalledAddonsValue {
+    addons: ReadonlySet<string>
+    capabilities: ReadonlySet<string>
+}
+
+const Ctx = createContext<InstalledAddonsValue | null>(null)
+
+export function InstalledAddonsProvider({
+    addons,
+    capabilities = [],
+    children,
+}: {
+    addons: readonly string[]
+    capabilities?: readonly string[]
+    children: ReactNode
+}) {
+    const aKey = [...addons].sort().join(',')
+    const cKey = [...capabilities].sort().join(',')
+    const value = useMemo<InstalledAddonsValue>(
+        () => ({ addons: new Set(addons), capabilities: new Set(capabilities) }),
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [aKey, cKey],
+    )
+    return <Ctx.Provider value={value}>{children}</Ctx.Provider>
+}
+
+/** true/false si el host lo sabe; undefined si no hay provider. */
+export function useAddonInstalled(key: string): boolean | undefined {
+    const v = useContext(Ctx)
+    return v ? v.addons.has(key) : undefined
+}
+
+export function useCapabilityProvided(capability: string): boolean | undefined {
+    const v = useContext(Ctx)
+    return v ? v.capabilities.has(capability) : undefined
+}
+
+export function useInstalledAddons(): InstalledAddonsValue | null {
+    return useContext(Ctx)
+}

package/src/org-runtime-context.ts

@@ -26,3 +26,13 @@ export const CurrencyContext = createContext<string | undefined>(undefined)
 
 /** Reads the nearest org currency (undefined outside a provider). */
 export const useCurrency = () => useContext(CurrencyContext)
+
+/**
+ * Org default tax rate as a fraction (e.g. `0.16`), from the org's fiscal
+ * config. Document line editors use it when the picked product carries no rate
+ * of its own. `undefined` outside a provider → lines start at 0.
+ */
+export const TaxRateContext = createContext<number | undefined>(undefined)
+
+/** Reads the nearest org default tax rate (undefined outside a provider). */
+export const useOrgTaxRate = () => useContext(TaxRateContext)

package/src/org-runtime-provider.tsx

@@ -12,13 +12,15 @@ import {
   identityImageUrl,
   type GetImageUrl,
 } from './image-url-context'
-import { CurrencyContext, TimeZoneContext } from './org-runtime-context'
+import { CurrencyContext, TaxRateContext, TimeZoneContext } from './org-runtime-context'
 
 export interface OrgRuntimeProviderProps {
   /** Org IANA timezone (e.g. `America/Mexico_City`). */
   timeZone?: string
   /** Org ISO-4217 currency (e.g. `MXN`). */
   currency?: string
+  /** Org default tax rate as a fraction (e.g. `0.16`) for document lines. */
+  taxRate?: number
   /** Resolver turning a stored path into a fetchable URL. Defaults to identity. */
   getImageUrl?: GetImageUrl
   children: ReactNode
@@ -27,6 +29,7 @@ export interface OrgRuntimeProviderProps {
 export function OrgRuntimeProvider({
   timeZone,
   currency,
+  taxRate,
   getImageUrl = identityImageUrl,
   children,
 }: OrgRuntimeProviderProps) {
@@ -34,7 +37,9 @@ export function OrgRuntimeProvider({
     <ImageUrlContext.Provider value={getImageUrl}>
       <TimeZoneContext.Provider value={timeZone}>
         <CurrencyContext.Provider value={currency}>
-          {children}
+          <TaxRateContext.Provider value={taxRate}>
+            {children}
+          </TaxRateContext.Provider>
         </CurrencyContext.Provider>
       </TimeZoneContext.Provider>
     </ImageUrlContext.Provider>

package/src/primitives/aging.ts

@@ -0,0 +1,76 @@
+// AgingTable — antigüedad de saldos (CxC y CxP) como función pura.
+//
+// customers ya guarda aging_1_30 … aging_90_plus por cliente (refresh_credit_file).
+// Esta función es la MISMA regla para la UI (drill-down por documento, CxP que
+// hoy no la tiene) y para reportes: un solo lugar decide qué es «corriente».
+import { roundMoney } from '../business/format'
+
+export interface AgingBucket {
+    key: string
+    label: string
+    /** Días vencidos desde (inclusive). `current` usa -Infinity..0. */
+    from: number
+    /** Días vencidos hasta (inclusive). `null` = sin tope. */
+    to: number | null
+}
+
+export const DEFAULT_AGING_BUCKETS: AgingBucket[] = [
+    { key: 'current', label: 'Corriente', from: Number.NEGATIVE_INFINITY, to: 0 },
+    { key: 'd1_30', label: '1–30', from: 1, to: 30 },
+    { key: 'd31_60', label: '31–60', from: 31, to: 60 },
+    { key: 'd61_90', label: '61–90', from: 61, to: 90 },
+    { key: 'd90_plus', label: '90+', from: 91, to: null },
+]
+
+export interface AgingDoc {
+    party_id: string
+    party_name?: string
+    due_at: string | null // ISO date; null = vence al emitir
+    issued_at: string
+    balance: number
+}
+
+export interface AgingRow {
+    party_id: string
+    party_name?: string
+    buckets: Record<string, number>
+    total: number
+    overdue: number
+    oldest_overdue_days: number
+}
+
+const DAY = 86_400_000
+
+/** Días vencidos al corte (negativo = falta para vencer). Fechas en ISO (día). */
+export function daysOverdue(dueISO: string, asOfISO: string): number {
+    const due = Date.parse(dueISO.slice(0, 10) + 'T00:00:00Z')
+    const asOf = Date.parse(asOfISO.slice(0, 10) + 'T00:00:00Z')
+    return Math.round((asOf - due) / DAY)
+}
+
+export function bucketFor(days: number, buckets: readonly AgingBucket[] = DEFAULT_AGING_BUCKETS): string {
+    for (const b of buckets) if (days >= b.from && (b.to === null || days <= b.to)) return b.key
+    return buckets[buckets.length - 1].key
+}
+
+/** Agrupa por contraparte y tramo. Saldos ≤ 0 se ignoran (anticipos van aparte). */
+export function computeAging(docs: readonly AgingDoc[], asOfISO: string, buckets: readonly AgingBucket[] = DEFAULT_AGING_BUCKETS): { rows: AgingRow[]; totals: Record<string, number>; total: number } {
+    const rows = new Map<string, AgingRow>()
+    const totals: Record<string, number> = Object.fromEntries(buckets.map(b => [b.key, 0]))
+    for (const d of docs) {
+        if (d.balance <= 0) continue
+        const days = daysOverdue(d.due_at ?? d.issued_at, asOfISO)
+        const key = bucketFor(days, buckets)
+        const row = rows.get(d.party_id) ?? { party_id: d.party_id, party_name: d.party_name, buckets: Object.fromEntries(buckets.map(b => [b.key, 0])), total: 0, overdue: 0, oldest_overdue_days: 0 }
+        row.buckets[key] = roundMoney(row.buckets[key] + d.balance)
+        row.total = roundMoney(row.total + d.balance)
+        if (days > 0) {
+            row.overdue = roundMoney(row.overdue + d.balance)
+            row.oldest_overdue_days = Math.max(row.oldest_overdue_days, days)
+        }
+        totals[key] = roundMoney(totals[key] + d.balance)
+        rows.set(d.party_id, row)
+    }
+    const list = [...rows.values()].sort((a, b) => b.overdue - a.overdue || b.total - a.total)
+    return { rows: list, totals, total: roundMoney(list.reduce((s, r) => s + r.total, 0)) }
+}