@zeniai/client-epic-state 5.0.83-betaRR3 → 5.0.83-betaRR5

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildAiCardPolicyFormDraftSeed.js

@@ -0,0 +1,385 @@
+import { buildVendorChipId, toMccCategoryChipFieldValue, toVendorChipFieldValue, } from './cardPolicyChipIds';
+import { CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT, CARD_POLICY_LIMIT_ROW_ID_TRANSACTION, } from './cardPolicyFormDraftTypes';
+const EMPTY_ALLOW_BLOCK = {
+    mode: 'allow',
+    allowItems: [],
+    blockItems: [],
+};
+const EMPTY_FORM_VALUES = {
+    vendorPolicy: EMPTY_ALLOW_BLOCK,
+    categoryPolicy: EMPTY_ALLOW_BLOCK,
+    cardSelections: [],
+    limits: [],
+    policiesReview: [],
+};
+export const buildEmptyLimitRows = () => [
+    { id: CARD_POLICY_LIMIT_ROW_ID_TRANSACTION, isEnabled: false },
+    { id: CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT, isEnabled: false },
+];
+/**
+ * Build the initial `CardPolicyFormDraft` + companion seed context for
+ * a fresh AI CFO card-policy session. Used by the
+ * `seedAiCardPolicyFormDraft` reducer.
+ *
+ * - `auto` (1-step review): chip groups are built eagerly from each
+ *   `draftPolicies[i]` since there's no live form to derive from.
+ * - `guided` (5-step wizard): Steps 1–4 seeded from `draftPolicies[0]`,
+ *   Step 5 seeded with one identity-only row per `draftPolicies[i]`;
+ *   chip groups are re-derived on every `applyAiCardPolicyFormDraftUpdate`.
+ * - `upload` (3-step): pre-recommendation returns an empty scaffold;
+ *   post-recommendation, Step 5 review rows + their chip groups are
+ *   derived from `wizardPlan.step5Review.draftPolicies`.
+ */
+export const buildAiCardPolicyFormDraftSeed = ({ initialData, cardsMasterList = [], categorySearchOptions, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const suggestedPoliciesSeed = buildSuggestedPoliciesSeed(initialData);
+    const wizardPlan = 'wizardPlan' in initialData ? initialData.wizardPlan : undefined;
+    const source = initialData.policyKind === 'upload' ? initialData.source : undefined;
+    const context = {
+        policyKind: initialData.policyKind,
+        cardsMasterList,
+        categorySearchOptions: categorySearchOptions ?? [],
+        suggestedAllowMerchants,
+        suggestedBlockMerchants,
+        suggestedAllowCategories,
+        suggestedBlockCategories,
+        suggestedPoliciesSeed,
+        wizardPlan,
+        source,
+    };
+    const draft = buildDraftFromInitialData({
+        initialData,
+        cardsMasterList,
+        categorySearchOptions,
+        suggestedAllowMerchants,
+        suggestedBlockMerchants,
+        suggestedAllowCategories,
+        suggestedBlockCategories,
+    });
+    return { draft, context };
+};
+const buildDraftFromInitialData = ({ initialData, cardsMasterList, categorySearchOptions, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const vendorAllowSeed = merchantsToChips(suggestedAllowMerchants);
+    const vendorBlockSeed = merchantsToChips(suggestedBlockMerchants);
+    const categoryAllowSeed = categoriesToChips(suggestedAllowCategories);
+    const categoryBlockSeed = categoriesToChips(suggestedBlockCategories);
+    if (initialData.policyKind === 'auto') {
+        const autoDraftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies ?? [];
+        return {
+            ...EMPTY_FORM_VALUES,
+            policyKind: 'auto',
+            policiesReview: buildAutoReviewRows(autoDraftPolicies, cardsMasterList, categorySearchOptions),
+        };
+    }
+    if (initialData.policyKind === 'upload') {
+        const uploadDraftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies;
+        if (uploadDraftPolicies == null) {
+            return {
+                ...EMPTY_FORM_VALUES,
+                policyKind: 'upload',
+                cardSelections: cardsMasterList.map((row) => ({
+                    ...row,
+                    isChecked: false,
+                })),
+                limits: buildEmptyLimitRows(),
+            };
+        }
+        return {
+            ...EMPTY_FORM_VALUES,
+            policyKind: 'upload',
+            cardSelections: cardsMasterList.map((row) => ({
+                ...row,
+                isChecked: false,
+            })),
+            limits: buildEmptyLimitRows(),
+            policiesReview: buildUploadReviewRows(uploadDraftPolicies, cardsMasterList, categorySearchOptions),
+        };
+    }
+    // Guided
+    const draftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies ?? [];
+    const primary = draftPolicies[0];
+    if (primary == null) {
+        return {
+            policyKind: 'guided',
+            vendorPolicy: buildAllowBlockFromSeeds(vendorAllowSeed, vendorBlockSeed),
+            categoryPolicy: buildAllowBlockFromSeeds(categoryAllowSeed, categoryBlockSeed),
+            cardSelections: cardsMasterList.map((row) => ({
+                ...row,
+                isChecked: false,
+            })),
+            limits: buildEmptyLimitRows(),
+            policiesReview: [],
+        };
+    }
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    const vendorMode = inferAllowBlockMode(primary.allowedEntity.merchantNames.length, primary.blockedEntity.merchantNames.length);
+    const aiVendorAllow = draftMerchantsToChips(primary.allowedEntity.merchantNames);
+    const aiVendorBlock = draftMerchantsToChips(primary.blockedEntity.merchantNames);
+    const vendorPolicy = {
+        mode: vendorMode,
+        allowItems: mergeAiAndSeedChips(aiVendorAllow, vendorAllowSeed),
+        blockItems: mergeAiAndSeedChips(aiVendorBlock, vendorBlockSeed),
+    };
+    const categoryMode = inferAllowBlockMode(primary.allowedEntity.categoryCodes.length, primary.blockedEntity.categoryCodes.length);
+    const aiCategoryAllow = draftCategoryCodesToChips(primary.allowedEntity.categoryCodes, mccCodeToCategory);
+    const aiCategoryBlock = draftCategoryCodesToChips(primary.blockedEntity.categoryCodes, mccCodeToCategory);
+    const categoryPolicy = {
+        mode: categoryMode,
+        allowItems: mergeAiAndSeedChips(aiCategoryAllow, categoryAllowSeed),
+        blockItems: mergeAiAndSeedChips(aiCategoryBlock, categoryBlockSeed),
+    };
+    const cardSelections = cardsMasterList.map((row) => ({
+        ...row,
+        isChecked: primary.applyToCards.includes(row.id),
+    }));
+    const limits = [
+        {
+            id: CARD_POLICY_LIMIT_ROW_ID_TRANSACTION,
+            isEnabled: primary.spendLimits.transaction > 0,
+            amount: primary.spendLimits.transaction > 0
+                ? primary.spendLimits.transaction
+                : undefined,
+        },
+        {
+            id: CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT,
+            isEnabled: primary.requiredReceiptThreshold > 0,
+            amount: primary.requiredReceiptThreshold > 0
+                ? primary.requiredReceiptThreshold
+                : undefined,
+        },
+    ];
+    return {
+        policyKind: 'guided',
+        vendorPolicy,
+        categoryPolicy,
+        cardSelections,
+        limits,
+        policiesReview: draftPolicies.map((p) => ({
+            id: p.id,
+            isChecked: true,
+            name: p.name,
+            chipGroups: [],
+        })),
+    };
+};
+const buildSuggestedPoliciesSeed = (initialData) => (initialData.wizardPlan?.step5Review?.draftPolicies ?? []).map((draft) => ({
+    id: draft.id,
+    name: draft.name,
+    isChecked: true,
+}));
+const merchantsToChips = (names) => (names ?? []).map((name) => toVendorChipFieldValue(name, false));
+const categoriesToChips = (categories) => (categories ?? []).map((category) => toMccCategoryChipFieldValue(category, false));
+const buildAllowBlockFromSeeds = (allowItems, blockItems) => {
+    if (allowItems.length === 0 && blockItems.length === 0) {
+        return EMPTY_ALLOW_BLOCK;
+    }
+    return { mode: 'allow', allowItems, blockItems };
+};
+const buildMccCodeToCategoryMap = (categories) => {
+    const map = new Map();
+    for (const category of categories ?? []) {
+        for (const code of category.mccCodes) {
+            if (!map.has(code)) {
+                map.set(code, category);
+            }
+        }
+    }
+    return map;
+};
+const buildOwnerSummaries = (cardIds, cardsMasterList) => {
+    const cardsById = new Map(cardsMasterList.map((card) => [card.id, card]));
+    const summaries = new Map();
+    for (const cardId of cardIds) {
+        const card = cardsById.get(cardId);
+        if (card == null) {
+            continue;
+        }
+        const existing = summaries.get(card.owner.userId);
+        if (existing != null) {
+            existing.cardIds.push(cardId);
+            continue;
+        }
+        summaries.set(card.owner.userId, {
+            userId: card.owner.userId,
+            displayName: card.owner.displayName,
+            cardIds: [cardId],
+        });
+    }
+    return Array.from(summaries.values());
+};
+const buildAutoReviewChipGroupsForDraft = (draft, cardsMasterList, mccCodeToCategory) => {
+    const groups = [];
+    if (draft.allowedEntity.merchantNames.length > 0) {
+        groups.push({
+            id: 'allowed-vendors',
+            label: 'Allowed Vendors',
+            chips: draft.allowedEntity.merchantNames.map((name) => ({
+                id: buildVendorChipId(name),
+                label: name,
+                chipKind: 'positive',
+                isSelected: true,
+            })),
+        });
+    }
+    if (draft.blockedEntity.merchantNames.length > 0) {
+        groups.push({
+            id: 'blocked-vendors',
+            label: 'Blocked Vendors',
+            chips: draft.blockedEntity.merchantNames.map((name) => ({
+                id: buildVendorChipId(name),
+                label: name,
+                chipKind: 'negative',
+                isSelected: true,
+            })),
+        });
+    }
+    if (draft.allowedEntity.categoryCodes.length > 0) {
+        groups.push({
+            id: 'allowed-categories',
+            label: 'Allowed Categories',
+            chips: draft.allowedEntity.categoryCodes.map((code) => {
+                const category = mccCodeToCategory.get(code);
+                const label = category != null ? `${category.name} (${code})` : code;
+                return {
+                    id: code,
+                    label,
+                    chipKind: 'positive',
+                    isSelected: true,
+                    optionalCode: code,
+                };
+            }),
+        });
+    }
+    if (draft.blockedEntity.categoryCodes.length > 0) {
+        groups.push({
+            id: 'restricted-categories',
+            label: 'Restricted Categories',
+            chips: draft.blockedEntity.categoryCodes.map((code) => {
+                const category = mccCodeToCategory.get(code);
+                const label = category != null ? `${category.name} (${code})` : code;
+                return {
+                    id: code,
+                    label,
+                    chipKind: 'negative',
+                    isSelected: true,
+                    optionalCode: code,
+                };
+            }),
+        });
+    }
+    if (draft.applyToCards.length > 0) {
+        const owners = buildOwnerSummaries(draft.applyToCards, cardsMasterList);
+        if (owners.length > 0) {
+            groups.push({
+                id: 'applied-to-cards',
+                label: 'Applied to Cards',
+                chips: owners.map((owner) => ({
+                    id: owner.userId,
+                    label: owner.displayName,
+                    chipKind: 'avatar',
+                    cardIds: owner.cardIds,
+                    isSelected: true,
+                })),
+            });
+        }
+    }
+    return groups;
+};
+const buildAutoReviewRows = (draftPolicies, cardsMasterList, categorySearchOptions) => {
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    return draftPolicies.map((draft) => ({
+        id: draft.id,
+        isChecked: true,
+        name: draft.name,
+        chipGroups: buildAutoReviewChipGroupsForDraft(draft, cardsMasterList, mccCodeToCategory),
+    }));
+};
+/**
+ * Upload-only "Limits" chip group carrying the draft's
+ * `spend_limits.transaction` and `required_receipt_threshold`. Each
+ * chip stashes its numeric value on `optionalCode` so the bulk-submit
+ * builder can recover it without re-parsing the label.
+ */
+const buildUploadLimitsChipGroup = (draft) => {
+    const transactionEnabled = draft.spendLimits.transaction > 0;
+    const receiptEnabled = draft.requiredReceiptThreshold > 0;
+    return {
+        id: 'limits',
+        label: 'Limits',
+        kind: 'limits',
+        chips: [
+            {
+                id: 'limit-transaction',
+                label: 'Transaction Limit',
+                helperText: 'Maximum amount per single transaction',
+                placeholder: '$0',
+                chipKind: 'positive',
+                isSelected: transactionEnabled,
+                optionalCode: transactionEnabled
+                    ? String(draft.spendLimits.transaction)
+                    : undefined,
+            },
+            {
+                id: 'limit-receipt',
+                label: 'Require Receipt',
+                helperText: 'Require a receipt above this amount',
+                placeholder: '$0',
+                chipKind: 'positive',
+                isSelected: receiptEnabled,
+                optionalCode: receiptEnabled
+                    ? String(draft.requiredReceiptThreshold)
+                    : undefined,
+            },
+        ],
+    };
+};
+export const buildUploadReviewRows = (draftPolicies, cardsMasterList, categorySearchOptions) => {
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    return draftPolicies.map((draft) => {
+        const chipGroups = buildAutoReviewChipGroupsForDraft(draft, cardsMasterList, mccCodeToCategory);
+        chipGroups.push(buildUploadLimitsChipGroup(draft));
+        return {
+            id: draft.id,
+            isChecked: true,
+            name: draft.name,
+            chipGroups,
+        };
+    });
+};
+/**
+ * Infer the AllowBlock mode for a draft policy field. The BE doesn't
+ * tell the FE which radio to pre-select; mirrors the rule used by
+ * `applyExtractedPolicyTo*FormValues`:
+ *
+ *  - allow side has any value → `"allow"`
+ *  - block side has any value → `"block"`
+ *  - both empty → `"allow"` (default)
+ *  - both populated → `"allow"` (user can flip the radio to reveal block).
+ */
+const inferAllowBlockMode = (allowCount, blockCount) => {
+    if (allowCount > 0) {
+        return 'allow';
+    }
+    if (blockCount > 0) {
+        return 'block';
+    }
+    return 'allow';
+};
+const draftMerchantsToChips = (names) => names.map((name) => toVendorChipFieldValue(name, true));
+const draftCategoryCodesToChips = (codes, mccCodeToCategory) => codes.map((code) => {
+    const category = mccCodeToCategory.get(code);
+    if (category != null) {
+        return toMccCategoryChipFieldValue(category, true);
+    }
+    return {
+        id: code,
+        label: code,
+        isSelected: true,
+        optionalCode: code,
+        optionalCodes: [code],
+    };
+});
+const mergeAiAndSeedChips = (aiChips, seedChips) => {
+    const seenIds = new Set(aiChips.map((chip) => chip.id));
+    const extraSeeds = seedChips.filter((chip) => !seenIds.has(chip.id));
+    return [...aiChips, ...extraSeeds];
+};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildManualCardPolicyFormDraftSeed.js

@@ -0,0 +1,34 @@
+import { buildEmptyLimitRows } from './buildAiCardPolicyFormDraftSeed';
+import { toMccCategoryChipFieldValue, toVendorChipFieldValue, } from './cardPolicyChipIds';
+const EMPTY_ALLOW_BLOCK = {
+    mode: 'allow',
+    allowItems: [],
+    blockItems: [],
+};
+/**
+ * Build the initial `CardPolicyCreateFormDraft` for a fresh manual
+ * create-page session. Mirrors the AI guided seed minus the wizard
+ * plan: every BE-suggested chip lands `isSelected: false` so the user
+ * has to opt each suggestion onto the policy explicitly.
+ */
+export const buildManualCardPolicyFormDraftSeed = ({ cardsMasterList = [], suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const vendorAllow = (suggestedAllowMerchants ?? []).map((name) => toVendorChipFieldValue(name, false));
+    const vendorBlock = (suggestedBlockMerchants ?? []).map((name) => toVendorChipFieldValue(name, false));
+    const categoryAllow = (suggestedAllowCategories ?? []).map((category) => toMccCategoryChipFieldValue(category, false));
+    const categoryBlock = (suggestedBlockCategories ?? []).map((category) => toMccCategoryChipFieldValue(category, false));
+    const vendorPolicy = vendorAllow.length === 0 && vendorBlock.length === 0
+        ? EMPTY_ALLOW_BLOCK
+        : { mode: 'allow', allowItems: vendorAllow, blockItems: vendorBlock };
+    const categoryPolicy = categoryAllow.length === 0 && categoryBlock.length === 0
+        ? EMPTY_ALLOW_BLOCK
+        : { mode: 'allow', allowItems: categoryAllow, blockItems: categoryBlock };
+    return {
+        name: '',
+        description: '',
+        mode: 'strict',
+        vendorPolicy,
+        categoryPolicy,
+        cardSelections: cardsMasterList.map((row) => ({ ...row, isChecked: false })),
+        limits: buildEmptyLimitRows(),
+    };
+};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyChipIds.js

@@ -0,0 +1,33 @@
+/**
+ * Centralized chip-id derivation so seeds, search-dropdown rows,
+ * saved-template recoveries, and the dedupe logic in
+ * `AllowBlockChipPicker.handleAddItem` all key off the **same** id for
+ * the same logical entity.
+ *
+ * The dedupe path is content-blind (`existing.id === option.id`): if
+ * the id strings don't match, the picker treats the option as a new
+ * chip and appends a duplicate. Every producer of chip values for the
+ * card-policy flow MUST funnel through these helpers.
+ *
+ * - Vendors: `vendor-${name.trim().toLowerCase()}`. Two vendors that
+ *   share an identical display name collapse into one chip.
+ * - MCC categories: `mcc-${name}`. Matches the legacy
+ *   `toCategoryChipOption` convention so the saved-template loader
+ *   keeps recovering chips by id.
+ */
+export const VENDOR_CHIP_ID_PREFIX = 'vendor-';
+export const MCC_CHIP_ID_PREFIX = 'mcc-';
+export const buildVendorChipId = (name) => `${VENDOR_CHIP_ID_PREFIX}${name.trim().toLowerCase()}`;
+export const buildMccCategoryChipId = (name) => `${MCC_CHIP_ID_PREFIX}${name}`;
+export const toVendorChipFieldValue = (name, isSelected) => ({
+    id: buildVendorChipId(name),
+    label: name,
+    isSelected,
+});
+export const toMccCategoryChipFieldValue = (category, isSelected) => ({
+    id: buildMccCategoryChipId(category.name),
+    label: category.name,
+    isSelected,
+    optionalCode: category.mccCodes[0],
+    optionalCodes: [...category.mccCodes],
+});

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyFormDraftTypes.js

@@ -0,0 +1,17 @@
+/**
+ * Stable id for the transaction-limit toggle row inside `limits`.
+ */
+export const CARD_POLICY_LIMIT_ROW_ID_TRANSACTION = 'transactionLimit';
+/**
+ * Stable id for the require-receipt toggle row inside `limits`.
+ */
+export const CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT = 'requireReceipt';
+/**
+ * Adapter so callers can hand the `MccCategory[]` array from
+ * `cardPolicyState.mccCategories` (or the suggested seeds) straight to
+ * the helpers expecting `MccCategoryLike[]`.
+ */
+export const toMccCategoryLike = (category) => ({
+    name: category.name,
+    mccCodes: category.mccCodes,
+});

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyRequestParts.js

@@ -0,0 +1,144 @@
+/**
+ * Shared helpers for building the wire-ready
+ * `CreateCardPolicyTemplateRequest` payload from either the manual
+ * `CardPolicyCreateFormDraft` or the AI CFO `CardPolicyFormDraft`.
+ * Both forms emit the same `vendorPolicy` / `categoryPolicy` /
+ * `limits` slices, so the mapping primitives are factored out here.
+ */
+/**
+ * Project the merchant names (chip `label`) selected on the given
+ * allow / block field, but only when the field's `mode` matches
+ * `forMode`. The other side's chips are preserved in form state for
+ * fast mode-flip but never belong on the wire for the current submit.
+ */
+export const collectMerchantNames = (field, forMode) => {
+    if (field.mode !== forMode) {
+        return [];
+    }
+    const items = forMode === 'allow' ? field.allowItems : field.blockItems;
+    return items.filter((item) => item.isSelected).map((item) => item.label);
+};
+/**
+ * Project the MCC codes selected on the given allow / block field.
+ * Chips with `optionalCodes` emit every code; chips lacking the plural
+ * fall back to the singular `optionalCode`. Chips with neither are
+ * dropped silently.
+ */
+export const collectCategoryCodes = (field, forMode) => {
+    if (field.mode !== forMode) {
+        return [];
+    }
+    const items = forMode === 'allow' ? field.allowItems : field.blockItems;
+    return items
+        .filter((item) => item.isSelected)
+        .flatMap((item) => {
+        if (item.optionalCodes != null && item.optionalCodes.length > 0) {
+            return item.optionalCodes;
+        }
+        return item.optionalCode != null ? [item.optionalCode] : [];
+    });
+};
+/**
+ * `null` when the toggle is off (BE treats `null` as "no threshold");
+ * otherwise the row's `amount` (or `0` when unset but the toggle is on).
+ */
+export const amountFromLimitRow = (limits, rowId) => {
+    const row = limits.find((entry) => entry.id === rowId);
+    if (row == null || !row.isEnabled) {
+        return null;
+    }
+    return row.amount ?? 0;
+};
+const REVIEW_GROUP_ID_ALLOWED_VENDORS = 'allowed-vendors';
+const REVIEW_GROUP_ID_BLOCKED_VENDORS = 'blocked-vendors';
+const REVIEW_GROUP_ID_ALLOWED_CATEGORIES = 'allowed-categories';
+const REVIEW_GROUP_ID_RESTRICTED_CATEGORIES = 'restricted-categories';
+const REVIEW_GROUP_ID_APPLIED_TO_CARDS = 'applied-to-cards';
+const REVIEW_GROUP_ID_LIMITS = 'limits';
+const REVIEW_LIMIT_CHIP_ID_TRANSACTION = 'limit-transaction';
+const REVIEW_LIMIT_CHIP_ID_RECEIPT = 'limit-receipt';
+const isChipOn = (chip) => chip.isSelected !== false;
+const findGroup = (row, groupId) => row.chipGroups.find((group) => group.id === groupId);
+const projectMerchantNamesFromGroup = (group) => group == null ? [] : group.chips.filter(isChipOn).map((chip) => chip.label);
+const projectCategoryCodesFromGroup = (group) => {
+    if (group == null) {
+        return [];
+    }
+    const codes = [];
+    for (const chip of group.chips) {
+        if (!isChipOn(chip)) {
+            continue;
+        }
+        if (chip.optionalCode != null && chip.optionalCode.length > 0) {
+            codes.push(chip.optionalCode);
+        }
+    }
+    return codes;
+};
+const projectApplyToCardsFromGroup = (group) => {
+    if (group == null) {
+        return [];
+    }
+    const cardIds = [];
+    for (const chip of group.chips) {
+        if (!isChipOn(chip)) {
+            continue;
+        }
+        if (chip.cardIds != null && chip.cardIds.length > 0) {
+            cardIds.push(...chip.cardIds);
+            continue;
+        }
+        cardIds.push(chip.id);
+    }
+    return cardIds;
+};
+const amountFromLimitsChip = (chip) => {
+    if (chip == null || chip.isSelected !== true) {
+        return null;
+    }
+    if (chip.optionalCode == null || chip.optionalCode.length === 0) {
+        return 0;
+    }
+    const parsed = Number(chip.optionalCode);
+    return Number.isFinite(parsed) ? parsed : 0;
+};
+/**
+ * Project a single `auto`-mode review row's chip groups into the wire
+ * shape. Used by the AI CFO wire builder when `policyKind === "auto"`,
+ * where the source slices are empty and the row's `chipGroups` are
+ * canonical.
+ */
+export const projectAutoReviewRowToCardPolicyRequestParts = (row) => {
+    const limitsGroup = findGroup(row, REVIEW_GROUP_ID_LIMITS);
+    const transactionChip = limitsGroup?.chips.find((chip) => chip.id === REVIEW_LIMIT_CHIP_ID_TRANSACTION);
+    const receiptChip = limitsGroup?.chips.find((chip) => chip.id === REVIEW_LIMIT_CHIP_ID_RECEIPT);
+    return {
+        allowedEntity: {
+            merchantNames: projectMerchantNamesFromGroup(findGroup(row, REVIEW_GROUP_ID_ALLOWED_VENDORS)),
+            categoryCodes: projectCategoryCodesFromGroup(findGroup(row, REVIEW_GROUP_ID_ALLOWED_CATEGORIES)),
+        },
+        blockedEntity: {
+            merchantNames: projectMerchantNamesFromGroup(findGroup(row, REVIEW_GROUP_ID_BLOCKED_VENDORS)),
+            categoryCodes: projectCategoryCodesFromGroup(findGroup(row, REVIEW_GROUP_ID_RESTRICTED_CATEGORIES)),
+        },
+        applyToCards: projectApplyToCardsFromGroup(findGroup(row, REVIEW_GROUP_ID_APPLIED_TO_CARDS)),
+        spendLimits: { transaction: amountFromLimitsChip(transactionChip) },
+        requiredReceiptThreshold: amountFromLimitsChip(receiptChip),
+    };
+};
+/**
+ * Group-id constants used by both auto and bulk wire builders. Exported
+ * so the bulk builder can mirror the contract without re-declaring.
+ */
+export const REVIEW_GROUP_IDS = {
+    allowedVendors: REVIEW_GROUP_ID_ALLOWED_VENDORS,
+    blockedVendors: REVIEW_GROUP_ID_BLOCKED_VENDORS,
+    allowedCategories: REVIEW_GROUP_ID_ALLOWED_CATEGORIES,
+    restrictedCategories: REVIEW_GROUP_ID_RESTRICTED_CATEGORIES,
+    appliedToCards: REVIEW_GROUP_ID_APPLIED_TO_CARDS,
+    limits: REVIEW_GROUP_ID_LIMITS,
+};
+export const REVIEW_LIMIT_CHIP_IDS = {
+    transaction: REVIEW_LIMIT_CHIP_ID_TRANSACTION,
+    receipt: REVIEW_LIMIT_CHIP_ID_RECEIPT,
+};