@asteby/metacore-runtime-react 48.0.0 → 49.0.0

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

@@ -694,3 +694,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],
+    )
+}

package/src/row-actions-menu.tsx

@@ -0,0 +1,159 @@
+// RowActionsMenu — el «…» de una fila: la acción primaria (si hay) arriba y
+// destacada, las principales debajo y las secundarias (compartir, imprimir,
+// correo, chat, PDF/XML y lo que aporten addons vía registerRecordAction)
+// agrupadas en un «Más…» discreto. Una acción por capacidad sin proveedor
+// activo, o una contribución cuyo addon no está instalado, no aparece.
+//
+// DynamicTable lo usa por defecto (getDynamicColumns) y los hosts que arman su
+// propia columna de acciones lo reutilizan en vez de duplicar el menú.
+import * as React from 'react'
+import { useTranslation } from 'react-i18next'
+import { MoreHorizontal } from 'lucide-react'
+// Root entry on purpose (not '/primitives'): see dropdown-menu-entry.test.ts.
+import {
+    Button,
+    DropdownMenu,
+    DropdownMenuContent,
+    DropdownMenuItem,
+    DropdownMenuSeparator,
+    DropdownMenuSub,
+    DropdownMenuSubContent,
+    DropdownMenuSubTrigger,
+    DropdownMenuTrigger,
+} from '@asteby/metacore-ui'
+import { DynamicIcon } from './dynamic-icon'
+import { translateMetadataLabel } from './dynamic-columns-helpers'
+import { RequiresAddonLock, resolveRequiresAddon, useRequiresAddonLabel } from './requires-addon'
+import { useInstalledAddons } from './installed-addons-context'
+import { isActionProviderActive, splitActionsByPriority, useRecordActions, type ResolvedRecordAction } from './record-actions'
+
+/**
+ * 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,
+    className,
+}: {
+    action: any
+    label: React.ReactNode
+    onSelect: (e: React.MouseEvent) => void
+    className?: string
+}) {
+    const requirement = resolveRequiresAddon(action)
+    const requiresAddonLabel = useRequiresAddonLabel()
+    return (
+        <DropdownMenuItem
+            onClick={onSelect}
+            title={requirement ? requiresAddonLabel(requirement) : undefined}
+            data-requires-addon={requirement?.key}
+            data-action={action.key}
+            className={className}
+        >
+            <DynamicIcon name={action.icon || 'Zap'} className="mr-2 h-4 w-4" />
+            {label}
+            {requirement && <RequiresAddonLock requirement={requirement} />}
+        </DropdownMenuItem>
+    )
+}
+
+export interface RowActionsMenuProps {
+    /** Acciones de metadata ya filtradas por estado/condición de la fila. */
+    actions: any[]
+    row: Record<string, any>
+    /** Modelo de la fila: resuelve las acciones aportadas por addons. */
+    model?: string
+    onAction?: (actionKey: string, row: any) => void
+    /** Sustituye el ícono del disparador (p. ej. un spinner mientras imprime). */
+    triggerIcon?: React.ReactNode
+    disabled?: boolean
+}
+
+/**
+ * Modelo de las filas que pinta la tabla. DynamicTable lo provee: la factoría
+ * de columnas (getDynamicColumns) no recibe el modelo y el menú lo necesita
+ * para resolver las acciones aportadas por addons.
+ */
+export const RowActionsModelContext = React.createContext<string | undefined>(undefined)
+
+type MenuEntry =
+    | { kind: 'action'; action: any }
+    | { kind: 'contribution'; item: ResolvedRecordAction }
+
+export function RowActionsMenu({ actions, row, model, onAction, triggerIcon, disabled }: RowActionsMenuProps) {
+    const { t } = useTranslation()
+    const installed = useInstalledAddons()
+    const ctxModel = React.useContext(RowActionsModelContext)
+    const recordModel = model ?? ctxModel
+    const contributed = useRecordActions(recordModel ?? '', recordModel ? row : null).filter((c) => !!c.run)
+
+    const available = actions.filter((a) => isActionProviderActive(a, installed))
+    const { primary, main, secondary } = splitActionsByPriority(available)
+    const mainEntries: MenuEntry[] = main.map((action) => ({ kind: 'action', action }))
+    const secondaryEntries: MenuEntry[] = secondary.map((action) => ({ kind: 'action', action }))
+    for (const item of contributed) {
+        ;(item.priority === 'primary' ? mainEntries : secondaryEntries).push({ kind: 'contribution', item })
+    }
+
+    if (!primary && mainEntries.length === 0 && secondaryEntries.length === 0) return null
+
+    const renderEntry = (e: MenuEntry) =>
+        e.kind === 'action' ? (
+            <RowActionMenuItem
+                key={e.action.key}
+                action={e.action}
+                label={translateMetadataLabel(e.action.label, t)}
+                onSelect={() => onAction?.(e.action.key, row)}
+            />
+        ) : (
+            <DropdownMenuItem key={e.item.key} data-action={e.item.key} onClick={() => void e.item.run?.()}>
+                <DynamicIcon name={e.item.icon || 'Share2'} className="mr-2 h-4 w-4" />
+                {t(e.item.label, { defaultValue: e.item.label })}
+            </DropdownMenuItem>
+        )
+
+    const hasMain = !!primary || mainEntries.length > 0
+    const moreLabel = t('datatable.more_actions', { defaultValue: 'Más…' })
+
+    return (
+        <div className="flex items-center justify-end">
+            <DropdownMenu>
+                <DropdownMenuTrigger asChild>
+                    <Button variant="ghost" className="h-8 w-8 p-0" disabled={disabled} onClick={(e: React.MouseEvent) => e.stopPropagation()}>
+                        <span className="sr-only">{t('datatable.open_menu', { defaultValue: 'Abrir menú' })}</span>
+                        {triggerIcon ?? <MoreHorizontal className="h-4 w-4" />}
+                    </Button>
+                </DropdownMenuTrigger>
+                <DropdownMenuContent align="end" onClick={(e: React.MouseEvent) => e.stopPropagation()}>
+                    {primary ? (
+                        <RowActionMenuItem
+                            action={primary}
+                            label={translateMetadataLabel(primary.label, t)}
+                            onSelect={() => onAction?.(primary.key, row)}
+                            className="font-semibold"
+                        />
+                    ) : null}
+                    {mainEntries.map(renderEntry)}
+                    {secondaryEntries.length > 0 && hasMain ? (
+                        <>
+                            <DropdownMenuSeparator />
+                            <DropdownMenuSub>
+                                <DropdownMenuSubTrigger data-row-more="" className="text-muted-foreground">
+                                    {moreLabel}
+                                </DropdownMenuSubTrigger>
+                                <DropdownMenuSubContent data-row-secondary="">{secondaryEntries.map(renderEntry)}</DropdownMenuSubContent>
+                            </DropdownMenuSub>
+                        </>
+                    ) : (
+                        // Sin principales no hay con qué competir: lista plana.
+                        secondaryEntries.map(renderEntry)
+                    )}
+                </DropdownMenuContent>
+            </DropdownMenu>
+        </div>
+    )
+}

package/src/slot.tsx

@@ -1,56 +1,19 @@
-// Slot / SlotRegistry — named extension points the host renders and addons
-// contribute to at register() time. Keyed by a slot id (e.g. "dashboard.widgets",
+// Slot — named extension points the host renders and addons contribute to at
+// register() time. Keyed by a slot id (e.g. "dashboard.widgets",
 // "invoice.footer"). Each contribution is an arbitrary React element factory.
+//
+// El store es `slotStore` de @asteby/metacore-sdk: el mismo donde escribe
+// `api.registry.registerSlot` (AddonAPI) y `registerDocumentContribution`, así
+// que hay una sola lista por slot. Una entrada con addon dueño (`owner`) que
+// consta como NO instalado (InstalledAddonsProvider) no se pinta.
 import React, { useSyncExternalStore } from 'react'
+import { slotStore, type SlotComponent, type SlotEntry } from '@asteby/metacore-sdk'
+import { useInstalledAddons } from './installed-addons-context'
 
-export type SlotComponent<P = any> = React.ComponentType<P>
+export type { SlotComponent, SlotEntry }
 
-interface SlotEntry {
-    id: string
-    component: SlotComponent
-    priority: number
-    source?: string
-}
-
-type Listener = () => void
-
-class SlotRegistryImpl {
-    private slots = new Map<string, SlotEntry[]>()
-    private listeners = new Set<Listener>()
-
-    register(slotId: string, component: SlotComponent, opts?: { priority?: number; source?: string }): () => void {
-        const entry: SlotEntry = { id: slotId, component, priority: opts?.priority ?? 0, source: opts?.source }
-        const list = this.slots.get(slotId) ?? []
-        list.push(entry)
-        // Higher priority renders first — canonical across SDK and runtime-react.
-        // See docs/slot-priority.md.
-        list.sort((a, b) => b.priority - a.priority)
-        this.slots.set(slotId, list)
-        this.emit()
-        return () => {
-            const arr = this.slots.get(slotId)
-            if (!arr) return
-            const idx = arr.indexOf(entry)
-            if (idx >= 0) {
-                arr.splice(idx, 1)
-                this.emit()
-            }
-        }
-    }
-
-    get(slotId: string): SlotEntry[] {
-        return this.slots.get(slotId) ?? []
-    }
-
-    subscribe(listener: Listener): () => void {
-        this.listeners.add(listener)
-        return () => { this.listeners.delete(listener) }
-    }
-
-    private emit() { this.listeners.forEach(l => l()) }
-}
-
-export const slotRegistry = new SlotRegistryImpl()
+/** Alias histórico del store canónico (`slotRegistry.register/get/subscribe`). */
+export const slotRegistry = slotStore
 
 export interface SlotProps {
     /** Slot id. */
@@ -62,11 +25,13 @@ export interface SlotProps {
 }
 
 export function Slot({ name, props, fallback = null }: SlotProps) {
-    const entries = useSyncExternalStore(
-        (cb) => slotRegistry.subscribe(cb),
-        () => slotRegistry.get(name),
-        () => slotRegistry.get(name),
+    const all = useSyncExternalStore(
+        (cb) => slotStore.subscribe(cb),
+        () => slotStore.get(name),
+        () => slotStore.get(name),
     )
+    const installed = useInstalledAddons()
+    const entries = installed ? all.filter((e) => !e.owner || installed.addons.has(e.owner)) : all
     if (entries.length === 0) return <>{fallback}</>
     return (
         <>

package/src/types.ts

@@ -141,6 +141,20 @@ export interface DocumentFormSource {
     option_filter?: unknown
     /** Addon requerido (gating de UI; el servidor revalida). */
     requires_addon?: string
+    /** Columna de cantidad del renglón origen (default `quantity`). */
+    qty_field?: string
+    /**
+     * Columna del renglón de ESTE documento que guarda el id del renglón origen
+     * (p. ej. `sales_order_item_id`). Con ella el host sirve lo pendiente por
+     * renglón (`<endpoint>/source-lines`) y rechaza al guardar si se excede.
+     */
+    line_link_field?: string
+    /** Columna del renglón origen que ya trae lo pendiente (la mantiene su addon). */
+    remaining_qty_field?: string
+    /** Endpoint del addon que sirve los renglones con `remaining_quantity` (`?id=`). */
+    remaining_endpoint?: string
+    /** Estados de este documento que no consumen el origen (cancelada…). */
+    exclude_states?: string[]
 }
 
 /** Vista previa: acción de fila sobre el borrador, llamada con `analyze: true`. */
@@ -907,6 +921,18 @@ export interface ActionDefinition {
      */
     replaces_create?: boolean
     replacesCreate?: boolean
+    /**
+     * Manifest v3 `priority`. "primary": la única acción destacada del menú de
+     * fila / cabecera. "secondary": compartir, imprimir, correo, chat → pie del
+     * documento y «Más…» del menú de fila. Sin valor: convención por clave
+     * (ver classifyActionPriority).
+     */
+    priority?: 'primary' | 'secondary'
+    /**
+     * Cómo despacha (served `trigger`). `type: "capability"` necesita un addon
+     * que provea `capability`; sin proveedor activo la acción no se ofrece.
+     */
+    trigger?: { type: string; capability?: string; connector?: string }
     /**
      * Optional addon this action depends on, stamped by the host only while it
      * is NOT installed (served as `requires_addon`; read through
@@ -958,6 +984,8 @@ export interface ActionMetadata {
     /** Federated modal slug "<addon_key>.<action_key>"; see ActionModalDispatcher. */
     modal?: string
     placement?: 'row' | 'table' | 'create'
+    /** Manifest v3 `priority`; ver ActionDefinition.priority. */
+    priority?: 'primary' | 'secondary'
     /**
      * Optional addon this action depends on, stamped by the host only while it
      * is NOT installed (served as `requires_addon`; read through