@asteby/metacore-runtime-react 48.0.0 → 49.1.0

package/src/document-form-dialog.tsx

@@ -23,7 +23,7 @@ import {
 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 { DynamicIcon } from './dynamic-icon'
 import { FieldCell, FieldGrid, FieldLabel } from './field-grid'
 import { FormErrorBanner } from './business/feedback'
@@ -43,11 +43,12 @@ import { validateValues, bagHasErrors } from './validator'
 import { clearFieldErrorTree } from './field-validation-ui'
 import { emitRecordMutation } from './record-mutation-events'
 import { isLineItemsField, resolveWidget, scopeValueFromFilterToken } from './dynamic-form-schema'
-import { createCatalogProductSearch } from './business/catalog-product-search'
+import { createCatalogProductSearch, withDefaultTaxRate } from './business/catalog-product-search'
 import { DocumentEditor } from './business/document-editor'
 import { editorLinesConfig, isEditorLayout } from './business/document-editor-model'
 import type {
     ActionFieldDef,
+    DocumentFormType,
     DocumentFormsManifest,
     TableMetadata,
 } from './types'
@@ -82,6 +83,39 @@ export interface DocumentFormDialogProps {
     record?: Record<string, any>
     /** Documento origen a precargar en el DocumentEditor (`sources[].key` + id). */
     initialSource?: { key: string; id: string }
+    /**
+     * Tipo con `create_model`: el alta vive en otro modelo. El host navega a la
+     * página de ese modelo con su alta abierta; el diálogo se cierra sin pintar
+     * formulario. Sin este callback un tipo delegado no se ofrece.
+     */
+    onDelegateCreate?: (target: DelegatedCreate) => void
+}
+
+/** Alta delegada a otro modelo (`document_forms.types[].create_model`). */
+export interface DelegatedCreate {
+    /** Clave del modelo destino tal como la declara el manifest (`customers.Invoice`). */
+    model: string
+    /** Tipo que la declaró. */
+    type: DocumentFormType
+}
+
+/**
+ * Si «Crear» de estos formularios es un alta delegada: un único tipo (p. ej.
+ * ya acotado por el filtro de la vista) con `create_model`. Con varios tipos el
+ * selector la ofrece como una tarjeta más.
+ */
+export function delegatedCreate(forms: DocumentFormsManifest | undefined): DelegatedCreate | undefined {
+    const only = forms?.types.length === 1 ? forms.types[0] : undefined
+    const model = only?.create_model?.trim()
+    return only && model ? { model, type: only } : undefined
+}
+
+/** Quita los tipos delegados cuando el host no sabe navegar a otro modelo. */
+export function withoutDelegatedTypes(forms: DocumentFormsManifest | undefined): DocumentFormsManifest | undefined {
+    if (!forms) return forms
+    const types = forms.types.filter((x) => !x.create_model?.trim())
+    if (types.length === forms.types.length) return forms
+    return types.length > 0 ? { ...forms, types } : undefined
 }
 
 /** Manifest efectivo: la prop gana sobre el metadata; sin tipos devuelve undefined. */
@@ -130,11 +164,17 @@ export function DocumentFormDialog({
     currency,
     record,
     initialSource,
+    onDelegateCreate,
 }: DocumentFormDialogProps) {
     const { t, i18n } = useTranslation()
     const api = useApi()
     const orgTaxRate = useOrgTaxRate()
-    const types = forms.types
+    const orgTimeZone = useTimeZone()
+    // Sin onDelegateCreate el host no sabe abrir otro modelo: sus tipos no se ofrecen.
+    const types = useMemo(
+        () => (onDelegateCreate ? forms.types : forms.types.filter((x) => !x.create_model?.trim())),
+        [forms.types, onDelegateCreate],
+    )
     const single = types.length === 1 ? types[0] : undefined
 
     const [typeKey, setTypeKey] = useState<string | null>(initialType ?? single?.key ?? null)
@@ -147,12 +187,26 @@ export function DocumentFormDialog({
     const [saving, setSaving] = useState(false)
 
     const type = useMemo(() => types.find((x) => x.key === typeKey) ?? null, [types, typeKey])
+    const delegatedModel = type?.create_model?.trim() || undefined
+
+    // Tipo con alta en otro modelo: no hay formulario aquí; el host navega.
+    useEffect(() => {
+        if (!open || !type || !delegatedModel) return
+        onDelegateCreate?.({ model: delegatedModel, type })
+        onOpenChange(false)
+        // onDelegateCreate/onOpenChange: callbacks del host, no disparan de nuevo.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [open, type, delegatedModel])
     // Sin buscador inyectado, el paso de renglones solo ofrecía «Renglón libre»
     // y la línea entraba sin precio (DynamicCRUDPage no pasa searchProducts).
-    // Default: el catálogo de productos de la org.
+    // Default: el catálogo de productos de la org. El buscador del host también
+    // recibe el IVA de la org para los productos que no traen su tasa.
     const taxRate = defaultTaxRate ?? orgTaxRate
     const lineSearch = useMemo(
-        () => searchProducts ?? createCatalogProductSearch(api, { model: productModel, defaultTaxRate: taxRate }),
+        () =>
+            searchProducts
+                ? withDefaultTaxRate(searchProducts, taxRate)
+                : createCatalogProductSearch(api, { model: productModel, defaultTaxRate: taxRate }),
         [searchProducts, api, productModel, taxRate],
     )
     const lineCfg = type ? editorLinesConfig(type, forms) : undefined
@@ -172,10 +226,13 @@ export function DocumentFormDialog({
     // Seed field defaults for the chosen type.
     useEffect(() => {
         if (!type) return
-        setFormData({ ...buildFieldDefaults(type.fields, record), ...(type.defaults ?? {}) })
+        setFormData({
+            ...buildFieldDefaults(type.fields, record, undefined, { timeZone: orgTimeZone }),
+            ...(type.defaults ?? {}),
+        })
         setFieldErrors({})
         setFormError(undefined)
-    }, [type, record])
+    }, [type, record, orgTimeZone])
 
     const updateField = (key: string, value: any) => {
         setFormData((prev) => ({ ...prev, [key]: value }))
@@ -276,9 +333,11 @@ export function DocumentFormDialog({
               ? t('documentForm.step_data', { defaultValue: 'Datos' })
               : tl(lineCfg?.title ?? 'Renglones')
 
+    if (open && type && delegatedModel) return null
+
     // layout "editor": una sola pantalla por secciones (DocumentEditor). Sin él
     // sigue el wizard de siempre (retrocompatible).
-    if (open && type && step !== 'type' && isEditorLayout(type)) {
+    if (open && type && step !== 'type' && (isEditorLayout(type) || !!initialSource)) {
         return (
             <Dialog open={open} onOpenChange={onOpenChange}>
                 <DialogContent

package/src/dynamic-columns.tsx

@@ -17,7 +17,7 @@ import { ColumnDef } from '@tanstack/react-table'
 import { format, type Locale } from 'date-fns'
 import { isCalendarDayValue, parseCalendarDate } from './calendar-date'
 import { es, enUS } from 'date-fns/locale'
-import { Calendar, Check, Copy, Mail, Minus, MoreHorizontal } from 'lucide-react'
+import { Calendar, Check, Copy, Mail, Minus } from 'lucide-react'
 import {
     Avatar,
     AvatarFallback,
@@ -25,10 +25,6 @@ import {
     Badge,
     Button,
     Checkbox,
-    DropdownMenu,
-    DropdownMenuContent,
-    DropdownMenuItem,
-    DropdownMenuTrigger,
     InitialsAvatar,
 } from '@asteby/metacore-ui'
 import {
@@ -57,7 +53,7 @@ import { DynamicIcon, isLucideIconName } from './dynamic-icon'
 import { CollectionCell } from './collection-cell'
 import { isNilUuid, normalizeNilUuid } from './nil-uuid'
 import { useOptionsResolver } from './use-options-resolver'
-import { RequiresAddonLock, resolveRequiresAddon, useRequiresAddonLabel } from './requires-addon'
+import { RowActionsMenu } from './row-actions-menu'
 import type { TableMetadata, ColumnDefinition } from './types'
 import { isColumnVisibleInTable } from './column-visibility'
 import type {
@@ -208,35 +204,9 @@ const CodeCell: React.FC<{ text: string; maxLength?: number }> = ({ text, maxLen
     )
 }
 
-/**
- * One entry of the row "…" menu. An action gated by a missing optional addon
- * (`requiresAddon`) stays listed with a lock + tooltip; the click still goes to
- * `onAction`, whose shared handler (useDynamicRowActions) opens the
- * requires-addon dialog instead of executing.
- */
-export function RowActionMenuItem({
-    action,
-    label,
-    onSelect,
-}: {
-    action: any
-    label: React.ReactNode
-    onSelect: (e: React.MouseEvent) => void
-}) {
-    const requirement = resolveRequiresAddon(action)
-    const requiresAddonLabel = useRequiresAddonLabel()
-    return (
-        <DropdownMenuItem
-            onClick={onSelect}
-            title={requirement ? requiresAddonLabel(requirement) : undefined}
-            data-requires-addon={requirement?.key}
-        >
-            <DynamicIcon name={action.icon || 'Zap'} className="mr-2 h-4 w-4" />
-            {label}
-            {requirement && <RequiresAddonLock requirement={requirement} />}
-        </DropdownMenuItem>
-    )
-}
+// RowActionMenuItem vive en row-actions-menu.tsx (junto al menú que lo usa);
+// se re-exporta aquí por compatibilidad (dynamic-kanban, hosts).
+export { RowActionMenuItem } from './row-actions-menu'
 
 /**
  * Lifecycle column used by `requiresState`: prefer `status` (workshop, vehicles,
@@ -1571,28 +1541,14 @@ export function makeDefaultGetDynamicColumns(
                 maxSize: 80,
                 meta: {},
                 cell: ({ row }) => (
-                    <div className="flex items-center justify-end">
-                        <DropdownMenu>
-                            <DropdownMenuTrigger asChild>
-                                <Button variant="ghost" className="h-8 w-8 p-0">
-                                    <span className="sr-only">Abrir menú</span>
-                                    <MoreHorizontal className="h-4 w-4" />
-                                </Button>
-                            </DropdownMenuTrigger>
-                            <DropdownMenuContent align="end">
-                                {resolvedActions
-                                    .filter((action) => isRowActionVisible(action, row.original, lifecycleStageField(metadata)))
-                                    .map((action) => (
-                                        <RowActionMenuItem
-                                            key={action.key}
-                                            action={action}
-                                            label={translateMetadataLabel(action.label, t)}
-                                            onSelect={() => onAction && onAction(action.key, row.original)}
-                                        />
-                                    ))}
-                            </DropdownMenuContent>
-                        </DropdownMenu>
-                    </div>
+                    // Primaria destacada, principales y un «Más…» con las
+                    // secundarias (compartir/imprimir/correo/chat + las que
+                    // aporten addons instalados). Ver row-actions-menu.tsx.
+                    <RowActionsMenu
+                        actions={resolvedActions.filter((action) => isRowActionVisible(action, row.original, lifecycleStageField(metadata)))}
+                        row={row.original}
+                        onAction={onAction}
+                    />
                 ),
             })
         }

package/src/dynamic-crud-page.tsx

@@ -33,7 +33,13 @@ import { useApi } from './api-context'
 import { useMetadataCache } from './metadata-cache'
 import { DynamicTable } from './dynamic-table'
 import { DynamicRecordDialog } from './dialogs/dynamic-record'
-import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from './document-form-dialog'
+import {
+    DocumentFormDialog,
+    resolveDocumentForms,
+    scopeDocumentFormsToFilter,
+    withoutDelegatedTypes,
+    type DelegatedCreate,
+} from './document-form-dialog'
 import { ExportDialog } from './dialogs/export'
 import { ImportDialog } from './dialogs/import'
 import { getModelExtension } from './model-extension-registry'
@@ -102,6 +108,18 @@ export interface DynamicCRUDPageProps {
      * formulario para él.
      */
     filter?: Record<string, string>
+    /**
+     * Abre el alta guiada al montar («crear desde»): tipo de documento y origen
+     * a precargar (`sources[].key` + id), p. ej. leídos de la URL
+     * `?create=<tipo>&from=<fuente>&from_id=<id>`. Solo con document_forms.
+     */
+    initialCreate?: { type?: string; source?: { key: string; id: string } }
+    /**
+     * Alta delegada (`document_forms.types[].create_model`): el host abre la
+     * página del modelo destino con su alta abierta. Sin él, esos tipos no se
+     * ofrecen (y si la vista queda acotada a uno, no hay «Crear»).
+     */
+    onDelegateCreate?: (target: DelegatedCreate) => void
 }
 
 /**
@@ -126,6 +144,8 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
         onChange,
         documentForms,
         filter,
+        initialCreate,
+        onDelegateCreate,
     } = props
 
     const strings = { ...defaultStrings, ...(i18n ?? {}) }
@@ -137,7 +157,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
 
     const [metadata, setMetadata] = useState<TableMetadata | null>(cachedMeta ?? null)
     const [refreshKey, setRefreshKey] = useState(0)
-    const [openCreate, setOpenCreate] = useState(false)
+    const [openCreate, setOpenCreate] = useState(!!initialCreate)
     const [openExport, setOpenExport] = useState(false)
     const [openImport, setOpenImport] = useState(false)
 
@@ -196,7 +216,11 @@ 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 scoped = scopeDocumentFormsToFilter(resolveDocumentForms(metadata, documentForms), filter)
+    const declaredForms = resolveDocumentForms(metadata, documentForms)
+    const scoped = scopeDocumentFormsToFilter(
+        onDelegateCreate ? declaredForms : withoutDelegatedTypes(declaredForms),
+        filter,
+    )
     const guidedForms = scoped.forms
     const showCreate = primary.showGenericCreate && !scoped.hideCreate && can(modelCapability(model, 'create'))
     const showImport = enableCRUD && !effectiveHideImport && can(modelCapability(model, 'import'))
@@ -308,13 +332,16 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
                     model={model}
                     endpoint={dataEndpoint}
                     forms={guidedForms}
+                    initialType={initialCreate?.type}
+                    initialSource={initialCreate?.source}
                     onSaved={handleRefresh}
+                    onDelegateCreate={onDelegateCreate}
                 />
             )}
 
             {showCreate && !guidedForms && (
                 <DynamicRecordDialog
-                    open={openCreate}
+                    open={openCreate && !initialCreate?.source}
                     onOpenChange={setOpenCreate}
                     mode='create'
                     model={model}

package/src/dynamic-row-actions.tsx

@@ -40,6 +40,16 @@ import { DynamicRecordDialog } from './dialogs/dynamic-record'
 import { RequiresAddonDialog, resolveRequiresAddon } from './requires-addon'
 import type { TableMetadata, ActionMetadata, RequiresAddon } from './types'
 
+/**
+ * Destino de una acción link. La query (`?create=…&from_id=…`) va como `search`:
+ * metida en `to` el router la tomaba como parte del path y la ruta no casaba.
+ */
+export function linkNavigation(url: string): { to: string; search?: Record<string, string> } {
+    const i = url.indexOf('?')
+    if (i < 0) return { to: url }
+    return { to: url.slice(0, i), search: Object.fromEntries(new URLSearchParams(url.slice(i + 1))) }
+}
+
 export interface UseDynamicRowActionsParams {
     /** Model key as registered on the backend (e.g. "issue"). */
     model: string
@@ -128,8 +138,8 @@ export function useDynamicRowActions({
         }
         const linkDef = metadata?.actions?.find((a) => a.key === action && a.type === 'link')
         if (linkDef?.linkUrl) {
-            const url = linkDef.linkUrl.replace(/\{(\w+)\}/g, (_: string, field: string) => String(row[field] ?? ''))
-            navigate({ to: url })
+            const url = linkDef.linkUrl.replace(/\{(\w+)\}/g, (_: string, field: string) => encodeURIComponent(String(row[field] ?? '')))
+            navigate(linkNavigation(url) as any)
             return
         }
         const actionDef = metadata?.actions?.find((a) => a.key === action)

package/src/dynamic-table.tsx

@@ -80,6 +80,7 @@ import {
     resolveVirtualizeThreshold,
 } from './table-virtualization'
 import { OptionsContext } from './options-context'
+import { RowActionsModelContext } from './row-actions-menu'
 import type { TableMetadata, ApiResponse, ColumnDefinition } from './types'
 import { getSearchableColumnKeys } from './column-visibility'
 import { visibleRelationInclude } from './list-include'
@@ -1455,6 +1456,7 @@ export function DynamicTable({
     }
 
     return (
+        <RowActionsModelContext.Provider value={model}>
         <OptionsContext.Provider value={{ optionsMap }}>
             <div className='flex flex-col h-full min-h-0 w-full'>
                 <div className='pb-4 shrink-0'>
@@ -1899,6 +1901,7 @@ export function DynamicTable({
                 </Button>
             </DataTableBulkActions>
         </OptionsContext.Provider>
+        </RowActionsModelContext.Provider>
     )
 }
 

package/src/index.ts

@@ -179,8 +179,11 @@ export { FieldGrid, FieldCell, FieldLabel } from './field-grid'
 export {
     ActionModalDispatcher,
     FEDERATED_ACTION_MODAL_TIMEOUT_MS,
+    resolveFieldDefault,
     type ActionModalProps,
+    type FieldDefaultContext,
 } from './action-modal-dispatcher'
+export { todayInZone, isTodayToken } from './calendar-date'
 export { setFederatedActionLoader, type FederatedActionLoader } from './federated-action-loader'
 export {
     ModelActionToolbar,
@@ -207,6 +210,9 @@ export {
     DocumentFormDialog,
     resolveDocumentForms,
     scopeDocumentFormsToFilter,
+    delegatedCreate,
+    withoutDelegatedTypes,
+    type DelegatedCreate,
     type DocumentFormDialogProps,
 } from './document-form-dialog'
 export {
@@ -694,3 +700,28 @@ export {
 // 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'
+
+// Acciones primarias / secundarias de un registro: una sola primaria
+// destacada; compartir/imprimir/correo/chat al «Más…» de la fila y al pie del
+// documento. Las aportadas por addons (registerRecordAction del SDK) sólo con
+// su proveedor instalado y activo.
+export {
+    RowActionsMenu,
+    RowActionMenuItem,
+    RowActionsModelContext,
+    type RowActionsMenuProps,
+} from './row-actions-menu'
+export {
+    classifyActionPriority,
+    isActionProviderActive,
+    isRecordActionProviderActive,
+    resolveRecordActions,
+    splitActionsByPriority,
+    useRecordActions,
+    type ActionPriority,
+    type PrioritizableAction,
+    type RecordActionContext,
+    type RecordActionContribution,
+    type ResolvedRecordAction,
+    type SplitActions,
+} from './record-actions'

package/src/primitives/contributions.ts

@@ -12,6 +12,12 @@
 // `register*` devuelve un disposer; el AddonLoader lo llama al desmontar o
 // recargar el remote y la contribución desaparece sin recargar la página.
 import { createElement, lazy, Suspense, type ComponentType } from 'react'
+import {
+    getModalComponent,
+    registerModalComponent,
+    subscribeActionComponents,
+    type ModalComponentEntry,
+} from '@asteby/metacore-sdk'
 import { slotRegistry } from '../slot'
 
 /** Regiones del DocumentEditor/DocumentPage donde se puede contribuir. */
@@ -76,6 +82,11 @@ function notify() {
     for (const l of [...listeners]) l()
 }
 
+// Los modales viven en el store canónico del SDK (action-registry): cualquier
+// cambio ahí (Registry.registerModal, registerModalComponent, unbind) también
+// re-pinta a quien escucha contribuciones.
+subscribeActionComponents(notify)
+
 /** Suscripción para useSyncExternalStore (contribuciones y modales). */
 export function subscribeContributions(listener: () => void): () => void {
     listeners.add(listener)
@@ -114,6 +125,7 @@ export function registerDocumentContribution<P = DocumentContributionProps>(c: D
         slotRegistry.register(slotIdFor(k, c.region), resolved.component as ComponentType, {
             priority: c.priority ?? 0,
             source: source ?? c.requiresAddon ?? c.id,
+            owner: c.requiresAddon,
         }),
     )
     let disposed = false
@@ -157,6 +169,10 @@ export function resolveContributions(
 // declarativa: el addon registra la clave al cargar. Si el addon dueño no está
 // instalado, resolveFederatedModal devuelve null de inmediato y el dispatcher
 // usa el formulario genérico de la acción en vez de colgarse esperando.
+//
+// No hay mapa propio: es un alias del store canónico de modales por slug de
+// @asteby/metacore-sdk (registerModalComponent), el mismo donde escribe
+// `api.registry.registerModal` de AddonAPI.
 
 export interface FederatedModal<P = any> {
     /** Clave `<addon>.<nombre>`, la misma que `modal` en el manifest. */
@@ -164,33 +180,63 @@ export interface FederatedModal<P = any> {
     addon: string
     /** El dispatcher le pasa ActionModalProps (open, onOpenChange, action, model, record…). */
     load: () => Promise<{ default: ComponentType<P> }>
+    /** Presente cuando el modal se registró ya cargado (`api.registry.registerModal`). */
+    component?: ComponentType<P>
 }
 
-const modals = new Map<string, FederatedModal>()
+/** Vista FederatedModal de cada entrada del store (identidad estable por entrada). */
+const views = new WeakMap<ModalComponentEntry, FederatedModal>()
 const modalComponents = new WeakMap<FederatedModal, ComponentType<any>>()
+/** Disposers de lo registrado por este alias (sólo __resetContributions los usa). */
+const aliasDisposers = new Set<() => void>()
 
+/**
+ * @deprecated Usa `registerModalComponent({ slug, load, owner })` de
+ * `@asteby/metacore-sdk` o `api.registry.registerModal` desde el plugin. Se
+ * mantiene como alias compatible: escribe en el mismo store.
+ */
 export function registerFederatedModal(m: FederatedModal): () => void {
-    modals.set(m.key, m)
-    notify()
+    const dispose = registerModalComponent({ slug: m.key, owner: m.addon, load: m.load, component: m.component })
+    const stored = getModalComponent(m.key)
+    if (stored) views.set(stored, m)
+    aliasDisposers.add(dispose)
     return () => {
-        if (modals.get(m.key) === m) {
-            modals.delete(m.key)
-            notify()
+        aliasDisposers.delete(dispose)
+        dispose()
+    }
+}
+
+function viewOf(e: ModalComponentEntry): FederatedModal {
+    let v = views.get(e)
+    if (!v) {
+        const component = e.component
+        v = {
+            key: e.slug,
+            addon: e.owner ?? '',
+            load: e.load ?? (async () => ({ default: component! })),
+            component,
         }
+        views.set(e, v)
     }
+    return v
 }
 
-/** null si el modal no está registrado o su addon no está instalado. Nunca espera. */
+/**
+ * Modal del slug en el store canónico, o null si no está registrado o su addon
+ * dueño no está instalado. Nunca espera.
+ */
 export function resolveFederatedModal(key: string, isInstalled: IsAddonInstalled): FederatedModal | null {
-    const m = modals.get(key)
-    return m && isInstalled(m.addon) ? m : null
+    const m = getModalComponent(key)
+    return m && (!m.owner || isInstalled(m.owner)) ? viewOf(m) : null
 }
 
 /**
- * Componente `React.lazy` del modal resuelto, memoizado por registro (no se
- * re-crea en cada render). Quien lo pinta lo envuelve en `<Suspense>`.
+ * Componente del modal resuelto: el ya cargado si lo hay; si no, un
+ * `React.lazy` memoizado por registro (no se re-crea en cada render; quien lo
+ * pinta lo envuelve en `<Suspense>`).
  */
 export function federatedModalComponent<P = any>(m: FederatedModal<P>): ComponentType<P> {
+    if (m.component) return m.component
     let C = modalComponents.get(m)
     if (!C) {
         C = lazy(m.load) as unknown as ComponentType<any>
@@ -203,6 +249,7 @@ export function federatedModalComponent<P = any>(m: FederatedModal<P>): Componen
 export function __resetContributions(): void {
     for (const e of [...contribs.values()]) e.dispose()
     contribs.clear()
-    modals.clear()
+    for (const d of [...aliasDisposers]) d()
+    aliasDisposers.clear()
     notify()
 }

package/src/record-actions.ts

@@ -0,0 +1,101 @@
+// Acciones primarias / secundarias de un registro.
+//
+// Una pantalla de registro tiene UNA acción destacada (la primaria) y el resto
+// en su lugar: lo de compartir, imprimir, correo, chat, descargar PDF/XML es
+// secundario — va al pie del documento (DocumentSecondaryBar) y al «Más…» del
+// menú de fila, nunca compitiendo con la primaria.
+//
+// Dos fuentes, una misma clasificación:
+//   - acciones del modelo (metadata `actions[]`): manifest v3 `priority`, o la
+//     convención por clave si no la declara;
+//   - acciones aportadas por addons o por el host (registerRecordAction del
+//     store canónico de @asteby/metacore-sdk), filtradas por su proveedor
+//     instalado y activo (InstalledAddonsProvider).
+import { useMemo, useSyncExternalStore } from 'react'
+import {
+    listRecordActions,
+    subscribeActionComponents,
+    type ActionPriority,
+    type OwnedRecordAction,
+    type RecordActionContext,
+    type RecordActionContribution,
+} from '@asteby/metacore-sdk'
+import { useInstalledAddons, type InstalledAddonsValue } from './installed-addons-context'
+
+export * from './action-priority'
+export type { RecordActionContext, RecordActionContribution }
+
+export interface ResolvedRecordAction {
+    /** Id de la contribución (o `<id>:<item>` si viene de `expand`). */
+    key: string
+    label: string
+    icon?: string
+    priority: ActionPriority
+    owner?: string
+    run?: () => unknown
+    render?: RecordActionContribution['render']
+}
+
+function modelMatches(models: RecordActionContribution['models'], model: string): boolean {
+    if (!models || models === '*') return true
+    const m = model.toLowerCase()
+    return models.some((x) => {
+        const k = x.toLowerCase()
+        return k === m || k.endsWith(`.${m}`) || m.endsWith(`.${k}`)
+    })
+}
+
+/** ¿El proveedor de la contribución está instalado y activo? Sin provider: sí. */
+export function isRecordActionProviderActive(row: OwnedRecordAction, installed: InstalledAddonsValue | null): boolean {
+    if (!installed) return true
+    const req = row.contribution.requires
+    if (req?.addon && !installed.addons.has(req.addon)) return false
+    if (req?.capability && !installed.capabilities.has(req.capability)) return false
+    if (!req?.addon && !req?.capability && row.owner && !installed.addons.has(row.owner)) return false
+    return true
+}
+
+/** Contribuciones aplicables al registro, filtradas por proveedor y ordenadas. Pura. */
+export function resolveRecordActions(
+    rows: readonly OwnedRecordAction[],
+    ctx: RecordActionContext,
+    installed: InstalledAddonsValue | null,
+): ResolvedRecordAction[] {
+    const out: ResolvedRecordAction[] = []
+    const sorted = [...rows].sort(
+        (a, b) => (a.contribution.order ?? 0) - (b.contribution.order ?? 0) || a.contribution.id.localeCompare(b.contribution.id),
+    )
+    for (const row of sorted) {
+        const c = row.contribution
+        if (!modelMatches(c.models, ctx.model)) continue
+        if (!isRecordActionProviderActive(row, installed)) continue
+        if (c.when && !c.when(ctx)) continue
+        const priority = c.priority ?? 'secondary'
+        if (c.expand) {
+            for (const item of c.expand(ctx)) {
+                out.push({ key: `${c.id}:${item.key}`, label: item.label, icon: item.icon ?? c.icon, priority, owner: row.owner, run: item.run })
+            }
+            continue
+        }
+        out.push({
+            key: c.id,
+            label: c.label ?? c.id,
+            icon: c.icon,
+            priority,
+            owner: row.owner,
+            run: c.run ? () => c.run!(ctx) : undefined,
+            render: c.render,
+        })
+    }
+    return out
+}
+
+/** Acciones aportadas al registro (`model`, `record`), reactivas a register/unbind. */
+export function useRecordActions(model: string, record: Record<string, unknown> | null | undefined): ResolvedRecordAction[] {
+    const rows = useSyncExternalStore(subscribeActionComponents, listRecordActions, listRecordActions)
+    const installed = useInstalledAddons()
+    return useMemo(
+        () => (record ? resolveRecordActions(rows, { model, record }, installed) : []),
+        [rows, model, record, installed],
+    )
+}