@asteby/metacore-runtime-react 45.0.0 → 45.2.0

package/src/business/product-search.ts

@@ -0,0 +1,108 @@
+// Búsqueda unificada de producto (productos, llantas y variantes).
+// Un solo cuadro acepta: medida de llanta «205/55R16», código de barras (EAN/UPC
+// numérico), SKU/clave de proveedor o texto libre. `parseProductQuery` clasifica
+// la entrada para que el backend/addon elija el índice correcto.
+import type { LineItem } from './line-items'
+import { makeLine } from './line-items'
+
+export interface TireSize {
+    width: number
+    ratio: number
+    rim: number
+    /** Forma canónica `205/55R16`. */
+    normalized: string
+}
+
+export type ProductQuery =
+    | { kind: 'empty'; raw: string }
+    | { kind: 'barcode'; raw: string; barcode: string }
+    | { kind: 'tire_size'; raw: string; tire: TireSize }
+    | { kind: 'text'; raw: string; text: string }
+
+// 205/55R16, 205 55 16, 205-55-16, 205/55ZR16, 2055516 (sin separadores).
+const TIRE_RE = /^(\d{3})\s*[\/\-x\s]?\s*(\d{2})\s*[\/\-x\s]?\s*(?:z?r|-)?\s*(\d{2})$/i
+const BARCODE_RE = /^\d{8,14}$/
+
+export function parseTireSize(input: string): TireSize | null {
+    const s = input.trim()
+    // 7 dígitos pegados también son medida, pero 8+ dígitos es código de barras.
+    if (BARCODE_RE.test(s)) return null
+    const m = TIRE_RE.exec(s)
+    if (!m) return null
+    const width = Number(m[1])
+    const ratio = Number(m[2])
+    const rim = Number(m[3])
+    if (width < 125 || width > 395 || ratio < 25 || ratio > 95 || rim < 10 || rim > 26) return null
+    return { width, ratio, rim, normalized: `${width}/${ratio}R${rim}` }
+}
+
+export function parseProductQuery(raw: string): ProductQuery {
+    const s = raw.trim()
+    if (!s) return { kind: 'empty', raw }
+    if (BARCODE_RE.test(s)) return { kind: 'barcode', raw, barcode: s }
+    const tire = parseTireSize(s)
+    if (tire) return { kind: 'tire_size', raw, tire }
+    return { kind: 'text', raw, text: s }
+}
+
+export interface StockByWarehouse {
+    warehouse_id: string
+    warehouse_name?: string
+    available: number
+}
+
+export interface ProductVariant {
+    id: string
+    /** «Rin 16 · 205/55R16 · 91V». */
+    label: string
+    sku?: string
+    barcode?: string
+    price?: number
+    stock?: StockByWarehouse[]
+}
+
+export interface ProductResult {
+    id: string
+    name: string
+    sku?: string
+    barcode?: string
+    /** Clave del proveedor (búsqueda por SKU del proveedor). */
+    supplier_sku?: string
+    kind?: 'product' | 'tire' | 'service' | 'bundle'
+    price?: number
+    tax_rate?: number
+    tire?: TireSize
+    variants?: ProductVariant[]
+    stock?: StockByWarehouse[]
+    /** Paquetes automáticos: ids/nombres que se sugieren junto al producto. */
+    bundle_items?: Array<{ product_id: string; name: string; quantity: number }>
+}
+
+/** Existencia disponible: de la variante o del producto, en un almacén o en total. */
+export function availableStock(
+    source: { stock?: StockByWarehouse[] },
+    warehouseId?: string,
+): number | undefined {
+    if (!source.stock) return undefined
+    return source.stock
+        .filter((s) => !warehouseId || s.warehouse_id === warehouseId)
+        .reduce((n, s) => n + s.available, 0)
+}
+
+/** Producto (+ variante) → renglón listo para <LineItemsEditor>. */
+export function productToLine(
+    p: ProductResult,
+    variant?: ProductVariant,
+    opts: { warehouseId?: string; quantity?: number } = {},
+): LineItem {
+    const src = variant ?? p
+    return makeLine({
+        product_id: variant?.id ?? p.id,
+        sku: variant?.sku ?? p.sku,
+        description: variant ? `${p.name} · ${variant.label}` : p.name,
+        quantity: opts.quantity ?? 1,
+        unit_price: variant?.price ?? p.price ?? 0,
+        tax_rate: p.tax_rate ?? 0,
+        available: availableStock(src, opts.warehouseId) ?? availableStock(p, opts.warehouseId),
+    })
+}

package/src/business/refund-destination.tsx

@@ -0,0 +1,121 @@
+// RefundDestination — a dónde regresa el dinero: efectivo, tarjeta, monedero,
+// saldo a favor o NC CFDI (benchmark §7, POS-3/DEV-*).
+import { useMemo } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Button, Input } from '@asteby/metacore-ui'
+import { useFormatter, roundMoney } from './format'
+import {
+    DEFAULT_REFUND_DESTINATIONS,
+    singleDestination,
+    validateRefund,
+    type RefundAllocation,
+    type RefundDestinationKind,
+    type RefundDestinationOption,
+    type RefundValidation,
+} from './refund'
+
+export interface RefundDestinationProps {
+    /** Monto total a reembolsar. */
+    total: number
+    value: RefundAllocation[]
+    onChange: (allocations: RefundAllocation[]) => void
+    /** Destinos ofrecidos (default: los cinco). Filtra/limita según el documento. */
+    options?: RefundDestinationOption[]
+    /** Emite la validación tras cada cambio (para bloquear «Confirmar»). */
+    onValidate?: (v: RefundValidation) => void
+    /** Errores del servidor `"<índice>.<campo>"`. */
+    serverErrors?: Record<string, string>
+    /** Permite repartir entre varios destinos. Default false (un solo destino). */
+    allowSplit?: boolean
+    currency?: string
+    disabled?: boolean
+}
+
+export function RefundDestination({
+    total,
+    value,
+    onChange,
+    options = DEFAULT_REFUND_DESTINATIONS,
+    onValidate,
+    serverErrors,
+    allowSplit = false,
+    currency,
+    disabled,
+}: RefundDestinationProps) {
+    const { t } = useTranslation()
+    const fmt = useFormatter({ currency })
+    const validation = useMemo(() => validateRefund(total, value, options), [total, value, options])
+    const errors = { ...validation.errors, ...serverErrors }
+    const chosen = (k: RefundDestinationKind) => value.some((a) => a.kind === k)
+
+    const emit = (next: RefundAllocation[]) => {
+        onChange(next)
+        onValidate?.(validateRefund(total, next, options))
+    }
+    const toggle = (o: RefundDestinationOption) => {
+        if (!allowSplit) return emit(singleDestination(o.kind, total))
+        if (chosen(o.kind)) return emit(value.filter((a) => a.kind !== o.kind))
+        emit([...value, { kind: o.kind, amount: Math.max(0, roundMoney(total - validation.allocated)) }])
+    }
+
+    return (
+        <div data-slot="refund-destination" className="space-y-2">
+            <p className="text-sm text-muted-foreground">
+                {t('refund.amount', { defaultValue: 'Monto a reembolsar' })}: <span className="font-semibold text-foreground">{fmt.money(total)}</span>
+            </p>
+            <div role={allowSplit ? 'group' : 'radiogroup'} className="grid gap-2 sm:grid-cols-2">
+                {options.map((o) => {
+                    const off = o.available === false
+                    const on = chosen(o.kind)
+                    return (
+                        <Button
+                            key={o.kind}
+                            type="button"
+                            variant={on ? 'default' : 'outline'}
+                            role={allowSplit ? 'checkbox' : 'radio'}
+                            aria-checked={on}
+                            disabled={disabled || off}
+                            title={off ? o.disabledReason : undefined}
+                            className="h-auto justify-start whitespace-normal py-2 text-left"
+                            onClick={() => toggle(o)}
+                        >
+                            <span>
+                                <span className="block">{o.label}</span>
+                                {off && o.disabledReason && <span className="block text-xs opacity-70">{o.disabledReason}</span>}
+                                {!off && o.maxAmount != null && <span className="block text-xs opacity-70">{t('refund.max', { defaultValue: 'Máx.' })} {fmt.money(o.maxAmount)}</span>}
+                            </span>
+                        </Button>
+                    )
+                })}
+            </div>
+
+            {value.map((a, i) => (
+                <div key={a.kind} className="grid grid-cols-[1fr_8rem_10rem] items-start gap-2">
+                    <span className="pt-2 text-sm">{options.find((o) => o.kind === a.kind)?.label ?? a.kind}</span>
+                    <div>
+                        <Input
+                            inputMode="decimal"
+                            className="text-right"
+                            value={String(a.amount)}
+                            disabled={disabled || !allowSplit}
+                            aria-invalid={!!errors[`${i}.amount`]}
+                            onChange={(e) => emit(value.map((x, j) => (j === i ? { ...x, amount: Number(e.target.value.replace(',', '.')) || 0 } : x)))}
+                        />
+                        {errors[`${i}.amount`] && <p className="mt-0.5 text-xs text-destructive">{errors[`${i}.amount`]}</p>}
+                    </div>
+                    {(a.kind === 'card' || a.kind === 'credit_note') && (
+                        <Input
+                            placeholder={a.kind === 'card' ? t('refund.cardRef', { defaultValue: 'Referencia' }) : t('refund.ncRef', { defaultValue: 'Folio / UUID relacionado' })}
+                            value={a.reference ?? ''}
+                            disabled={disabled}
+                            onChange={(e) => emit(value.map((x, j) => (j === i ? { ...x, reference: e.target.value } : x)))}
+                        />
+                    )}
+                    {errors[`${i}.kind`] && <p className="col-span-3 text-xs text-destructive">{errors[`${i}.kind`]}</p>}
+                </div>
+            ))}
+
+            {validation.form && value.length > 0 && <p role="alert" className="text-sm text-destructive">{validation.form}</p>}
+        </div>
+    )
+}

package/src/business/refund.ts

@@ -0,0 +1,71 @@
+// Destino de un reembolso (ReturnWizard, cancelación de apartado, anticipos).
+// Lógica pura de <RefundDestination>.
+import { roundMoney, toAmount } from './format'
+
+export type RefundDestinationKind = 'cash' | 'card' | 'wallet' | 'store_credit' | 'credit_note'
+
+export interface RefundDestinationOption {
+    kind: RefundDestinationKind
+    label: string
+    /** Tope reembolsable por este destino (p. ej. lo pagado con tarjeta). */
+    maxAmount?: number
+    /** false → la opción se muestra deshabilitada con `disabledReason`. */
+    available?: boolean
+    disabledReason?: string
+}
+
+export interface RefundAllocation {
+    kind: RefundDestinationKind
+    amount: number
+    /** Referencia del reembolso a tarjeta / folio de NC relacionada. */
+    reference?: string
+}
+
+/** Catálogo por defecto: el llamador filtra/limita según el documento. */
+export const DEFAULT_REFUND_DESTINATIONS: RefundDestinationOption[] = [
+    { kind: 'cash', label: 'Efectivo' },
+    { kind: 'card', label: 'Tarjeta' },
+    { kind: 'wallet', label: 'Monedero' },
+    { kind: 'store_credit', label: 'Saldo a favor' },
+    { kind: 'credit_note', label: 'Nota de crédito (CFDI)' },
+]
+
+export interface RefundValidation {
+    errors: Record<string, string>
+    form?: string
+    allocated: number
+    remaining: number
+    valid: boolean
+}
+
+export function validateRefund(
+    total: number,
+    allocations: RefundAllocation[],
+    options: RefundDestinationOption[] = DEFAULT_REFUND_DESTINATIONS,
+): RefundValidation {
+    const byKind = new Map(options.map((o) => [o.kind, o]))
+    const errors: Record<string, string> = {}
+    let allocated = 0
+    const seen = new Set<string>()
+    allocations.forEach((a, i) => {
+        const o = byKind.get(a.kind)
+        const amt = toAmount(a.amount)
+        allocated += amt
+        if (!o || o.available === false) errors[`${i}.kind`] = o?.disabledReason ?? 'Destino no disponible'
+        if (seen.has(a.kind)) errors[`${i}.kind`] = 'Ese destino ya está en la lista'
+        seen.add(a.kind)
+        if (amt <= 0) errors[`${i}.amount`] = 'Captura un monto mayor a cero'
+        else if (o?.maxAmount != null && amt > o.maxAmount) errors[`${i}.amount`] = `El máximo para ${o.label} es ${o.maxAmount}`
+    })
+    allocated = roundMoney(allocated)
+    const remaining = roundMoney(total - allocated)
+    let form: string | undefined
+    if (allocations.length === 0) form = 'Elige a dónde se devuelve el dinero'
+    else if (remaining !== 0) form = remaining > 0 ? 'Falta asignar parte del reembolso' : 'La suma excede el monto a reembolsar'
+    return { errors, form, allocated, remaining, valid: !form && Object.keys(errors).length === 0 }
+}
+
+/** Un solo destino cubriendo todo el monto (caso común). */
+export function singleDestination(kind: RefundDestinationKind, total: number): RefundAllocation[] {
+    return [{ kind, amount: roundMoney(total) }]
+}

package/src/business/use-async-search.ts

@@ -0,0 +1,43 @@
+import { useEffect, useState } from 'react'
+import { useDebouncedValue } from '../use-debounced-value'
+
+/** Búsqueda async con debounce y cancelación. `search` debe ser estable (useCallback). */
+export function useAsyncSearch<T>(
+    query: string,
+    search: (q: string, signal: AbortSignal) => Promise<T[]>,
+    opts: { minChars?: number; delay?: number } = {},
+): { results: T[]; loading: boolean; error: boolean } {
+    const { minChars = 2, delay = 250 } = opts
+    const q = useDebouncedValue(query.trim(), delay)
+    const [results, setResults] = useState<T[]>([])
+    const [loading, setLoading] = useState(false)
+    const [error, setError] = useState(false)
+
+    useEffect(() => {
+        if (q.length < minChars) {
+            setResults([])
+            setLoading(false)
+            setError(false)
+            return
+        }
+        const ctrl = new AbortController()
+        setLoading(true)
+        setError(false)
+        search(q, ctrl.signal)
+            .then((rows) => {
+                if (!ctrl.signal.aborted) setResults(rows)
+            })
+            .catch(() => {
+                if (!ctrl.signal.aborted) {
+                    setResults([])
+                    setError(true)
+                }
+            })
+            .finally(() => {
+                if (!ctrl.signal.aborted) setLoading(false)
+            })
+        return () => ctrl.abort()
+    }, [q, search, minChars])
+
+    return { results, loading, error }
+}

package/src/document/__tests__/document-page.test.tsx

@@ -0,0 +1,107 @@
+// @vitest-environment happy-dom
+//
+// DocumentPage: dos badges independientes con texto explícito, 1 primaria +
+// secundarias visibles, destructiva separada y bloqueada con motivo, botones
+// inteligentes con contador y pestaña «records» desde una fuente.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render, screen, fireEvent, waitFor } from '@testing-library/react'
+
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (k: string, o?: any) => o?.defaultValue ?? k }),
+}))
+vi.mock('../../dynamic-icon', () => ({ DynamicIcon: () => null }))
+
+import { DocumentPage } from '../document-page'
+import { ApiProvider, type ApiClient } from '../../api-context'
+import type { DocumentPageRegistration } from '../registry'
+
+afterEach(cleanup)
+
+const registration: DocumentPageRegistration = {
+    spec: {
+        model: 'invoices',
+        title: '{{number}}',
+        statuses: [
+            {
+                id: 'fiscal',
+                label: 'Estado fiscal',
+                field: '$.fiscal',
+                states: [{ value: 'stamped', label: 'Timbrada', tone: 'success' }],
+            },
+            {
+                id: 'billing',
+                label: 'Estado de cobro',
+                field: '$.billing',
+                states: [{ value: 'partial', label: 'Parcial', tone: 'caution' }],
+            },
+        ],
+        metrics: [{ label: 'Total', path: 'total', format: 'money' }],
+        actions: [
+            { key: 'pay', label: 'Registrar pago' },
+            { key: 'send', label: 'Enviar' },
+            { key: 'pdf', label: 'Descargar PDF', openUrl: '{{$.pdf}}' },
+            {
+                key: 'cancel',
+                label: 'Solicitar cancelación',
+                destructive: true,
+                blockedWhen: { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'Cancela primero los REP' },
+            },
+        ],
+        layouts: [{ when: { field: '$.fiscal', op: 'eq', value: 'stamped' }, layout: { primary: 'pay', secondary: ['send', 'pdf'], destructive: ['cancel'] } }],
+        smartButtons: [{ key: 'reps', label: 'REP', source: 'reps', tab: 'reps' }],
+        sources: [{ key: 'reps', model: 'fiscal_documents', foreignKey: 'source_id' }],
+        tabs: [
+            { key: 'reps', label: 'Pagos y REP', kind: 'records', source: 'reps', columns: [{ label: 'UUID', path: 'fiscal_uuid' }] },
+        ],
+    },
+    derive: () => ({ fiscal: 'stamped', billing: 'partial', pdf: 'https://x/y.pdf' }),
+}
+
+function setup(onAction = vi.fn()) {
+    const api = {
+        get: vi.fn().mockResolvedValue({ data: { success: true, data: [{ id: 'r1', fiscal_uuid: 'REP-UUID-1' }] } }),
+    } as unknown as ApiClient
+    render(
+        <ApiProvider client={api}>
+            <DocumentPage registration={registration} record={{ id: 'i1', number: 'A-42', total: 1500 }} onAction={onAction} currency='MXN' />
+        </ApiProvider>,
+    )
+    return { api, onAction }
+}
+
+describe('DocumentPage', () => {
+    it('muestra cabecera con dos badges de texto explícito y el total en la moneda de la org', async () => {
+        setup()
+        expect(screen.getByRole('heading', { name: 'A-42' })).toBeTruthy()
+        expect(screen.getByText('Timbrada')).toBeTruthy()
+        expect(screen.getByText('Parcial')).toBeTruthy()
+        expect(screen.getByText(/1,500\.00/)).toBeTruthy()
+    })
+
+    it('una primaria, secundarias visibles y la destructiva bloqueada con el contador de REP', async () => {
+        const { onAction } = setup()
+        await waitFor(() => expect(screen.getAllByText('1').length).toBeGreaterThan(0)) // contador del botón inteligente
+        fireEvent.click(screen.getByText('Registrar pago'))
+        await waitFor(() => expect(onAction).toHaveBeenCalledTimes(1))
+        expect(onAction.mock.calls[0][0].def.key).toBe('pay')
+        const cancel = screen.getByRole('button', { name: /Solicitar cancelación/ }) as HTMLButtonElement
+        expect(cancel.disabled).toBe(true)
+        fireEvent.click(cancel)
+        expect(onAction).toHaveBeenCalledTimes(1)
+    })
+
+    it('el botón inteligente abre la pestaña con las filas de la fuente', async () => {
+        setup()
+        await waitFor(() => expect(screen.getAllByText('1').length).toBeGreaterThan(0))
+        fireEvent.click(screen.getByRole('button', { name: /REP/ }))
+        await waitFor(() => expect(screen.getByText('REP-UUID-1')).toBeTruthy())
+    })
+
+    it('openUrl abre el archivo sin pasar por onAction', async () => {
+        const open = vi.spyOn(window, 'open').mockImplementation(() => null)
+        const { onAction } = setup()
+        fireEvent.click(screen.getByText('Descargar PDF'))
+        await waitFor(() => expect(open).toHaveBeenCalledWith('https://x/y.pdf', '_blank', 'noopener,noreferrer'))
+        expect(onAction).not.toHaveBeenCalled()
+    })
+})

package/src/document/__tests__/evaluate.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+import { evaluateWhen, interpolate, pruneUnavailableActions, readPath, resolveActions, resolveStatus, resolveTitle } from '../evaluate'
+import type { DocumentContext, DocumentSpec } from '../types'
+
+const ctx = (record: Record<string, unknown>, derived: Record<string, unknown> = {}, sources: DocumentContext['sources'] = {}): DocumentContext => ({
+    record,
+    derived,
+    sources,
+})
+
+const spec: DocumentSpec = {
+    model: 'docs',
+    title: '{{series}}{{number}} || {{id}}',
+    statuses: [
+        {
+            id: 'fiscal',
+            field: '$.fiscal',
+            states: [
+                { value: 'draft', label: 'Borrador', tone: 'neutral' },
+                { value: 'cancelled', label: 'Cancelada', tone: 'neutral', strike: true },
+            ],
+        },
+    ],
+    actions: [
+        { key: 'stamp', label: 'Timbrar factura' },
+        { key: 'preview', label: 'Vista previa' },
+        { key: 'edit', label: 'Editar' },
+        { key: 'a', label: 'A' },
+        { key: 'b', label: 'B' },
+        { key: 'dup', label: 'Duplicar' },
+        {
+            key: 'cancel',
+            label: 'Solicitar cancelación',
+            destructive: true,
+            blockedWhen: { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'Cancela primero los REP' },
+        },
+        { key: 'secret', label: 'Secreta', hiddenWhen: { field: 'locked', op: 'truthy' } },
+    ],
+    layouts: [
+        { when: { field: '$.fiscal', op: 'eq', value: 'draft' }, layout: { primary: 'stamp', secondary: ['preview', 'edit', 'a', 'b'], more: ['dup', 'secret'] } },
+        { when: [{ field: '$.fiscal', op: 'eq', value: 'stamped' }], layout: { primary: 'dup', destructive: ['cancel'] } },
+    ],
+    tabs: [],
+}
+
+describe('readPath', () => {
+    it('lee registro, derivados y totales de fuentes', () => {
+        const c = ctx({ a: { b: 1 } }, { x: 'y' }, { reps: [{}, {}] })
+        expect(readPath(c, 'a.b')).toBe(1)
+        expect(readPath(c, 'record.a.b')).toBe(1)
+        expect(readPath(c, '$.x')).toBe('y')
+        expect(readPath(c, 'sources.reps.length')).toBe(2)
+        expect(readPath(c, 'nope.deep')).toBeUndefined()
+    })
+})
+
+describe('evaluateWhen', () => {
+    it('AND de predicados y operadores', () => {
+        const c = ctx({ n: 5, s: 'a', e: '' })
+        expect(evaluateWhen(undefined, c)).toBe(true)
+        expect(evaluateWhen([{ field: 'n', op: 'gt', value: 3 }, { field: 's', op: 'in', value: ['a', 'b'] }], c)).toBe(true)
+        expect(evaluateWhen([{ field: 'n', op: 'gt', value: 3 }, { field: 's', op: 'neq', value: 'a' }], c)).toBe(false)
+        expect(evaluateWhen({ field: 'e', op: 'falsy' }, c)).toBe(true)
+        expect(evaluateWhen({ field: 's', op: 'not_in', value: ['z'] }, c)).toBe(true)
+    })
+})
+
+describe('resolveStatus', () => {
+    it('resuelve del catálogo, cae a neutral con el valor crudo y omite vacío', () => {
+        expect(resolveStatus(spec.statuses[0], ctx({}, { fiscal: 'cancelled' }))?.strike).toBe(true)
+        expect(resolveStatus(spec.statuses[0], ctx({}, { fiscal: 'raro' }))).toMatchObject({ label: 'raro', tone: 'neutral' })
+        expect(resolveStatus(spec.statuses[0], ctx({}, {}))).toBeUndefined()
+    })
+})
+
+describe('resolveActions', () => {
+    it('1 primaria, máx. 3 secundarias y el desborde va a «Más…»', () => {
+        const r = resolveActions(spec, ctx({}, { fiscal: 'draft' }))
+        expect(r.primary?.def.key).toBe('stamp')
+        expect(r.secondary.map((a) => a.def.key)).toEqual(['preview', 'edit', 'a'])
+        expect(r.more.map((a) => a.def.key)).toEqual(['b', 'dup', 'secret'])
+    })
+    it('hiddenWhen omite la acción', () => {
+        const r = resolveActions(spec, ctx({ locked: true }, { fiscal: 'draft' }))
+        expect(r.more.map((a) => a.def.key)).not.toContain('secret')
+    })
+    it('blockedWhen deja la destructiva visible pero bloqueada con motivo', () => {
+        const blocked = resolveActions(spec, ctx({}, { fiscal: 'stamped' }, { reps: [{ id: 1 }] }))
+        expect(blocked.destructive[0].blockedReason).toBe('Cancela primero los REP')
+        const free = resolveActions(spec, ctx({}, { fiscal: 'stamped' }, { reps: [] }))
+        expect(free.destructive[0].blockedReason).toBeUndefined()
+    })
+    it('blockedWhen admite varias reglas y muestra el motivo de la primera que aplica', () => {
+        const multi: DocumentSpec = {
+            ...spec,
+            actions: [
+                {
+                    key: 'cancel',
+                    label: 'Cancelar',
+                    destructive: true,
+                    blockedWhen: [
+                        { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'REP' },
+                        { when: { field: 'sources.notes.length', op: 'gt', value: 0 }, reason: 'NC' },
+                    ],
+                },
+            ],
+            layouts: [{ when: { field: '$.fiscal', op: 'eq', value: 'stamped' }, layout: { destructive: ['cancel'] } }],
+        }
+        expect(resolveActions(multi, ctx({}, { fiscal: 'stamped' }, { reps: [], notes: [{}] })).destructive[0].blockedReason).toBe('NC')
+        expect(resolveActions(multi, ctx({}, { fiscal: 'stamped' }, { reps: [{}], notes: [{}] })).destructive[0].blockedReason).toBe('REP')
+    })
+    it('sin regla que coincida no hay acciones', () => {
+        const r = resolveActions(spec, ctx({}, { fiscal: 'otro' }))
+        expect(r.primary).toBeUndefined()
+        expect(r.secondary).toEqual([])
+    })
+})
+
+describe('interpolate / resolveTitle', () => {
+    it('interpola y prueba alternativas', () => {
+        expect(interpolate('{{series}}-{{number}}', ctx({ series: 'A', number: 7 }))).toBe('A-7')
+        expect(resolveTitle(spec.title, ctx({ series: 'A', number: 7, id: 'x' }))).toBe('A7')
+        expect(resolveTitle(spec.title, ctx({ id: 'x' }))).toBe('x')
+    })
+})
+
+describe('pruneUnavailableActions', () => {
+    it('quita acciones sin acción de modelo, conserva href/openUrl/tab', () => {
+        const s: DocumentSpec = {
+            ...spec,
+            actions: [
+                { key: 'a', label: 'A' },
+                { key: 'b', label: 'B', modelAction: 'real' },
+                { key: 'c', label: 'C', tab: 'fiscal' },
+                { key: 'd', label: 'D', openUrl: '{{x}}' },
+            ],
+        }
+        expect(pruneUnavailableActions(s, ['real']).actions.map((a) => a.key)).toEqual(['b', 'c', 'd'])
+    })
+})