@asteby/metacore-runtime-react 48.0.0 → 49.1.0

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

@@ -11,6 +11,7 @@ import type { Allocation, AllocationIssue, OpenDocument } from '../primitives/al
 import type {
     ActionFieldDef,
     DocumentFormLines,
+    DocumentFormSource,
     DocumentFormOpenDocuments,
     DocumentFormsManifest,
     DocumentFormType,
@@ -24,8 +25,10 @@ const ADVANCED_SECTIONS = new Set(['fiscal', 'advanced'])
 export type EditorLinesConfig = DocumentFormLines & { field: string }
 
 /** true si el tipo se abre en el DocumentEditor (`layout: "editor"`). */
-export function isEditorLayout(type: Pick<DocumentFormType, 'layout'> | null | undefined): boolean {
-    return type?.layout === 'editor'
+export function isEditorLayout(type: Pick<DocumentFormType, 'layout' | 'sources'> | null | undefined): boolean {
+    // «Cargar desde…» vive en el editor: un tipo con `sources` lo usa salvo que
+    // pida explícitamente el wizard.
+    return type?.layout === 'editor' || (type?.layout !== 'wizard' && (type?.sources?.length ?? 0) > 0)
 }
 
 /** Paso de renglones efectivo del tipo (o undefined si no tiene). */
@@ -189,13 +192,22 @@ export function creditStatus(
  * (`description: product_name`, `discount: discount_pct`). Si el origen trae
  * `tax_amount` y `subtotal` pero no la tasa, la deriva. `credit` (NC) topa la
  * cantidad en lo facturado (o en `max_quantity` si el origen la trae).
+ *
+ * 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.
  */
-export function linesFromSource(rows: unknown, map: Record<string, string> = {}, opts: { kind?: DocumentFormLines['kind'] } = {}): LineItem[] {
+export function linesFromSource(
+    rows: unknown,
+    map: Record<string, string> = {},
+    opts: { kind?: DocumentFormLines['kind']; discountMode?: DocumentFormLines['discount_mode'] } = {},
+): LineItem[] {
     if (!Array.isArray(rows)) return []
-    return rows.map((raw) => {
+    return rows.filter((raw) => !isFullyConsumed(raw)).map((raw) => {
         const r = (raw ?? {}) as Record<string, any>
         const get = (k: string) => r[map[k] ?? k]
-        const qty = toAmount(get('quantity') ?? 1)
+        const pending = hasValue(r.remaining_quantity) ? toAmount(r.remaining_quantity) : undefined
+        const qty = pending ?? toAmount(get('quantity') ?? 1)
         let rate = get('tax_rate')
         if (!hasValue(rate)) {
             const sub = toAmount(get('subtotal'))
@@ -213,11 +225,34 @@ export function linesFromSource(rows: unknown, map: Record<string, string> = {},
             tax_rate: r2 > 1 ? r2 / 100 : r2,
             unit: get('unit') ?? undefined,
         })
-        if (opts.kind === 'credit') line.max_quantity = hasValue(get('max_quantity')) ? toAmount(get('max_quantity')) : qty
+        // 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 (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
+        if (hasValue(sourceLine)) line.source_line_id = String(sourceLine)
         return line
     })
 }
 
+function isFullyConsumed(raw: unknown): boolean {
+    const r = (raw ?? {}) as Record<string, any>
+    return hasValue(r.remaining_quantity) && toAmount(r.remaining_quantity) <= 0
+}
+
+/** Cuántos renglones del origen se cargaron y cuántos se omitieron por estar ya cubiertos. */
+export function sourceLoadSummary(rows: unknown): { loaded: number; covered: number } {
+    if (!Array.isArray(rows)) return { loaded: 0, covered: 0 }
+    const covered = rows.filter(isFullyConsumed).length
+    return { loaded: rows.length - covered, covered }
+}
+
+/** Fuente que precarga desde lo pendiente servido por el host (no desde la relación cruda). */
+export function sourceTracksRemaining(src: Pick<DocumentFormSource, 'line_link_field' | 'remaining_qty_field' | 'remaining_endpoint'>): boolean {
+    return !!(src.line_link_field || src.remaining_qty_field || src.remaining_endpoint)
+}
+
 export interface EditorIssue {
     field?: string
     severity: 'error' | 'warning'
@@ -234,6 +269,13 @@ export function localIssues(lines: LineItem[], opts: { requireLines?: boolean; r
     items.forEach((l, i) => {
         if (!l.description.trim()) issues.push({ field: `lines.${i}`, severity: 'error', message: `Renglón ${i + 1}: falta la descripción.` })
         if (toAmount(l.unit_price) <= 0) issues.push({ field: `lines.${i}`, severity: 'warning', message: `Renglón ${i + 1}: precio en cero.` })
+        if (l.max_quantity != null && toAmount(l.quantity) > toAmount(l.max_quantity)) {
+            issues.push({
+                field: `lines.${i}`,
+                severity: 'error',
+                message: `Renglón ${i + 1}: la cantidad excede lo pendiente del documento origen (${l.max_quantity}).`,
+            })
+        }
         if (opts.requireTax && toAmount(l.tax_rate) === 0) {
             issues.push({ field: `lines.${i}`, severity: 'warning', message: `Renglón ${i + 1}: sin impuesto.` })
         }

package/src/business/document-editor.tsx

@@ -23,7 +23,7 @@ import { Button } from '@asteby/metacore-ui/primitives'
 import { Loader2 } from 'lucide-react'
 import { toast } from 'sonner'
 import { useApi } from '../api-context'
-import { useOrgTaxRate } from '../org-runtime-context'
+import { useOrgTaxRate, useTimeZone } from '../org-runtime-context'
 import { FieldCell, FieldGrid, FieldLabel } from '../field-grid'
 import { FormErrorBanner } from './feedback'
 import { DocumentLinesGrid, type DocumentLinesGridProps, type LineItemsColumn } from './line-items-editor'
@@ -38,6 +38,8 @@ import {
     editorLinesConfig,
     linesFromSource,
     localIssues,
+    sourceLoadSummary,
+    sourceTracksRemaining,
     partyDefaults,
     partySummaryRows,
     splitEditorFields,
@@ -112,6 +114,7 @@ export function DocumentEditor({
     const fmt = useFormatter({ currency })
     const installed = useInstalledAddons()
     const orgTaxRate = useOrgTaxRate()
+    const orgTimeZone = useTimeZone()
     const tl = useCallback((s: string) => t(s, { defaultValue: s }), [t])
 
     const lineCfg = useMemo(() => editorLinesConfig(type, forms), [type, forms])
@@ -120,7 +123,7 @@ export function DocumentEditor({
     const amountKey = isAllocation ? allocationAmountField(type.fields) : undefined
 
     const [header, setHeader] = useState<Record<string, any>>(() => ({
-        ...buildFieldDefaults(type.fields, record),
+        ...buildFieldDefaults(type.fields, record, undefined, { timeZone: orgTimeZone, now: today }),
         ...(type.defaults ?? {}),
     }))
     const [lines, setLines] = useState<LineItem[]>([])
@@ -142,6 +145,10 @@ export function DocumentEditor({
     const [attempted, setAttempted] = useState(false)
     const [sourceKey, setSourceKey] = useState<string>(initialSource?.key ?? '')
     const [sourceId, setSourceId] = useState<string>(initialSource?.id ?? '')
+    // Fuente de la que salieron los renglones: su `line_link_field` viaja en cada
+    // 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 relCache = useRef(new Map<string, Promise<any[]>>())
 
     const taxRate = defaultTaxRate ?? orgTaxRate
@@ -273,10 +280,13 @@ export function DocumentEditor({
         const p: Record<string, unknown> = { ...(type.defaults ?? {}), ...header }
         if (forms.type_field && !type.submit_action) p[forms.type_field] = type.value ?? type.key
         if (lineCfg) {
-            p[lineCfg.field] = isAllocation && openCfg ? allocationPayload(allocation.allocations, openCfg) : serializeLineItems(lines)
+            p[lineCfg.field] =
+                isAllocation && openCfg
+                    ? allocationPayload(allocation.allocations, openCfg)
+                    : serializeLineItems(lines, { sourceLineField: loadedSource?.line_link_field })
         }
         return p
-    }, [type, header, forms.type_field, lineCfg, isAllocation, openCfg, allocation, lines])
+    }, [type, header, forms.type_field, lineCfg, isAllocation, openCfg, allocation, lines, loadedSource])
 
     const baseUrl = type.endpoint ?? endpoint ?? `/dynamic/${model}`
 
@@ -304,27 +314,72 @@ export function DocumentEditor({
     }
 
     // ---- Cargar desde… --------------------------------------------------------
+    /**
+     * Renglones del origen. Con lo pendiente declarado (`line_link_field`,
+     * `remaining_qty_field` o `remaining_endpoint`) los sirve el host ya con
+     * `remaining_quantity` (cantidad − lo ya facturado/devuelto, calculado en el
+     * servidor); si el host aún no tiene `source-lines` (404) o la fuente no lo
+     * declara, se leen de la relación como antes.
+     */
+    const fetchSourceRows = useCallback(
+        async (src: DocumentFormSource, id: string): Promise<unknown[]> => {
+            if (src.remaining_endpoint) {
+                const res = await api.get(src.remaining_endpoint, { params: { id } })
+                return res?.data?.data ?? []
+            }
+            if (sourceTracksRemaining(src)) {
+                try {
+                    const res = await api.get(`${baseUrl}/source-lines`, {
+                        params: { source: src.key, id, ...(draftId ? { exclude: draftId } : {}) },
+                    })
+                    return res?.data?.data ?? []
+                } catch (err: any) {
+                    if (err?.response?.status !== 404) throw err
+                }
+            }
+            let rels = relCache.current.get(src.model)
+            if (!rels) {
+                rels = api
+                    .get(`/metadata/table/${src.model}`)
+                    .then((r: any) => r?.data?.data?.relations ?? r?.data?.relations ?? [])
+                relCache.current.set(src.model, rels)
+            }
+            const call = prefillFromFieldRelationRequest(
+                { fieldKey: lineCfg?.field ?? 'lines', refModel: src.model, refId: id, spec: { $prefillFromRecord: src.lines } },
+                await rels,
+            )
+            if (!call) throw new Error(`${src.model}: falta la relación «${src.lines}»`)
+            const res = await api.get(call.endpoint, { params: call.params })
+            return res?.data?.data ?? []
+        },
+        [api, baseUrl, draftId, lineCfg?.field],
+    )
+
     const loadFromSource = useCallback(
         async (src: DocumentFormSource, id: string) => {
             if (!lineCfg || !id) return
             setBusy('source')
             try {
                 if (!isAllocation) {
-                    let rels = relCache.current.get(src.model)
-                    if (!rels) {
-                        rels = api
-                            .get(`/metadata/table/${src.model}`)
-                            .then((r: any) => r?.data?.data?.relations ?? r?.data?.relations ?? [])
-                        relCache.current.set(src.model, rels)
-                    }
-                    const call = prefillFromFieldRelationRequest(
-                        { fieldKey: lineCfg.field, refModel: src.model, refId: id, spec: { $prefillFromRecord: src.lines } },
-                        await rels,
-                    )
-                    if (!call) throw new Error(`${src.model}: falta la relación «${src.lines}»`)
-                    const res = await api.get(call.endpoint, { params: call.params })
-                    setLines(linesFromSource(res?.data?.data ?? [], src.map, { kind }))
+                    const rows = await fetchSourceRows(src, id)
+                    const loaded = linesFromSource(rows, src.map, { kind, discountMode: lineCfg.discount_mode })
+                    const { covered } = sourceLoadSummary(rows)
+                    setLines(loaded)
+                    setLoadedSource(src)
                     setLinesFromSourceDoc(kind === 'credit')
+                    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.',
+                              })
+                            : covered > 0
+                              ? t('documentEditor.source_loaded_partial', {
+                                    defaultValue: '{{count}} renglones con lo pendiente · {{covered}} ya cubiertos se omitieron',
+                                    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 } })
@@ -345,7 +400,7 @@ export function DocumentEditor({
                 setBusy(null)
             }
         },
-        [api, lineCfg, isAllocation, kind, t],
+        [api, lineCfg, isAllocation, kind, t, fetchSourceRows],
     )
 
     // Prefill al abrir desde un documento origen (acción de fila «Crear NC», «Facturar venta»…).
@@ -538,7 +593,7 @@ export function DocumentEditor({
                     <EditorSection
                         slot="load-from-source"
                         title={t('documentEditor.load_from', { defaultValue: 'Cargar desde…' })}
-                        hint={busy === 'source' ? t('documentEditor.loading_source', { defaultValue: 'Cargando…' }) : undefined}
+                        hint={busy === 'source' ? t('documentEditor.loading_source', { defaultValue: 'Cargando…' }) : sourceNote}
                     >
                         <div className="flex flex-wrap items-center gap-2">
                             {sources.length > 1 && (

package/src/business/line-items.ts

@@ -32,6 +32,12 @@ export interface LineItem {
     cost?: number
     /** Tope de cantidad (NC: facturado − acreditado; devolución: vendido − devuelto). */
     max_quantity?: number
+    /**
+     * Id del renglón del documento origen («crear desde»). Viaja en la columna
+     * `line_link_field` de la fuente para que el servidor descuente y valide lo
+     * pendiente; un renglón libre no lo lleva.
+     */
+    source_line_id?: string
     technician_id?: string
     lot?: string
     dot?: string
@@ -203,7 +209,10 @@ export function validateLineItems(lines: LineItem[], policy: LineItemsPolicy = {
  * Forma que se manda al backend: números reales (nunca `""`), sin claves de UI,
  * opcionales vacíos omitidos y `position` 1-based conservando el orden.
  */
-export function serializeLineItems(lines: LineItem[]): Array<Record<string, unknown>> {
+export function serializeLineItems(
+    lines: LineItem[],
+    opts: { /** Columna que recibe `source_line_id` (la `line_link_field` de la fuente). */ sourceLineField?: string } = {},
+): Array<Record<string, unknown>> {
     return lines.map((l, i) => {
         const out: Record<string, unknown> = {
             position: i + 1,
@@ -222,6 +231,12 @@ export function serializeLineItems(lines: LineItem[]): Array<Record<string, unkn
                 if (typeof v === 'string' && v.trim()) out[k] = v.trim()
             }
             if (l.extensions && Object.keys(l.extensions).length > 0) out.fiscal_data = { ...l.extensions }
+            if (opts.sourceLineField && l.source_line_id) out[opts.sourceLineField] = l.source_line_id
+            // Importes ya calculados: un modelo de renglón sin tasa (solo
+            // `tax_amount`/`subtotal`) los guarda tal cual en vez de perder el IVA.
+            const a = computeLine(l)
+            out.subtotal = a.net
+            out.tax_amount = a.tax
         }
         return out
     })

package/src/calendar-date.ts

@@ -26,3 +26,39 @@ export function isCalendarDayValue(v: unknown): boolean {
     if (typeof v !== 'string') return false
     return /^\d{4}-\d{2}-\d{2}(?:[T ]00:00:00(?:\.0+)?(?:Z|\+00:00)?)?$/.test(v.trim())
 }
+
+/**
+ * Today's calendar day ("YYYY-MM-DD") in `timeZone` (IANA, e.g. the org's
+ * `America/Mexico_City`), or in the browser zone when absent/invalid. A form
+ * that seeds «hoy» must use the org's day, not UTC's: at 19:00 in Mexico City
+ * UTC is already tomorrow.
+ */
+export function todayInZone(timeZone?: string, now: Date = new Date()): string {
+    if (timeZone) {
+        try {
+            // en-CA formats as YYYY-MM-DD.
+            return new Intl.DateTimeFormat('en-CA', {
+                timeZone,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+            }).format(now)
+        } catch {
+            /* unknown zone → browser day */
+        }
+    }
+    const y = now.getFullYear()
+    const m = String(now.getMonth() + 1).padStart(2, '0')
+    const d = String(now.getDate()).padStart(2, '0')
+    return `${y}-${m}-${d}`
+}
+
+/**
+ * A field default that names «today» instead of a fixed day: `$today` (the
+ * token flows already use) or `today`. Case-insensitive.
+ */
+export function isTodayToken(v: unknown): boolean {
+    if (typeof v !== 'string') return false
+    const s = v.trim().toLowerCase()
+    return s === '$today' || s === 'today'
+}

package/src/document/document-page.tsx

@@ -8,6 +8,7 @@ import { useTranslation } from 'react-i18next'
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@asteby/metacore-ui/primitives'
 import { cn } from '@asteby/metacore-ui/lib'
 import { ActionBar } from './action-bar'
+import { DocumentSecondaryBar } from './secondary-bar'
 import { DocumentHeader, type HeaderBadge, type HeaderMetric } from './document-header'
 import { SmartButtons, type SmartButtonItem } from './smart-buttons'
 import { StatusBadge } from './status-badge'
@@ -175,6 +176,20 @@ export function DocumentPage(props: DocumentPageProps) {
                     </TabsContent>
                 ))}
             </Tabs>
+
+            {/* Compartir / imprimir / correo / PDF-XML y lo que aporten los
+                addons instalados: al pie, no compitiendo con la primaria. */}
+            <DocumentSecondaryBar
+                items={layout.footer.map((a) => ({
+                    key: a.def.key,
+                    label: a.def.label,
+                    icon: a.def.icon,
+                    blockedReason: a.blockedReason,
+                    run: () => handleAction(a),
+                }))}
+                model={spec.model}
+                record={record}
+            />
         </div>
     )
 }

package/src/document/evaluate.ts

@@ -1,3 +1,4 @@
+import { classifyActionPriority } from '../action-priority'
 import type {
     ActionLayout,
     DocumentActionDef,
@@ -130,12 +131,15 @@ export function resolveActions(spec: DocumentSpec, ctx: DocumentContext): Resolv
     const destructive = many(layout.destructive)
     const secondary: ResolvedAction[] = []
     const more: ResolvedAction[] = []
+    const footer: ResolvedAction[] = []
     for (const a of [...many(layout.secondary)]) {
         if (a.def.destructive) destructive.push(a)
+        else if (isFooterAction(a.def)) footer.push(a)
         else secondary.push(a)
     }
     for (const a of many(layout.more)) {
         if (a.def.destructive) destructive.push(a)
+        else if (isFooterAction(a.def)) footer.push(a)
         else more.push(a)
     }
     const overflow = secondary.splice(MAX_VISIBLE_SECONDARY)
@@ -146,7 +150,19 @@ export function resolveActions(spec: DocumentSpec, ctx: DocumentContext): Resolv
         destructive.unshift(primary)
         primary = undefined
     }
-    return { primary, secondary, more, destructive }
+    return { primary, secondary, more, destructive, footer }
+}
+
+/**
+ * ¿Va al pie? `priority: secondary`, o la convención por clave sobre la acción
+ * del modelo (`modelAction ?? key`): compartir, imprimir, correo, chat, PDF/XML.
+ */
+function isFooterAction(def: DocumentActionDef): boolean {
+    if (def.priority) return def.priority === 'secondary'
+    return (
+        classifyActionPriority({ key: def.key }) === 'secondary' ||
+        (!!def.modelAction && classifyActionPriority({ key: def.modelAction }) === 'secondary')
+    )
 }
 
 /** Interpola `{{campo}}` con valores del registro (sin evaluar código). */

package/src/document/index.ts

@@ -13,6 +13,7 @@ export {
 export { formatFieldValue, type FieldFormatOptions } from './format'
 export { StatusBadge, STATUS_TONE_STYLE, type StatusBadgeProps } from './status-badge'
 export { ActionBar, type ActionBarProps } from './action-bar'
+export { DocumentSecondaryBar, type DocumentSecondaryBarProps, type SecondaryBarItem } from './secondary-bar'
 export { DocumentHeader, type DocumentHeaderProps, type HeaderBadge, type HeaderMetric } from './document-header'
 export { SmartButtons, type SmartButtonItem, type SmartButtonsProps } from './smart-buttons'
 export { DocumentTimeline, type DocumentTimelineProps, type TimelineEntry } from './document-timeline'

package/src/document/secondary-bar.tsx

@@ -0,0 +1,92 @@
+// DocumentSecondaryBar — pie del documento con las acciones secundarias:
+// compartir, imprimir/descargar PDF o XML, enviar por correo, enviar al chat…
+// La cabecera se queda con UNA primaria (y sus principales); esto va abajo,
+// discreto. Junta dos fuentes:
+//   - `items`: acciones del propio documento/modelo ya clasificadas como
+//     secundarias (resolveActions → `footer`, o splitActionsByPriority);
+//   - las aportadas por addons/host con registerRecordAction, sólo si su
+//     proveedor está instalado y activo (useRecordActions).
+// Sin nada que mostrar no pinta nada.
+import { useState, type ReactNode } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Loader2 } from 'lucide-react'
+import { Button } from '@asteby/metacore-ui/primitives'
+import { cn } from '@asteby/metacore-ui/lib'
+import { DynamicIcon } from '../dynamic-icon'
+import { useRecordActions } from '../record-actions'
+
+export interface SecondaryBarItem {
+    key: string
+    label: string
+    icon?: string
+    /** Deshabilitada con su motivo (no desaparece). */
+    blockedReason?: string
+    run: () => unknown
+}
+
+export interface DocumentSecondaryBarProps {
+    items?: SecondaryBarItem[]
+    /** Modelo + registro: resuelven las acciones aportadas por addons. */
+    model?: string
+    record?: Record<string, unknown> | null
+    /** Controles extra del host (al final). */
+    children?: ReactNode
+    className?: string
+}
+
+export function DocumentSecondaryBar({ items = [], model, record, children, className }: DocumentSecondaryBarProps) {
+    const { t } = useTranslation()
+    const contributed = useRecordActions(model ?? '', model ? record : null)
+    const [busy, setBusy] = useState<string | null>(null)
+
+    const run = async (key: string, fn?: () => unknown) => {
+        if (!fn || busy) return
+        setBusy(key)
+        try {
+            await fn()
+        } finally {
+            setBusy(null)
+        }
+    }
+
+    const all: SecondaryBarItem[] = [
+        ...items,
+        ...contributed.filter((c) => c.run).map((c) => ({ key: c.key, label: c.label, icon: c.icon, run: c.run! })),
+    ]
+    const rendered = contributed.filter((c) => c.render && !c.run)
+    if (all.length === 0 && rendered.length === 0 && !children) return null
+
+    return (
+        <footer
+            className={cn('flex flex-wrap items-center gap-1.5 border-t pt-3', className)}
+            data-document-secondary=''
+            aria-label={t('datatable.secondary_actions', { defaultValue: 'Compartir y documentos' })}
+        >
+            {all.map((a) => (
+                <Button
+                    key={a.key}
+                    type='button'
+                    size='sm'
+                    variant='ghost'
+                    className='text-muted-foreground'
+                    data-action={a.key}
+                    disabled={!!a.blockedReason || (!!busy && busy !== a.key)}
+                    title={a.blockedReason ? t(a.blockedReason, { defaultValue: a.blockedReason }) : undefined}
+                    onClick={() => void run(a.key, a.run)}
+                >
+                    {busy === a.key ? (
+                        <Loader2 className='mr-1.5 h-4 w-4 animate-spin' />
+                    ) : a.icon ? (
+                        <DynamicIcon name={a.icon} className='mr-1.5 h-4 w-4' />
+                    ) : null}
+                    {t(a.label, { defaultValue: a.label })}
+                </Button>
+            ))}
+            {rendered.map((c) => {
+                const C = c.render!
+                return <C key={c.key} model={model!} record={record!} />
+            })}
+            {children}
+        </footer>
+    )
+}

package/src/document/types.ts

@@ -64,6 +64,12 @@ export interface DocumentActionDef {
     href?: string
     openUrl?: string
     tab?: string
+    /**
+     * "secondary" (o, sin valor, una clave de compartir/imprimir/correo/chat/
+     * PDF/XML por convención) saca la acción de la cabecera y la pone en la
+     * barra secundaria del pie — salvo que el layout la haga primaria.
+     */
+    priority?: 'primary' | 'secondary'
     /** Estilo crítico: siempre va en la zona destructiva. */
     destructive?: boolean
     /** Se muestra deshabilitada con el motivo en lugar de desaparecer. */
@@ -200,6 +206,8 @@ export interface ResolvedActionLayout {
     secondary: ResolvedAction[]
     more: ResolvedAction[]
     destructive: ResolvedAction[]
+    /** Secundarias (compartir, imprimir, correo…) → DocumentSecondaryBar, no la cabecera. */
+    footer: ResolvedAction[]
 }
 
 export type DocumentSlotRenderer = (ctx: DocumentContext) => ReactNode