@zeniai/client-epic-state 5.1.0-betaSS3 → 5.1.0

package/lib/esm/entity/aiCfo/aiCfoReducer.js

@@ -1,9 +1,10 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { date as zeniDate } from '../../zeniDayJS';
-import { ALL_AI_CFO_ANSWER_RESPONSE_TYPES, toAiCfoAnswerResponseType, toAiCfoAnswerResponseTypeStrict, toAiCfoAnswerStateType, toAiCfoVisualizationTypeStrict, toMessageSender, toMessageType, toYFormatScaleStrict, toYFormatTypeStrict, toYFormatUnitStrict, } from './aiCfoState';
+import { ALL_AI_CFO_ANSWER_RESPONSE_TYPES, toAiCfoAnswerResponseType, toAiCfoAnswerResponseTypeStrict, toAiCfoAnswerStateType, toAiCfoVisualizationTypeStrict, toInteractiveFormTypeStrict, toMessageSender, toMessageType, toYFormatScaleStrict, toYFormatTypeStrict, toYFormatUnitStrict, } from './aiCfoState';
 export const initialAiCfoState = {
     aiCfoByChatSessionId: {},
     partialQuestionAnswers: {},
+    syntheticAnswersByChatSessionId: {},
 };
 // Utility: Merge two arrays of Q&A pairs, combining responses for the same question
 function mergeQuestionAnswerPairs(existing, newQAs) {
@@ -113,6 +114,7 @@ function chatHistoryToQA(history) {
                             chainOfThoughtActionSteps: [],
                             artifact: parsedAgentMessage.artifact ?? undefined,
                             artifactTitle: parsedAgentMessage.artifact_title ?? undefined,
+                            artifactHostUrl: parsedAgentMessage.artifact_host_url ?? undefined,
                         },
                         createdAt: zeniDate(agentMessage.created_at),
                     };
@@ -135,9 +137,171 @@ export const toAiCfoVisualization = (visualization) => {
     if (visualization.type == null || visualization.data == null) {
         return undefined;
     }
+    // Reject unknown viz types; `?? 'table'` used to throw in the chart/table decoder
+    // when interactive-form payloads (no `values`) hit it.
+    const normalizedType = toAiCfoVisualizationTypeStrict(visualization.type);
+    if (normalizedType == null) {
+        return undefined;
+    }
+    return {
+        type: normalizedType,
+        data: normalizedType === 'interactive_form'
+            ? toInteractiveFormVisualization(visualization.data)
+            : toAiCfoVisualizationData(visualization.data),
+    };
+};
+const toInteractiveFormVisualization = (data) => {
+    // When `form_type` is missing / mistyped, infer from payload shape so a malformed
+    // card-policy answer doesn't get decoded as cards_creation (wrong form + submit path).
+    const formType = toInteractiveFormTypeStrict(data.form_type) ??
+        inferInteractiveFormTypeFromPayload(data.payload);
+    if (formType === 'card_policy') {
+        return {
+            formType: 'card_policy',
+            payload: toCardPolicyInitialData(data.payload),
+        };
+    }
+    return {
+        formType: 'cards_creation',
+        payload: toCardsCreationInitialData(data.payload),
+    };
+};
+const inferInteractiveFormTypeFromPayload = (payload) => {
+    if (payload != null && typeof payload === 'object' && 'mode' in payload) {
+        const mode = payload.mode;
+        if (mode === 'auto' || mode === 'guided' || mode === 'upload') {
+            return 'card_policy';
+        }
+    }
+    return 'cards_creation';
+};
+const toCardsCreationInitialData = (payload) => {
+    const suggestedCards = payload.suggested_cards ?? [];
+    const ordered = [...suggestedCards].sort((a, b) => KIND_RANK[a.card_type] - KIND_RANK[b.card_type]);
+    const withUniqueIds = withSynthesizedIds(ordered);
+    const suggestedOnly = withUniqueIds.filter(({ card }) => card.is_suggested);
+    const cardNameOptions = withUniqueIds.map(({ card, uniqueId }) => ({
+        id: uniqueId,
+        kind: toCardKind(card.card_type),
+        label: card.card_name,
+    }));
+    const suggestedOwnerUserIdByTeamId = Object.fromEntries(suggestedOnly.map(({ card, uniqueId }) => [
+        uniqueId,
+        normalizeOwnerId(card.owner_id),
+    ]));
+    const common = {
+        cardNameOptions,
+        suggestedOwnerUserIdByTeamId,
+    };
+    if (payload.mode === 'create') {
+        return {
+            ...common,
+            mode: 'create',
+            cardRows: suggestedOnly.map(({ card, uniqueId }) => ({
+                cardKind: toCardKind(card.card_type),
+                id: uniqueId,
+                label: card.card_name,
+                recommendedLimit: card.credit_limit > 0 ? card.credit_limit : undefined,
+                suggestedOwnerUserId: normalizeOwnerId(card.owner_id),
+            })),
+        };
+    }
     return {
-        type: toAiCfoVisualizationTypeStrict(visualization.type) ?? 'table',
-        data: toAiCfoVisualizationData(visualization.data),
+        ...common,
+        mode: 'review',
+        teamRows: suggestedOnly.map(({ card, uniqueId }) => ({
+            avgMonthlySpend: CURRENCY_FORMATTER.format(card.avg_spend),
+            cardKind: toCardKind(card.card_type),
+            id: uniqueId,
+            label: card.card_name,
+            recommendedLimit: CURRENCY_FORMATTER.format(card.credit_limit),
+            recommendedLimitCadence: 'Monthly',
+        })),
+    };
+};
+const CURRENCY_FORMATTER = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    maximumFractionDigits: 0,
+});
+// BE emits `null` or `""` for "no owner picked"; collapse both to `undefined`.
+const normalizeOwnerId = (ownerId) => (ownerId != null && ownerId !== '' ? ownerId : undefined);
+const KIND_RANK = {
+    vendor: 0,
+    category: 1,
+    department: 2,
+};
+const toCardKind = (cardType) => {
+    if (cardType === 'department') {
+        return 'class';
+    }
+    if (cardType === 'category') {
+        return 'category';
+    }
+    return 'vendor';
+};
+// Falls back to `${kind}__${card_name_id}__${index}` when `card_name_id` collides
+// (sample payloads ship the literal `"vendor_uuid"`), to keep RHF row keys unique.
+const withSynthesizedIds = (cards) => {
+    const seen = new Set();
+    return cards.map((card, index) => {
+        const preferred = card.card_name_id;
+        if (preferred != null && preferred !== '' && !seen.has(preferred)) {
+            seen.add(preferred);
+            return { card, uniqueId: preferred };
+        }
+        const synthesized = `${card.card_type}__${preferred ?? 'unknown'}__${index}`;
+        seen.add(synthesized);
+        return { card, uniqueId: synthesized };
+    });
+};
+const toCardPolicyDraftPolicy = (payload, index) => ({
+    id: `draft-${index}`,
+    name: payload.name,
+    description: payload.description ?? '',
+    mode: payload.mode,
+    allowedEntity: {
+        categoryCodes: payload.allowed_entity?.category_codes ?? [],
+        merchantNames: payload.allowed_entity?.merchant_names ?? [],
+    },
+    blockedEntity: {
+        categoryCodes: payload.blocked_entity?.category_codes ?? [],
+        merchantNames: payload.blocked_entity?.merchant_names ?? [],
+    },
+    applyToCards: payload.apply_to_cards ?? [],
+    requiredReceiptThreshold: payload.required_receipt_threshold ?? 0,
+    spendLimits: {
+        transaction: payload.spend_limits?.transaction ?? 0,
+    },
+});
+const toCardPolicyStep5Review = (payload) => ({
+    draftPolicies: (payload.draft_policies ?? []).map(toCardPolicyDraftPolicy),
+    groupingSource: payload.grouping_source ?? 'none',
+    prompt: payload.prompt ?? '',
+});
+const toCardPolicyWizardPlan = (payload) => ({
+    step5Review: toCardPolicyStep5Review(payload.step_5_review),
+});
+const toCardPolicyUploadSource = (payload) => ({
+    confidenceScore: payload.confidence_score,
+    fileName: payload.file_name,
+    lowConfidenceFields: payload.low_confidence_fields ?? [],
+});
+const toCardPolicyInitialData = (payload) => {
+    if (payload.mode === 'upload') {
+        return {
+            policyKind: 'upload',
+            wizardPlan: payload.wizard_plan != null
+                ? toCardPolicyWizardPlan(payload.wizard_plan)
+                : undefined,
+            source: payload.source != null
+                ? toCardPolicyUploadSource(payload.source)
+                : undefined,
+        };
+    }
+    return {
+        policyKind: payload.mode,
+        wizardPlan: toCardPolicyWizardPlan(payload.wizard_plan),
     };
 };
 const toAiCfoVisualizationData = (data) => {
@@ -182,7 +346,7 @@ const toAiCfoVisualizationData = (data) => {
     };
 };
 const toResponseBlockType = (answer, userId) => {
-    const { metadata, state, type, text, visualization, table, follow_up_questions, assumptions, insights, summarized_title, artifact, artifact_title, } = answer;
+    const { metadata, state, type, text, visualization, table, follow_up_questions, assumptions, insights, summarized_title, artifact, artifact_title, artifact_host_url, } = answer;
     const { chat_session_id, message_id, timestamp, chain_of_thought_action_steps: chainOfThoughtActionSteps = [], } = metadata;
     return {
         messageId: message_id,
@@ -202,6 +366,7 @@ const toResponseBlockType = (answer, userId) => {
             chainOfThoughtActionSteps,
             artifact: artifact ?? undefined,
             artifactTitle: artifact_title ?? undefined,
+            artifactHostUrl: artifact_host_url ?? undefined,
         },
         createdAt: zeniDate(timestamp),
     };
@@ -373,10 +538,8 @@ const aiCfo = createSlice({
             // Update state - append new complete Q&As to existing ones
             session.questionAnswers = mergeQuestionAnswerPairs(session.questionAnswers, completeQAs);
         },
-        /**
-         * Upsert a Q/A pair: if the questionAnswerId exists, upsert the response block; if not, add a new Q/A entry.
-         * Used for push notification payloads that may introduce a new question.
-         */
+        // Upserts the response block when `questionAnswerId` exists; otherwise adds the Q/A
+        // entry. Used for push notification payloads that may introduce a new question.
         upsertOrAddQuestionAnswerPayload(draft, action) {
             const { chatSessionId, questionAnswerId, question: { questionId, createdAt, text }, answerPayload, userId, insertQuestionAnswer, } = action.payload;
             const session = draft.aiCfoByChatSessionId[chatSessionId];
@@ -453,10 +616,82 @@ const aiCfo = createSlice({
                 session.questionAnswers.push(qa);
             }
         },
+        // Patches an upload-mode card-policy answer with the wizard plan + source returned
+        // by `policy-recommendation-from-upload`. No-op for non-upload / missing targets.
+        updateAiCfoAnswerCardPolicyWizardPlan(draft, action) {
+            const { answerId, chatSessionId, source, wizardPlan } = action.payload;
+            const session = draft.aiCfoByChatSessionId[chatSessionId];
+            if (session == null) {
+                return;
+            }
+            const qa = session.questionAnswers.find((entry) => entry.questionAnswerId === answerId);
+            if (qa == null) {
+                return;
+            }
+            for (const response of Object.values(qa.responses)) {
+                const visualization = response?.content.visualization;
+                if (visualization == null ||
+                    visualization.type !== 'interactive_form') {
+                    continue;
+                }
+                const data = visualization.data;
+                if (data.formType !== 'card_policy' ||
+                    data.payload.policyKind !== 'upload') {
+                    continue;
+                }
+                data.payload = {
+                    ...data.payload,
+                    wizardPlan,
+                    source: source ?? data.payload.source,
+                };
+            }
+        },
+        // Renders a "Creating…" placeholder while the cards/policy create mutation runs.
+        // Caller supplies a stable `id` (updated in place by `updateSyntheticAiCfoAnswer`).
+        appendSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, createdAt, entityIds, sourceQuestionAnswerId, } = action.payload;
+            if (draft.syntheticAnswersByChatSessionId[chatSessionId] == null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] = [];
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId].push({
+                id,
+                kind,
+                entityIds: entityIds ?? [],
+                createdAt,
+                sourceQuestionAnswerId,
+            });
+        },
+        // Transitions a bubble from `creating_*` to `created_*` once the mutation completes.
+        updateSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id, kind, entityIds } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            const entry = list.find((item) => item.id === id);
+            if (entry == null) {
+                return;
+            }
+            entry.kind = kind;
+            if (entityIds != null) {
+                entry.entityIds = entityIds;
+            }
+        },
+        removeSyntheticAiCfoAnswer(draft, action) {
+            const { chatSessionId, id } = action.payload;
+            const list = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (list == null) {
+                return;
+            }
+            draft.syntheticAnswersByChatSessionId[chatSessionId] = list.filter((item) => item.id !== id);
+        },
+        clearSyntheticAiCfoAnswers(draft, action) {
+            delete draft.syntheticAnswersByChatSessionId[action.payload];
+        },
         clearSession(draft, action) {
             const sessionId = action.payload;
             delete draft.aiCfoByChatSessionId[sessionId];
-            // Clear partial Q&A if it belongs to the cleared session
+            delete draft.syntheticAnswersByChatSessionId[sessionId];
             if (draft.partialQuestionAnswers?.[sessionId] != null) {
                 draft.partialQuestionAnswers[sessionId] = undefined;
             }
@@ -464,6 +699,7 @@ const aiCfo = createSlice({
         clearAiCfo(draft) {
             draft.aiCfoByChatSessionId = {};
             draft.partialQuestionAnswers = {};
+            draft.syntheticAnswersByChatSessionId = {};
         },
         deleteQuestion(draft, action) {
             const { chatSessionId, questionAnswerId } = action.payload;
@@ -476,6 +712,12 @@ const aiCfo = createSlice({
             if (idx !== -1) {
                 session.questionAnswers.splice(idx, 1);
             }
+            // Drop synthetic bubbles whose sourceQuestionAnswerId is the deleted Q/A; otherwise "Creating…" / "Created" tiles outlive their Q/A.
+            const syntheticAnswers = draft.syntheticAnswersByChatSessionId[chatSessionId];
+            if (syntheticAnswers != null) {
+                draft.syntheticAnswersByChatSessionId[chatSessionId] =
+                    syntheticAnswers.filter((answer) => answer.sourceQuestionAnswerId !== questionAnswerId);
+            }
         },
     },
 });
@@ -488,5 +730,5 @@ const toChatSession = (chatSessionPayload) => {
         createdAt: zeniDate(created_at),
     };
 };
-export const { setNewSession, clearSession, setSessions, setChatHistory, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearAiCfo, deleteQuestion, } = aiCfo.actions;
+export const { setNewSession, clearSession, setSessions, setChatHistory, upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, addQuestionPayload, clearAiCfo, deleteQuestion, updateAiCfoAnswerCardPolicyWizardPlan, appendSyntheticAiCfoAnswer, updateSyntheticAiCfoAnswer, removeSyntheticAiCfoAnswer, clearSyntheticAiCfoAnswers, } = aiCfo.actions;
 export default aiCfo.reducer;

package/lib/esm/entity/aiCfo/aiCfoSelector.js

@@ -32,5 +32,21 @@ export function getAiCfoSelectorView(state) {
             : [],
     }))
         .sort((a, b) => b.chatSession.createdAt.valueOf() - a.chatSession.createdAt.valueOf());
-    return { allSessionsWithOrderedQuestionAnswers };
+    return {
+        allSessionsWithOrderedQuestionAnswers,
+        syntheticAnswersByChatSessionId: state.syntheticAnswersByChatSessionId ?? {},
+    };
+}
+export function getSyntheticAiCfoAnswersForChatSession(state, chatSessionId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId] ?? [];
+    return arr
+        .slice()
+        .sort((a, b) => a.createdAt.valueOf() - b.createdAt.valueOf());
+}
+export function getSyntheticAiCfoAnswerByQuestionAnswerId(state, chatSessionId, questionAnswerId) {
+    const arr = state.syntheticAnswersByChatSessionId?.[chatSessionId];
+    if (arr == null) {
+        return undefined;
+    }
+    return arr.find((answer) => answer.sourceQuestionAnswerId === questionAnswerId);
 }

package/lib/esm/entity/aiCfo/aiCfoState.js

@@ -7,7 +7,14 @@ export const ALL_AI_CFO_CHARTS_TYPES = [
 export const ALL_AI_CFO_VISUALIZATION_TYPES = [
     ...ALL_AI_CFO_CHARTS_TYPES,
     'table',
+    'interactive_form',
 ];
+export const ALL_INTERACTIVE_FORM_TYPES = [
+    'cards_creation',
+    'card_policy',
+];
+export const toInteractiveFormType = (v) => stringToUnion(v, ALL_INTERACTIVE_FORM_TYPES);
+export const toInteractiveFormTypeStrict = (v) => stringToUnionStrict(v, ALL_INTERACTIVE_FORM_TYPES);
 export const toAiCfoVisualizationType = (v) => stringToUnion(v, ALL_AI_CFO_VISUALIZATION_TYPES);
 export const toAiCfoVisualizationTypeStrict = (v) => stringToUnionStrict(v, ALL_AI_CFO_VISUALIZATION_TYPES);
 export const toAiCfoChartType = (v) => stringToUnion(v, ALL_AI_CFO_CHARTS_TYPES);
@@ -58,3 +65,13 @@ export const toMessageSender = (v) => stringToUnion(v, ALL_MESSAGE_SENDERS);
 export const toMessageType = (v) => stringToUnion(v, ALL_MESSAGE_TYPES);
 export const toMessageSenderStrict = (v) => stringToUnionStrict(v, ALL_MESSAGE_SENDERS);
 export const toMessageTypeStrict = (v) => stringToUnionStrict(v, ALL_MESSAGE_TYPES);
+// Client-synthesized AI CFO answer bubbles (Creating…/Created) pushed when the user
+// submits an interactive form; not streamed from the backend.
+export const ALL_SYNTHETIC_AI_CFO_ANSWER_KINDS = [
+    'creating_cards',
+    'creating_policy',
+    'created_cards',
+    'created_policy',
+    'errored_cards',
+    'errored_policy',
+];

package/lib/esm/entity/approvalRule/approvalRuleConflict.js

@@ -0,0 +1,74 @@
+export function detectRuleOverlap({ candidateCriteria, existingRules, excludeRuleId, }) {
+    const candidateAmount = pickAmount(candidateCriteria);
+    const candidateVendor = pickVendor(candidateCriteria);
+    const candidateDepartment = pickDepartment(candidateCriteria);
+    const overlaps = [];
+    for (const rule of existingRules) {
+        if (rule.approvalRuleId === excludeRuleId) {
+            continue;
+        }
+        if (rule.isFallback === true) {
+            continue;
+        }
+        const ruleVendor = pickVendor(rule.criteria);
+        const ruleDepartment = pickDepartment(rule.criteria);
+        if (!areVendorCriteriaEqual(candidateVendor, ruleVendor)) {
+            continue;
+        }
+        if (!areDepartmentCriteriaEqual(candidateDepartment, ruleDepartment)) {
+            continue;
+        }
+        const ruleAmount = pickAmount(rule.criteria);
+        if (amountsOverlap(candidateAmount, ruleAmount)) {
+            overlaps.push({ conflictingRule: rule });
+        }
+    }
+    return overlaps;
+}
+const pickAmount = (criteria) => criteria.find((c) => c.type === 'amount');
+const pickVendor = (criteria) => criteria.find((c) => c.type === 'vendor');
+const pickDepartment = (criteria) => criteria.find((c) => c.type === 'department');
+const areVendorCriteriaEqual = (a, b) => {
+    if (a == null && b == null) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    if (a.operator !== b.operator) {
+        return false;
+    }
+    return idsEqual(a.vendorIds, b.vendorIds);
+};
+const areDepartmentCriteriaEqual = (a, b) => {
+    if (a == null && b == null) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    if (a.operator !== b.operator) {
+        return false;
+    }
+    return idsEqual(a.departmentIds, b.departmentIds);
+};
+const idsEqual = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const aSorted = [...a].sort();
+    const bSorted = [...b].sort();
+    return aSorted.every((id, i) => id === bSorted[i]);
+};
+const amountsOverlap = (a, b) => {
+    // Absent amount criteria covers the whole real line, so any
+    // pairing involving an absent one is a guaranteed overlap.
+    if (a == null || b == null) {
+        return true;
+    }
+    const aLow = a.min?.amount ?? Number.NEGATIVE_INFINITY;
+    const aHigh = a.max?.amount ?? Number.POSITIVE_INFINITY;
+    const bLow = b.min?.amount ?? Number.NEGATIVE_INFINITY;
+    const bHigh = b.max?.amount ?? Number.POSITIVE_INFINITY;
+    return Math.max(aLow, bLow) <= Math.min(aHigh, bHigh);
+};

package/lib/esm/entity/approvalRule/approvalRulePayload.js

@@ -14,18 +14,153 @@ export const toApprovalRule = (payload) => ({
     version: payload.version,
     criteria: toApprovalCriteria(payload.criteria),
     steps: toApprovalSteps(payload.steps),
+    description: payload.description ?? undefined,
+    priority: payload.priority,
+    isFallback: payload.is_fallback ?? false,
+    separationOfDuties: payload.is_separation_of_duty_enabled ?? false,
+    areApprovalsSerialized: payload.are_approvals_serialized,
+    pendingApprovalsCount: payload.pending_approvals_count,
+    pendingEntityApprovalUpdateStatus: payload.pending_entity_approval_update_status,
 });
+/**
+ * Maps the wire-level criteria block into the state-side discriminated
+ * `Criteria[]` union.
+ *
+ * The wire keeps each condition as a flat row inside `conditions[]`.
+ * Amount comparisons can show up as a `gte` only, a `lte` only, or a
+ * `gte` + `lte` pair — those collapse into a single AmountCriteria whose
+ * `comparator` is `greater_than`, `less_than`, or `range` respectively.
+ *
+ * Vendor and department conditions map one-to-one: `in` becomes `is`,
+ * `not_in` becomes `is_not`.
+ *
+ * Resilient to two forms of upstream drift:
+ *  - Missing / null criteria → returns [].
+ *  - Legacy criteria shape (array of amount-range objects, the pre-3.0
+ *    wire) → converted to an AmountCriteria so existing rules in production
+ *    still render while the backend rolls out.
+ */
 const toApprovalCriteria = (payload) => {
-    return payload.map((criteria) => ({
-        rangeType: criteria.type,
-        rangeEntity: criteria.range_entity,
-        range: {
-            min: toAmount(criteria.min, criteria.currency_code, criteria.currency_symbol),
-            max: criteria.max != null
-                ? toAmount(criteria.max, criteria.currency_code, criteria.currency_symbol)
-                : undefined,
-        },
-    }));
+    if (payload == null) {
+        return [];
+    }
+    if (Array.isArray(payload)) {
+        // Legacy pre-3.0 wire: an array of amount-range entries.
+        return legacyAmountRangeToCriteria(payload);
+    }
+    if (!Array.isArray(payload.conditions)) {
+        return [];
+    }
+    const results = [];
+    const amountCriteria = toAmountCriteria(payload);
+    if (amountCriteria != null) {
+        results.push(amountCriteria);
+    }
+    payload.conditions
+        .filter((condition) => condition.field === 'vendor_id')
+        .forEach((condition) => {
+        const vendor = toVendorCriteria(condition);
+        if (vendor != null) {
+            results.push(vendor);
+        }
+    });
+    payload.conditions
+        .filter((condition) => condition.field === 'department_id')
+        .forEach((condition) => {
+        const department = toDepartmentCriteria(condition);
+        if (department != null) {
+            results.push(department);
+        }
+    });
+    return results;
+};
+const legacyAmountRangeToCriteria = (legacy) => {
+    if (legacy.length === 0) {
+        return [];
+    }
+    // The state-side 'Criteria[]' model allows at most one
+    // 'AmountCriteria' per rule (see 'approvalRuleState.ts'). The legacy
+    // wire was an array, so a multi-entry payload can't be represented
+    // here without losing data. Read the first entry and log a warning
+    // if production rules ever ship more — that would signal a backend
+    // regression we want to catch early rather than silently truncating.
+    if (legacy.length > 1) {
+        console.warn('[approvalRulePayload] legacyAmountRangeToCriteria: received ' +
+            legacy.length +
+            ' entries but the state model only supports one; using the ' +
+            'first entry and dropping the rest.');
+    }
+    const first = legacy[0] ?? {};
+    const currency = first.currency_code ?? 'USD';
+    const symbol = first.currency_symbol ?? '$';
+    const min = typeof first.min === 'number'
+        ? toAmount(first.min, currency, symbol)
+        : undefined;
+    const max = typeof first.max === 'number'
+        ? toAmount(first.max, currency, symbol)
+        : undefined;
+    if (min == null && max == null) {
+        return [];
+    }
+    const comparator = min != null && max != null
+        ? 'range'
+        : min != null
+            ? 'greater_than'
+            : 'less_than';
+    return [{ type: 'amount', comparator, min, max }];
+};
+const toAmountCriteria = (payload) => {
+    if (!Array.isArray(payload.conditions)) {
+        return undefined;
+    }
+    const amountConditions = payload.conditions.filter((condition) => condition.field === 'amount');
+    // Approval Rules 3.0 — an 'eq' condition represents min === max. Fold
+    // it into both finders so it decodes as comparator: 'range' (closed
+    // single-point) rather than 'greater_than' (open upper).
+    const gteCondition = amountConditions.find((condition) => condition.type === 'gte' || condition.type === 'eq');
+    const lteCondition = amountConditions.find((condition) => condition.type === 'lte' || condition.type === 'eq');
+    if (gteCondition == null && lteCondition == null) {
+        return undefined;
+    }
+    const currencyCode = payload.currency_code ?? 'USD';
+    const currencySymbol = payload.currency_symbol ?? '$';
+    const min = typeof gteCondition?.value === 'number'
+        ? toAmount(gteCondition.value, currencyCode, currencySymbol)
+        : undefined;
+    const max = typeof lteCondition?.value === 'number'
+        ? toAmount(lteCondition.value, currencyCode, currencySymbol)
+        : undefined;
+    let comparator;
+    if (min != null && max != null) {
+        comparator = 'range';
+    }
+    else if (min != null) {
+        comparator = 'greater_than';
+    }
+    else {
+        comparator = 'less_than';
+    }
+    return { type: 'amount', comparator, min, max };
+};
+const toVendorCriteria = (condition) => {
+    if (!Array.isArray(condition.value)) {
+        return undefined;
+    }
+    return {
+        type: 'vendor',
+        operator: condition.type === 'not_in' ? 'is_not' : 'is',
+        vendorIds: condition.value,
+    };
+};
+const toDepartmentCriteria = (condition) => {
+    if (!Array.isArray(condition.value)) {
+        return undefined;
+    }
+    return {
+        type: 'department',
+        operator: condition.type === 'not_in' ? 'is_not' : 'is',
+        departmentIds: condition.value,
+    };
 };
 const toApprovalSteps = (payload) => {
     return payload.map((step) => ({

package/lib/esm/entity/approvalRule/approvalRuleSelector.js

@@ -7,3 +7,38 @@ export function getApprovalRulesByIds(approvalRuleState, approvalRuleIds) {
         .filter((value) => value != null);
     return approvalRulesByIds;
 }
+/**
+ * Returns the amount-range portion of a rule's criteria, if any.
+ *
+ * Use this whenever a caller needs to read amount min/max from the new
+ * discriminated `Criteria` union without inlining a type guard.
+ */
+export function getAmountCriteria(criteria) {
+    return criteria.find((c) => c.type === 'amount');
+}
+export function getVendorCriteria(criteria) {
+    return criteria.find((c) => c.type === 'vendor');
+}
+export function getDepartmentCriteria(criteria) {
+    return criteria.find((c) => c.type === 'department');
+}
+/**
+ * Returns all rules of the given entityType, sorted by `priority` ascending.
+ *
+ * Rules without a `priority` value sort to the end (treated as Infinity).
+ * Use this for the list page where rules render in evaluation order.
+ */
+export function getApprovalRulesByEntityType(approvalRuleState, entityType) {
+    return Object.values(approvalRuleState.approvalRuleById)
+        .filter((rule) => rule.entityType === entityType)
+        .sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
+}
+/**
+ * Returns the tenant's fallback rule for the given entityType, if one exists.
+ *
+ * The fallback rule is shown by the "fallback engine active" banner on the
+ * list page and is used to handle bills/reimbursements that match no other rule.
+ */
+export function getFallbackApprovalRule(approvalRuleState, entityType) {
+    return Object.values(approvalRuleState.approvalRuleById).find((rule) => rule.entityType === entityType && rule.isFallback === true);
+}