@asteby/metacore-runtime-react 23.8.0 → 23.9.1

package/src/dynamic-form-schema.ts

@@ -2,7 +2,7 @@
 // callers (and unit tests) can use the zod schema without pulling in React or
 // metacore-ui primitives.
 import { z, type ZodTypeAny } from 'zod'
-import type { ActionFieldDef, FieldValidation, FieldOptionsConfig } from './types'
+import type { ActionFieldDef, FieldValidation, FieldOptionsConfig, OptionDef } from './types'
 import { resolveValidatorToken } from './use-org-config-bridge'
 
 /**
@@ -287,6 +287,49 @@ export function resolveDependsValue(
     return String(raw)
 }
 
+/**
+ * Filters a STATIC enum's `options[]` by each option's `when` gate against the
+ * current form values. Pure — no React, no side effects.
+ *
+ * Rule per option:
+ * - No `when` → always included (retrocompat; existing enums untouched).
+ * - With `when`: the gating field is `when.field ?? dependsOn`. If neither is
+ *   present the option is included (nothing to gate on). Otherwise the form's
+ *   value for that field is compared AS STRING: included when (no `in`, or
+ *   value ∈ `in`) AND (no `not_in`, or value ∉ `not_in`). Tolerates the
+ *   snake_case `not_in` the kernel serves alongside camelCase `notIn`.
+ *
+ * `formValues` is the flat map of the surrounding form/row values the gating
+ * field is read from; `dependsOn` is the containing field's declared dependency
+ * used as the default gating field.
+ */
+export function applyOptionWhen(
+    options: OptionDef[] | undefined,
+    formValues: Record<string, any> | null | undefined,
+    dependsOn?: string,
+): OptionDef[] {
+    if (!Array.isArray(options)) return []
+    return options.filter((opt) => {
+        const when = opt?.when
+        if (!when) return true
+        const gate = (typeof when.field === 'string' && when.field.trim() !== '')
+            ? when.field.trim()
+            : dependsOn
+        if (!gate) return true
+        const raw = formValues ? formValues[gate] : undefined
+        const current = raw == null ? '' : String(raw)
+        const inList = when.in
+        const notIn = when.notIn ?? when.not_in
+        if (Array.isArray(inList) && inList.length > 0) {
+            if (!inList.some((v) => String(v) === current)) return false
+        }
+        if (Array.isArray(notIn) && notIn.length > 0) {
+            if (notIn.some((v) => String(v) === current)) return false
+        }
+        return true
+    })
+}
+
 /**
  * Reads a field's enriched options-resolution config, tolerating the camelCase
  * `optionsConfig` (authored SDK shape) and the snake_case `options_config` the

package/src/dynamic-form.tsx

@@ -20,6 +20,8 @@ import {
     resolveWidget,
     isLineItemsField,
     evaluateBalance,
+    applyOptionWhen,
+    getDependsOn,
 } from './dynamic-form-schema'
 import { useOptionsResolver, type ResolvedOption } from './use-options-resolver'
 import { DynamicLineItems } from './dynamic-line-items'
@@ -111,32 +113,17 @@ export function DynamicForm({
     return (
         <form onSubmit={handleSubmit} className="grid gap-4">
             <div className="grid gap-4 sm:grid-cols-2">
-                {fields.map((field) => {
-                    const fullWidth =
-                        isLineItemsField(field) ||
-                        resolveWidget(field) === 'textarea' ||
-                        resolveWidget(field) === 'richtext'
-                    return (
-                        <div
-                            key={field.key}
-                            className={'grid gap-2 ' + (fullWidth ? 'sm:col-span-2' : '')}
-                        >
-                            <Label htmlFor={field.key}>
-                                {field.label}
-                                {field.required && <span className="text-red-500 ml-1">*</span>}
-                            </Label>
-                            <FieldRenderer
-                                field={field}
-                                value={values[field.key]}
-                                onChange={(v: any) => update(field.key, v)}
-                                initialValues={initialValues}
-                            />
-                            {errors[field.key] && (
-                                <span className="text-red-500 text-sm" role="alert">{errors[field.key]}</span>
-                            )}
-                        </div>
-                    )
-                })}
+                {fields.map((field) => (
+                    <FieldRow
+                        key={field.key}
+                        field={field}
+                        value={values[field.key]}
+                        onChange={(v: any) => update(field.key, v)}
+                        values={values}
+                        error={errors[field.key]}
+                        initialValues={initialValues}
+                    />
+                ))}
             </div>
             <div className="flex justify-end gap-2 pt-2">
                 {onCancel && (
@@ -158,6 +145,61 @@ interface FieldRendererProps {
     onChange: (v: any) => void
     /** The form's initial record — used to seed an FK picker's existing label/image. */
     initialValues?: Record<string, any>
+    /**
+     * The full flat map of current form values — read by a STATIC enum select to
+     * gate its options by a sibling field's value (`applyOptionWhen`).
+     */
+    values?: Record<string, any>
+}
+
+interface FieldRowProps extends FieldRendererProps {
+    error?: string
+}
+
+// One form field row: label + renderer + inline error. Encapsulated as its own
+// component so a STATIC enum select whose options are all gated out by a sibling
+// value (`when`) can hide the ENTIRE row (label included) and run its reset
+// effect with valid hook ordering.
+function FieldRow({ field, value, onChange, values, error, initialValues }: FieldRowProps) {
+    const isStaticSelect =
+        resolveWidget(field) === 'select' && !field.ref && Array.isArray(field.options)
+    const effectiveOptions = isStaticSelect
+        ? applyOptionWhen(field.options, values, getDependsOn(field))
+        : undefined
+
+    // Reset a selection that the current sibling value no longer permits (e.g.
+    // the parent switched away from the value that made this option valid).
+    useEffect(() => {
+        if (!isStaticSelect || !effectiveOptions) return
+        if (value && !effectiveOptions.some((o) => String(o.value) === String(value))) {
+            onChange('')
+        }
+    }, [isStaticSelect, effectiveOptions, value, onChange])
+
+    // No option applies under the current sibling value → hide the whole field.
+    if (isStaticSelect && effectiveOptions && effectiveOptions.length === 0) return null
+
+    const fullWidth =
+        isLineItemsField(field) ||
+        resolveWidget(field) === 'textarea' ||
+        resolveWidget(field) === 'richtext'
+    return (
+        <div className={'grid gap-2 ' + (fullWidth ? 'sm:col-span-2' : '')}>
+            <Label htmlFor={field.key}>
+                {field.label}
+                {field.required && <span className="text-red-500 ml-1">*</span>}
+            </Label>
+            <FieldRenderer
+                field={field}
+                value={value}
+                onChange={onChange}
+                initialValues={initialValues}
+                values={values}
+                effectiveOptions={effectiveOptions}
+            />
+            {error && <span className="text-red-500 text-sm" role="alert">{error}</span>}
+        </div>
+    )
 }
 
 // seedOptionFromSibling builds a pre-resolved option for an FK field from the
@@ -187,7 +229,13 @@ function seedOptionFromSibling(
     }
 }
 
-function FieldRenderer({ field, value, onChange, initialValues }: FieldRendererProps) {
+function FieldRenderer({
+    field,
+    value,
+    onChange,
+    initialValues,
+    effectiveOptions,
+}: FieldRendererProps & { effectiveOptions?: import('./types').OptionDef[] }) {
     // Repeatable line-items group → render the row grid. Its value is an array
     // of row objects rather than a scalar.
     if (isLineItemsField(field)) {
@@ -228,7 +276,7 @@ function FieldRenderer({ field, value, onChange, initialValues }: FieldRendererP
                 <Select value={value || ''} onValueChange={onChange}>
                     <SelectTrigger className="w-full"><SelectValue placeholder={field.placeholder || 'Seleccionar...'} /></SelectTrigger>
                     <SelectContent>
-                        {field.options?.map((opt) => <SelectItem key={opt.value} value={opt.value}>{opt.label}</SelectItem>)}
+                        {(effectiveOptions ?? field.options)?.map((opt) => <SelectItem key={opt.value} value={opt.value}>{opt.label}</SelectItem>)}
                     </SelectContent>
                 </Select>
             )

package/src/dynamic-kanban.tsx

@@ -54,6 +54,7 @@ import {
     MoreHorizontal,
     RotateCcw,
     Search,
+    Settings2,
     Tag,
     ToggleLeft,
     Type,
@@ -99,13 +100,18 @@ import {
     splitCustomStages,
     mergeLaneStages,
     resolveSmartLanes,
+    cardMatchesStageFilters,
+    smartLaneParams,
     AddStageColumn,
-    CustomStageLaneMenu,
     CustomStageDialog,
     CustomStageDeleteDialog,
+    StageConfigDialog,
     SmartLane,
     type CustomStage,
+    type CustomStageFilter,
+    type StageConfigTarget,
 } from './custom-stages'
+import { useStageOverrides } from './stage-overrides'
 import { useDynamicFilters } from './use-dynamic-filters'
 import {
     FilterChipsRow,
@@ -117,7 +123,7 @@ import { useMetadataCache } from './metadata-cache'
 import { ActivityValueRenderer } from './activity-value-renderer'
 import { DynamicIcon } from './dynamic-icon'
 import { isColumnVisibleInTable } from './column-visibility'
-import { isRowActionVisible } from './dynamic-columns'
+import { isRowActionVisible, relationKeyFor } from './dynamic-columns'
 import { useCan, usePermissionsActive, resolveRowActions } from './permissions-context'
 import { useDynamicRowActions } from './dynamic-row-actions'
 import { useStageLayout } from './stage-layout'
@@ -317,6 +323,27 @@ export function selectCardColumns(
     return { title, fields }
 }
 
+/** The all-zeros UUID — a Go zero-value FK serialized as "set" when it isn't. */
+const ZERO_UUID = /^0{8}-0{4}-0{4}-0{4}-0{12}$/
+
+/**
+ * The value a card cell should render for a column — same resolution the
+ * table's cells apply. An FK column (`<rel>_id`) prefers the backend-resolved
+ * sibling object (`card.<rel>`, e.g. `{ name }` / `{ value, label }`) over the
+ * raw UUID; a zero-UUID FK counts as unset (renders the em-dash). Pure —
+ * exported for unit tests.
+ */
+export function cardCellValue(card: any, col: ColumnDefinition): unknown {
+    const raw = card?.[col.key]
+    if (typeof raw === 'string' && ZERO_UUID.test(raw)) return null
+    const relKey = relationKeyFor(col)
+    if (relKey !== col.key) {
+        const sibling = card?.[relKey]
+        if (sibling && typeof sibling === 'object') return sibling
+    }
+    return raw
+}
+
 /**
  * Whether a card passes a lane funnel. Picked select/facet `values` match by
  * equality (IN — the card's field value must be one of them); a free-text
@@ -489,10 +516,16 @@ export function DynamicKanban({
     // the host has no `/custom-stages` endpoint — the "+ Agregar etapa" column
     // and lane menus simply don't render.
     const customStages = useCustomStages(model)
+    // Per-org overrides for DECLARED lanes (rename/recolor/conditions). Degrades
+    // to no-op when the host has no `/stage-overrides` endpoint — the ⚙ gear then
+    // hides on declared lanes (custom lanes keep it via /custom-stages).
+    const stageOverrides = useStageOverrides(model)
     // Dialog state: create/edit a stage, and the delete confirmation.
     const [stageDialogOpen, setStageDialogOpen] = useState(false)
     const [editingStage, setEditingStage] = useState<CustomStage | null>(null)
     const [deletingStage, setDeletingStage] = useState<CustomStage | null>(null)
+    // The gear (⚙) "Configurar etapa" dialog — one UI for declared + custom lanes.
+    const [configTarget, setConfigTarget] = useState<StageConfigTarget | null>(null)
     const openCreateStage = useCallback(() => {
         setEditingStage(null)
         setStageDialogOpen(true)
@@ -628,6 +661,7 @@ export function DynamicKanban({
                         const r = (await api.get(endpoint || `/data/${model}`, {
                             params: {
                                 ...filterParams,
+                                ...smartLaneParams(stage.filters),
                                 page: 1,
                                 per_page: 1,
                                 [`f_${gb}`]: stage.key,
@@ -661,6 +695,27 @@ export function DynamicKanban({
     // the shared records. Scoped by `f_<group_by>=<stage>` on top of the active
     // filterParams (the stage scope wins over any global group_by filter).
     const groupByKey = metadata?.group_by || ''
+    // Extra per-lane conditions (stage overrides) keyed by stage. A real lane
+    // that carries these queries its data — and counts its header — with the
+    // stage scope PLUS these filters (serialized like a smart lane's), so the
+    // top-up + eager-total requests below layer them on. Sourced from
+    // `metadata.stages` (the kernel applies declared + custom-real overrides).
+    const stageExtraFilters = useMemo(() => {
+        const m = new Map<string, CustomStageFilter[]>()
+        for (const s of metadata?.stages ?? []) {
+            if (s.filters && s.filters.length > 0) {
+                m.set(
+                    s.key,
+                    s.filters.map((f) => ({
+                        field: f.field,
+                        op: f.op as CustomStageFilter['op'],
+                        value: f.value,
+                    })),
+                )
+            }
+        }
+        return m
+    }, [metadata?.stages])
     const loadMoreLane = useCallback(
         async (stageKey: string) => {
             if (!metadata || !groupByKey) return
@@ -680,6 +735,7 @@ export function DynamicKanban({
                 const res = (await api.get(endpoint || `/data/${model}`, {
                     params: {
                         ...filterParams,
+                        ...smartLaneParams(stageExtraFilters.get(stageKey)),
                         page: nextPage,
                         per_page: lanePageSize,
                         [`f_${groupByKey}`]: stageKey,
@@ -712,7 +768,7 @@ export function DynamicKanban({
                 }))
             }
         },
-        [api, endpoint, model, metadata, groupByKey, filterParams, lanePageSize, lanePagination],
+        [api, endpoint, model, metadata, groupByKey, filterParams, lanePageSize, lanePagination, stageExtraFilters],
     )
 
     // Refetch when metadata resolves, on an explicit refresh, or when the
@@ -1133,14 +1189,82 @@ export function DynamicKanban({
         stageKey === activeStage ||
         isTransitionAllowed(transitions, activeStage, stageKey)
 
+    // Opens the gear (⚙) "Configurar etapa" dialog for a lane, routing to the
+    // right backend by kind: a custom real stage edits through /custom-stages, a
+    // declared stage through /stage-overrides. Seeds the current label/color and
+    // any extra conditions the lane already carries.
+    const openConfigStage = (stage: StageMeta) => {
+        const custom = customStages.available
+            ? customByKey.get(stage.key)
+            : undefined
+        const raw =
+            stageExtraFilters.get(stage.key) ??
+            (custom?.filters as CustomStageFilter[] | undefined) ??
+            []
+        const filters: CustomStageFilter[] = raw.map((f) => ({
+            field: f.field,
+            op: f.op as CustomStageFilter['op'],
+            value: f.value,
+        }))
+        if (custom) {
+            setConfigTarget({
+                kind: 'custom',
+                stageKey: stage.key,
+                id: custom.id,
+                label: custom.label,
+                color: custom.color,
+                filters,
+                customStage: custom,
+            })
+        } else {
+            const original = stage.original
+                ? {
+                      label: stage.original.label,
+                      color: stage.original.color,
+                      filters: stage.original.filters?.map((f) => ({
+                          field: f.field,
+                          op: f.op as CustomStageFilter['op'],
+                          value: f.value,
+                      })),
+                  }
+                : undefined
+            setConfigTarget({
+                kind: 'declared',
+                stageKey: stage.key,
+                label: t(stage.label, { defaultValue: stage.label }),
+                color: stage.color ?? 'slate',
+                filters,
+                overridden: !!stage.overridden,
+                isFinal: stage.is_final,
+                original,
+            })
+        }
+    }
+    // Whether a lane offers the gear: custom real stages always (their CRUD is
+    // wired); declared lanes only when the host wired /stage-overrides. Never on
+    // the synthetic "Sin etapa" lane.
+    const isConfigurable = (stage: StageMeta): boolean => {
+        if (stage.key === UNASSIGNED_LANE) return false
+        return customByKey.has(stage.key)
+            ? customStages.available
+            : stageOverrides.available
+    }
+
     // Builds every `KanbanLane` prop (minus the dnd wiring) for one stage —
     // shared by the sortable real stages and the plain-droppable unassigned lane.
     const buildLaneProps = (stage: StageMeta): Omit<KanbanLaneProps, 'dnd'> => {
         const allCards = grouped.get(stage.key) ?? []
+        // Extra lane conditions (stage override): the server already scopes this
+        // lane's top-up + total queries by them, but the shared INITIAL board page
+        // is unscoped, so narrow those cards client-side too (belt-and-suspenders).
+        const extraFilters = stageExtraFilters.get(stage.key) ?? []
         // Per-lane client-side narrowing (instant, scoped to this stage). The
         // funnel (field/value) and the lane search (query) are AND-combined.
         const laneFilter = laneFilters[stage.key]
         let cards = allCards
+        if (extraFilters.length > 0) {
+            cards = cards.filter((c) => cardMatchesStageFilters(c, extraFilters))
+        }
         if (laneFilter?.field) {
             cards = cards.filter((c) => cardMatchesLaneFunnel(c, laneFilter))
         }
@@ -1179,11 +1303,9 @@ export function DynamicKanban({
             onAutomationCreate: automations.create,
             onAutomationUpdate: automations.update,
             onAutomationRemove: automations.remove,
-            customStage: customStages.available
-                ? customByKey.get(stage.key)
-                : undefined,
-            onEditStage: openEditStage,
-            onDeleteStage: openDeleteStage,
+            extraFilters,
+            configurable: isConfigurable(stage),
+            onConfigure: () => openConfigStage(stage),
             children:
                 loadingData && cards.length === 0 ? (
                     <>
@@ -1461,6 +1583,50 @@ export function DynamicKanban({
                     />
                 </>
             )}
+
+            {/* Unified "Configurar etapa" dialog opened by the per-lane ⚙ gear —
+                routes saves to /stage-overrides (declared) or /custom-stages
+                (custom) by the target's kind. */}
+            <StageConfigDialog
+                open={!!configTarget}
+                onOpenChange={(o) => {
+                    if (!o) setConfigTarget(null)
+                }}
+                columns={metadata?.columns ?? []}
+                target={configTarget}
+                onSaveOverride={async (stageKey, patch) => {
+                    await stageOverrides.save(stageKey, patch)
+                    // The override changes the served label/color/filters — refetch
+                    // metadata so the board repaints, and reload the cards.
+                    try {
+                        const res = await api.get(`/metadata/table/${model}`)
+                        const body = res.data as ApiResponse<TableMetadata>
+                        if (body.success) {
+                            setMetadata(body.data)
+                            cacheMetadata(model, body.data)
+                        }
+                    } catch {
+                        /* keep the current metadata on a refetch miss */
+                    }
+                    void fetchData()
+                }}
+                onResetOverride={async (stageKey) => {
+                    await stageOverrides.reset(stageKey)
+                    try {
+                        const res = await api.get(`/metadata/table/${model}`)
+                        const body = res.data as ApiResponse<TableMetadata>
+                        if (body.success) {
+                            setMetadata(body.data)
+                            cacheMetadata(model, body.data)
+                        }
+                    } catch {
+                        /* keep the current metadata on a refetch miss */
+                    }
+                    void fetchData()
+                }}
+                onUpdateCustom={customStages.update}
+                onDeleteCustom={openDeleteStage}
+            />
         </div>
     )
 }
@@ -1716,10 +1882,12 @@ interface KanbanLaneProps {
         patch: Partial<StageAutomation>,
     ) => Promise<void>
     onAutomationRemove: (id: StageAutomation['id']) => Promise<void>
-    /** When set, this lane is a user-defined custom stage → show ⋮ Editar/Eliminar. */
-    customStage?: CustomStage
-    onEditStage?: (stage: CustomStage) => void
-    onDeleteStage?: (stage: CustomStage) => void
+    /** Extra lane conditions (stage override) — drives the header filter dot + tooltip. */
+    extraFilters: CustomStageFilter[]
+    /** Whether the ⚙ "Configurar etapa" gear should render for this lane. */
+    configurable: boolean
+    /** Opens the gear config dialog for this lane. */
+    onConfigure: () => void
     children: React.ReactNode
 }
 
@@ -1745,9 +1913,9 @@ function KanbanLane({
     onAutomationCreate,
     onAutomationUpdate,
     onAutomationRemove,
-    customStage,
-    onEditStage,
-    onDeleteStage,
+    extraFilters,
+    configurable,
+    onConfigure,
     children,
 }: KanbanLaneProps) {
     const { t } = useTranslation()
@@ -1792,6 +1960,25 @@ function KanbanLane({
           }
         : undefined
 
+    // Stage-override conditions active on this lane → a small filter dot in the
+    // header, its `title` listing the conditions (e.g. "priority es igual high").
+    const hasConditions = extraFilters.length > 0
+    const conditionsSummary = extraFilters
+        .map((f) => {
+            const opLabel = t(`dynamic.custom_stages.op.${f.op}`, {
+                defaultValue:
+                    f.op === 'eq'
+                        ? 'es igual'
+                        : f.op === 'neq'
+                        ? 'distinto'
+                        : f.op === 'contains'
+                        ? 'contiene'
+                        : 'en lista',
+            })
+            return `${f.field} ${opLabel} ${f.value}`
+        })
+        .join(' · ')
+
     return (
         <div
             ref={dnd.setNodeRef}
@@ -1836,6 +2023,22 @@ function KanbanLane({
                     <span className="text-xs font-medium tabular-nums text-muted-foreground">
                         {formatLaneCount(count, totalCount, serverTotal, laneActive)}
                     </span>
+                    {hasConditions && (
+                        <span
+                            className="flex items-center text-primary"
+                            title={t('dynamic.stage_config.conditions_active', {
+                                defaultValue: 'Condiciones: {{list}}',
+                                list: conditionsSummary,
+                            })}
+                            data-testid={`lane-conditions-${stage.key}`}
+                            aria-label={t('dynamic.stage_config.conditions_active', {
+                                defaultValue: 'Condiciones: {{list}}',
+                                list: conditionsSummary,
+                            })}
+                        >
+                            <ListFilter className="h-3 w-3" />
+                        </span>
+                    )}
                 </div>
                 {/* Lane actions — always visible in muted (a hidden hover-reveal
                     was undiscoverable); active state is a primary tint + a count
@@ -1873,12 +2076,20 @@ function KanbanLane({
                             onRemove={onAutomationRemove}
                         />
                     )}
-                    {customStage && onEditStage && onDeleteStage && (
-                        <CustomStageLaneMenu
-                            stage={customStage}
-                            onEdit={onEditStage}
-                            onDelete={onDeleteStage}
-                        />
+                    {configurable && (
+                        <button
+                            type="button"
+                            onClick={onConfigure}
+                            className={`relative flex size-6 items-center justify-center rounded-md transition-colors hover:bg-accent hover:text-foreground ${
+                                hasConditions ? 'text-primary' : 'text-muted-foreground'
+                            }`}
+                            aria-label={t('dynamic.stage_config.open', {
+                                defaultValue: 'Configurar etapa',
+                            })}
+                            data-testid={`lane-config-${stage.key}`}
+                        >
+                            <Settings2 className="h-3.5 w-3.5" />
+                        </button>
                     )}
                 </div>
             </div>
@@ -2152,7 +2363,7 @@ function KanbanCard({
                     <div className="min-w-0 flex-1 break-words text-sm font-medium leading-snug">
                         {titleCol ? (
                             <ActivityValueRenderer
-                                value={card[titleCol.key]}
+                                value={cardCellValue(card, titleCol)}
                                 col={titleCol}
                                 locale={locale}
                                 timeZone={timeZone}
@@ -2204,7 +2415,7 @@ function KanbanCard({
                         <span className="shrink-0 opacity-70">{col.label}:</span>
                         <span className="min-w-0 break-words">
                             <ActivityValueRenderer
-                                value={card[col.key]}
+                                value={cardCellValue(card, col)}
                                 col={col}
                                 locale={locale}
                                 timeZone={timeZone}
@@ -2233,7 +2444,7 @@ function CardPreview({
                 <div className="break-words text-sm font-medium leading-snug">
                     {titleCol ? (
                         <ActivityValueRenderer
-                            value={card[titleCol.key]}
+                            value={cardCellValue(card, titleCol)}
                             col={titleCol}
                             locale={locale}
                             timeZone={timeZone}
@@ -2251,7 +2462,7 @@ function CardPreview({
                         <span className="shrink-0 opacity-70">{col.label}:</span>
                         <span className="min-w-0 break-words">
                             <ActivityValueRenderer
-                                value={card[col.key]}
+                                value={cardCellValue(card, col)}
                                 col={col}
                                 locale={locale}
                                 timeZone={timeZone}

package/src/dynamic-line-items.tsx

@@ -31,6 +31,7 @@ import {
     resolveDependsValue,
     getOptionsConfig,
     resolveOptionsSource,
+    applyOptionWhen,
 } from './dynamic-form-schema'
 import { DynamicSelectField, DEFAULT_DEPENDS_HINT } from './dynamic-select-field'
 import { useOptionsResolver, type ResolvedOption } from './use-options-resolver'
@@ -271,6 +272,25 @@ function CellRenderer({ field, value, onChange, disabled, formValues, rowValues
     const dependsValue = getDependsOn(field)
         ? resolveDependsValue(field, formValues, rowValues)
         : undefined
+
+    // STATIC enum options gated per-cell by a sibling (row) or header value.
+    // Row values win over the header when a key exists in both, matching
+    // `resolveDependsValue`. Filtered against each option's `when`.
+    const isStaticSelect =
+        widget === 'select' && !field.ref && !getOptionsConfig(field)?.source && Array.isArray(field.options)
+    const gateValues = isStaticSelect ? { ...(formValues ?? {}), ...(rowValues ?? {}) } : undefined
+    const effectiveOptions = isStaticSelect
+        ? applyOptionWhen(field.options, gateValues, getDependsOn(field))
+        : undefined
+
+    // Reset a selection the current sibling value no longer permits.
+    useEffect(() => {
+        if (!isStaticSelect || !effectiveOptions) return
+        if (value && !effectiveOptions.some((o) => String(o.value) === String(value))) {
+            onChange('')
+        }
+    }, [isStaticSelect, effectiveOptions, value, onChange])
+
     // Async searchable picker per row cell — e.g. the account_id column of a
     // journal entry's debit/credit lines. Same widget as the flat form.
     if (widget === 'dynamic_select') {
@@ -309,14 +329,17 @@ function CellRenderer({ field, value, onChange, disabled, formValues, rowValues
                     disabled={off}
                 />
             )
-        case 'select':
+        case 'select': {
+            const opts = effectiveOptions ?? field.options
+            // No option applies under the current sibling value → hide the cell.
+            if (effectiveOptions && effectiveOptions.length === 0) return null
             return (
                 <Select value={value || ''} onValueChange={onChange} disabled={off}>
                     <SelectTrigger className="w-full">
                         <SelectValue placeholder={field.placeholder || 'Seleccionar...'} />
                     </SelectTrigger>
                     <SelectContent>
-                        {field.options?.map((opt) => (
+                        {opts?.map((opt) => (
                             <SelectItem key={opt.value} value={opt.value}>
                                 {opt.label}
                             </SelectItem>
@@ -324,6 +347,7 @@ function CellRenderer({ field, value, onChange, disabled, formValues, rowValues
                     </SelectContent>
                 </Select>
             )
+        }
         case 'switch':
             return <Switch checked={!!value} onCheckedChange={onChange} disabled={off} />
         case 'number':