@final-commerce/command-frame 0.8.0 → 0.9.0-staging.1

package/dist/actions/get-composite-price/types.d.ts

@@ -0,0 +1,31 @@
+import type { CFCompositePick } from '../../CommonTypes';
+export interface GetCompositePriceParams {
+    /** The composite's variant — the one `addProductToCart` takes. */
+    variantId: string;
+    /** The picks so far, exactly as `addProductToCart({ composite })` would send them. */
+    composite: CFCompositePick[];
+    /** B41: the date and time a bookable pick is for, as `addProductToCart` takes it; without one a bookable pick is refused. */
+    compositeSlot?: {
+        startAt: string;
+    };
+}
+export interface GetCompositePriceResponse {
+    success: boolean;
+    /** Why these picks are refused — the same refusal and text `addProductToCart` would give. */
+    reason?: string;
+    /**
+     * What ONE composite with these picks adds to the cart, minor units: the line price the host would build plus the
+     * picked items' modifiers. Before discounts, fees and tax. Show it; do not recompute it. Absent when refused.
+     */
+    total?: number;
+    /**
+     * The parts that still need picks before the composite can be added, and how many ("Pick 2 more"); empty when every
+     * required part is filled. Decided by the host — keep Add to cart disabled while this is not empty.
+     */
+    missing: {
+        partId: string;
+        needed: number;
+    }[];
+    timestamp: string;
+}
+export type GetCompositePrice = (params: GetCompositePriceParams) => Promise<GetCompositePriceResponse>;

package/dist/actions/get-composite-price/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/get-current-cart/mock.d.ts

@@ -1,2 +1,2 @@
-import { GetCurrentCart } from "./types";
+import { GetCurrentCart } from './types';
 export declare const mockGetCurrentCart: GetCurrentCart;

package/dist/actions/get-current-cart/mock.js

@@ -1,9 +1,19 @@
-import { MOCK_CART, safeSerialize } from "../../demo/database";
+import { MOCK_CART, buildModifierRows, safeSerialize } from '../../demo/database';
+import { extendPrice } from '@final-commerce/common';
 export const mockGetCurrentCart = async () => {
-    console.log("[Mock] getCurrentCart called");
+    console.log('[Mock] getCurrentCart called');
+    // The mock keeps no discounts or fees per line: a line is its price × quantity plus its modifier rows.
+    const lineTotals = Object.fromEntries([
+        ...MOCK_CART.products.map((line) => [
+            line.internalId ?? line.id,
+            extendPrice(line.price, line.quantity) + buildModifierRows(line.modifiers, line.quantity).modifiersTotal,
+        ]),
+        ...(MOCK_CART.customSales ?? []).map((sale) => [sale.id, extendPrice(sale.price, sale.quantity)]),
+    ]);
     return {
         success: true,
         cart: safeSerialize(MOCK_CART),
-        timestamp: new Date().toISOString()
+        lineTotals,
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/get-current-cart/types.d.ts

@@ -1,7 +1,13 @@
-import { CFActiveCart } from "../../CommonTypes";
+import { CFActiveCart } from '../../CommonTypes';
 export interface GetCurrentCartResponse {
     success: boolean;
     cart: CFActiveCart;
+    /**
+     * What each line adds to the cart, minor units, keyed by the line's `internalId` (products, bookings) or `id`
+     * (custom sales): price × quantity − its own discounts + its own fees + its modifiers. Before the cart discount
+     * and tax; Σ = the cart's subtotal before non-revenue items. Show it; do not recompute it.
+     */
+    lineTotals?: Record<string, number>;
     timestamp: string;
 }
 export type GetCurrentCart = () => Promise<GetCurrentCartResponse>;

package/dist/actions/get-product-modifier-selections/mock.js

@@ -16,6 +16,18 @@ export const mockGetProductModifierSelections = async (params) => {
             timestamp: new Date().toISOString(),
         };
     }
+    // Like the host (FT-83): a composite line's modifiers belong to its components.
+    if (line.components?.length) {
+        return {
+            success: false,
+            reason: 'The modifiers of a composite line cannot be edited yet: remove the line and add it again with its picks',
+            internalId: line.internalId,
+            selections: [],
+            rows: [],
+            modifiersTotal: 0,
+            timestamp: new Date().toISOString(),
+        };
+    }
     // The priced rows already sit on the line; extending them by the line quantity is
     // the host's job, not the flow's.
     const { rows, modifiersTotal } = buildModifierRows(line.modifiers, line.quantity);

package/dist/actions/get-products/mock.js

@@ -1,9 +1,13 @@
-import { MOCK_PRODUCTS, safeSerialize } from '../../demo/database';
+import { MOCK_PRODUCTS, mockCompositeAtOutlet, mockHiddenProductIds, safeSerialize } from '../../demo/database';
 import { resolveUnit } from '@final-commerce/common';
 export const mockGetProducts = async (params) => {
     console.log('[Mock] getProducts called', params);
-    // Simple filter simulation
-    let products = MOCK_PRODUCTS;
+    // Simple filter simulation. Like the host: a product hidden at this outlet is left out, and a composite offers only
+    // what is sold here.
+    const hidden = mockHiddenProductIds();
+    let products = MOCK_PRODUCTS.filter((p) => !hidden.has(p._id)).map((p) => 
+    // B43: the host never hands a composite modifiers of its own.
+    p.composite ? { ...p, modifiers: [], composite: mockCompositeAtOutlet(p.composite, hidden) } : p);
     const query = params?.query || {};
     // Same rule as the real host: a bookable service is not catalogue stock and is left out unless
     // the query names `productType`. Mirrored here on purpose — a mock that hands back services the

package/dist/actions/get-products/types.d.ts

@@ -27,7 +27,7 @@ export interface GetProductsParams {
         };
         status?: string;
         /**
-         * `simple` | `variable` | `booking`. Naming it at all switches OFF the default exclusion
+         * `simple` | `variable` | `booking` | `composite`. Naming it at all switches OFF the default exclusion
          * of bookable services — including `{ $ne: 'booking' }`, which then means what it says.
          */
         productType?: string | {

package/dist/actions/get-refund-plan/mock.d.ts

@@ -15,9 +15,5 @@ import { GetRefundPlan } from './types';
  * and no company cash-rounding setting, so it always describes a FULL refund
  * with `rounding: 0` and no cash `payout`. Against real kaching the allocation
  * tracks the live selection and carries the drawer snap.
- *
- * `rows` / `allocation.breakdown` follow the engine's reading of the order
- * (`line.total` includes the line's tax) but prorate by plain quantity share;
- * the engine's remainder carry across earlier partial refunds is not modelled.
  */
 export declare const mockGetRefundPlan: GetRefundPlan;

package/dist/actions/get-refund-plan/mock.js

@@ -1,5 +1,4 @@
 import { MOCK_ORDERS } from '../../demo/database';
-import { mockRefundBreakdown, mockRefundRows } from './mockRows';
 /**
  * Demo derivation of the runtime `getRefundPlan`. Builds the per-source rows
  * from the mock order's `paymentMethods`, mirroring the runtime's capacity
@@ -16,10 +15,6 @@ import { mockRefundBreakdown, mockRefundRows } from './mockRows';
  * and no company cash-rounding setting, so it always describes a FULL refund
  * with `rounding: 0` and no cash `payout`. Against real kaching the allocation
  * tracks the live selection and carries the drawer snap.
- *
- * `rows` / `allocation.breakdown` follow the engine's reading of the order
- * (`line.total` includes the line's tax) but prorate by plain quantity share;
- * the engine's remainder carry across earlier partial refunds is not modelled.
  */
 export const mockGetRefundPlan = async (params) => {
     console.log('[Mock] getRefundPlan called', params);
@@ -67,19 +62,16 @@ export const mockGetRefundPlan = async (params) => {
         requiresGiftCardDestination: s.paymentType === 'redeem',
     }));
     const budget = legs.reduce((sum, l) => sum + l.amount, 0);
-    const rows = mockRefundRows(order);
     return {
         success: true,
         orderId: order._id,
         sources,
-        rows,
         allocation: {
             budget,
             // No cash rounding in the demo, so the goods value and the budget agree.
             itemTotal: budget,
             rounding: 0,
             legs,
-            breakdown: mockRefundBreakdown(rows, params?.items),
         },
         // Demo: no prior refunds, so remaining = captured minus the non-revenue load.
         remainingRefundable: Math.max(0, totalCaptured - nonRefundableLiability),

package/dist/actions/get-refund-plan/types.d.ts

@@ -79,81 +79,6 @@ export interface RefundPlanLeg {
         rounding: number;
     };
 }
-export type RefundPlanRowType = 'product' | 'customSale' | 'fee' | 'tip';
-/** One tax rate's share of a row's refund (minor units). */
-export interface RefundPlanTaxLine {
-    name: string;
-    /** Decimal rate as stored on the order (e.g. `0.15`), when the order recorded one. */
-    percentage?: number;
-    amount: number;
-}
-/**
- * The money a row refunds, split the way a receipt shows it. Every field is
- * minor units and already rounded; `subtotal − itemDiscount − cartDiscount +
- * tax === total` always holds. DISPLAY IT — never re-add or prorate it.
- */
-export interface RefundPlanAmounts {
-    /** Before discounts, tax excluded. For a tip row, the tip itself. */
-    subtotal: number;
-    /** Per-item discounts on the refunded quantity (positive). */
-    itemDiscount: number;
-    /** Cart discount share on the refunded quantity (positive). */
-    cartDiscount: number;
-    /** Tax on the refunded quantity. Zero for a tip. */
-    tax: number;
-    /** `tax` per rate — the price breakdown's tax lines. */
-    taxes: RefundPlanTaxLine[];
-    /** What the row refunds. */
-    total: number;
-}
-/**
- * One refundable row of the order — a line item, custom sale, cart fee or tip —
- * served ready to render. Rows with nothing left to refund are not listed.
- */
-export interface RefundPlanRow {
-    type: RefundPlanRowType;
-    /** The key `items[].itemKey` takes, for this call and for `processPartialRefund`. */
-    itemKey: string;
-    /** Line or fee name; `Tip` for a tip. */
-    label: string;
-    /** Product lines only, when the order recorded them. */
-    sku?: string;
-    attributes?: string;
-    /** Tip rows only: the tender that took the tip (`card`, `cash`, …). */
-    paymentType?: string;
-    /** Quantity originally sold. Fees and tips are `1` — all or nothing. */
-    quantity: number;
-    /** Quantity still refundable — the stepper's max. */
-    refundableQuantity: number;
-    /** The money for refunding ALL of `refundableQuantity`. */
-    amounts: RefundPlanAmounts;
-}
-/** One selected row and what refunding the selected quantity of it moves. */
-export interface RefundPlanSelectedRow {
-    type: RefundPlanRowType;
-    itemKey: string;
-    quantity: number;
-    amounts: RefundPlanAmounts;
-}
-/**
- * The selection's goods value broken down for display. Minor units;
- * `items − discounts + fees + tax + tip === total === allocation.itemTotal`.
- */
-export interface RefundPlanTotals {
-    /** Σ selected line subtotals (before discounts, tax excluded). */
-    items: number;
-    /** Σ item + cart discounts on the selected lines (positive). */
-    discounts: number;
-    /** Σ selected cart fees, tax excluded. */
-    fees: number;
-    tax: number;
-    tip: number;
-    total: number;
-}
-export interface RefundPlanBreakdown {
-    rows: RefundPlanSelectedRow[];
-    totals: RefundPlanTotals;
-}
 /**
  * The engine's own allocation of the CURRENT refund selection across the
  * order's captures — what a flow renders and submits instead of computing a
@@ -181,25 +106,11 @@ export interface RefundPlanAllocation {
     rounding: number;
     /** One leg per source that receives money. Submit as `legs`, unchanged. */
     legs: RefundPlanLeg[];
-    /**
-     * What the selection refunds, per row and in total — the numbers a refund
-     * dialog's rows and footer render. Optional so an older runtime still
-     * type-checks; kaching 1.12.1+ always sends it.
-     */
-    breakdown?: RefundPlanBreakdown;
 }
 export interface GetRefundPlanResponse {
     success: boolean;
     orderId: string;
     sources: RefundPlanSource[];
-    /**
-     * Every row still refundable on the order, with the money for refunding all
-     * of it — what a refund dialog lists before anything is selected. Replaces
-     * reading line totals off the order and deciding whether they include tax.
-     * Optional so an older runtime still type-checks; kaching 1.12.1+ always
-     * sends it.
-     */
-    rows?: RefundPlanRow[];
     /**
      * Ready-to-submit allocation of the current selection. Present only when a
      * refund selection exists on the active order. See {@link RefundPlanAllocation}.

package/dist/actions/set-product-modifier-selections/mock.js

@@ -30,6 +30,18 @@ export const mockSetProductModifierSelections = async (params) => {
             timestamp: new Date().toISOString(),
         };
     }
+    // Like the host (FT-83): a composite line's modifiers belong to its components.
+    if (line.components?.length) {
+        return {
+            success: false,
+            reason: 'The modifiers of a composite line cannot be edited yet: remove the line and add it again with its picks',
+            internalId: line.internalId,
+            selections: [],
+            rows: [],
+            modifiersTotal: 0,
+            timestamp: new Date().toISOString(),
+        };
+    }
     // Full replacement — passing [] clears the rows. The line drops the product's resolved
     // stack when it is built, so the menu is re-read from the catalogue to price against.
     // Cart totals are not touched, for the same reason addProductToCart does not move them

package/dist/demo/database.d.ts

@@ -2,7 +2,7 @@
  * Mock Database for Standalone/Demo Mode
  * Stores mock data that mimics the Render environment
  */
-import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout, CFBooking, CFBookingAvailability, CFBookingResource, CFCartLineModifier, CFProdModifierBreakdown, CFModifierSelection, CFResolvedModifier } from '../CommonTypes';
+import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFComposite, CFCartLineComponent, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout, CFBooking, CFBookingAvailability, CFBookingResource, CFBookingSlot, CFCartLineModifier, CFProdModifierBreakdown, CFModifierSelection, CFResolvedModifier } from '../CommonTypes';
 export * from './mocks';
 /** Replace mock catalog / context data in place (same array references mock handlers use). */
 export interface MockDatabaseConfig {
@@ -19,6 +19,12 @@ export interface MockDatabaseConfig {
     bookingResources?: CFBookingResource[];
     /** Windows already taken when the dataset loads, so a calendar does not open empty. */
     bookings?: CFBooking[];
+    /** Products hidden at an outlet (the host's `catalog-visibility`, product-level rows). Empty = sold everywhere. */
+    catalogVisibility?: MockCatalogVisibility[];
+}
+export interface MockCatalogVisibility {
+    productId: string;
+    outletId: string;
 }
 export declare const MOCK_COMPANY: CFActiveCompany;
 export declare const MOCK_OUTLET_MAIN: CFActiveOutlet;
@@ -64,8 +70,40 @@ export declare const MOCK_OUTLETS: import("@final-commerce/common/pos-types").Ac
 export declare const MOCK_CUSTOMERS: import("@final-commerce/common/pos-types").ActiveCustomer[];
 export declare const MOCK_CATEGORIES: import("@final-commerce/common/pos-types").Category[];
 export declare const MOCK_PRODUCT_HAIRCUT: CFProduct;
+export declare const MOCK_PRODUCT_PASTE_TRIO: CFProduct;
 export declare const MOCK_PRODUCTS: import("@final-commerce/common/pos-types").FullProduct[];
 export declare const MOCK_ORDERS: import("@final-commerce/common/pos-types").ActiveOrder[];
+/** Nothing hidden by default; `setMockDatabase({ catalogVisibility })` hides products at an outlet. */
+export declare const MOCK_CATALOG_VISIBILITY: MockCatalogVisibility[];
+/**
+ * The host's cart stock check for composites (kaching `compositeStockRefusal`), over the demo shelves — a copy: what the
+ * cart takes of each component's variant (plain lines and components × their line quantity) against its shelf here.
+ * The demo has no pools or units, so it counts per variant; untracked and backordered variants are never short.
+ */
+export declare function mockCompositeStockRefusal(products: {
+    variantId: string;
+    quantity: number;
+    components?: CFCartLineComponent[];
+}[]): string | null;
+/** Product ids hidden at the demo's active outlet. */
+export declare const mockHiddenProductIds: () => Set<string>;
+/**
+ * The host's outlet rules for a composite (kaching `resolveComposite`), over the demo's static view — a copy, change both
+ * in one step: an item whose product is hidden here is left out, a category item keeps only products sold here (none →
+ * `'empty'`), an Optional part with nothing to pick is not offered, a required one with nothing makes it unavailable,
+ * and the D36 default and "from" price are read off what is left.
+ */
+/** B41: the seats a bookable demo product has free in the slot starting at `startAt` — as the host reads them. */
+export declare function mockBookableWindow(productId: string, startAt: string): {
+    free: number;
+    slot: CFBookingSlot | null;
+};
+export declare const mockIsBookable: (productId: string) => boolean;
+export declare function mockCompositeAtOutlet(composite: Omit<CFComposite, 'needsDate'>, hidden?: Set<string>, 
+/** B41: the window bookable items are judged in; absent = `by_date`. */
+slot?: {
+    startAt: string;
+}): CFComposite;
 export declare const MOCK_PARKED_ORDERS: CFActiveOrder[];
 export declare let MOCK_USER: CFActiveUser;
 export declare let MOCK_STATION: CFActiveStation;

package/dist/demo/database.js

@@ -3,7 +3,7 @@
  * Stores mock data that mimics the Render environment
  */
 import { CFProductType, CFUserTypes, CurrencyCode, } from '../CommonTypes';
-import { extendPrice, resolveUnit, toBase } from '@final-commerce/common';
+import { cheapestCompositeItem, cheapestCompositePrice, extendPrice, resolveUnit, toBase, } from '@final-commerce/common';
 import { BookingRatePeriod, BookingResourceKind, BookingType, ReservationStatus } from '@final-commerce/common';
 export * from './mocks';
 // Asset Imports - Using Remote URLs to avoid build complexity with asset copying
@@ -228,6 +228,7 @@ const createSimpleProduct = (id, name, price, image, categories, description) =>
         maxPrice: price,
         status: 'active',
         productType: CFProductType.SIMPLE,
+        composite: null,
         taxTable: 'tax_standard',
         description,
         images: [image],
@@ -263,6 +264,7 @@ const createVariableProduct = (id, name, basePrice, largePrice, image, categorie
         maxPrice: largePrice,
         status: 'active',
         productType: CFProductType.VARIABLE,
+        composite: null,
         taxTable: 'tax_standard',
         description,
         images: [image],
@@ -658,7 +660,106 @@ export const MOCK_PRODUCT_HAIRCUT = {
     productType: CFProductType.BOOKING,
     bookingRulesId: 'rule_salon_30',
 };
+// A composite (FT-83) as the host serves it: the merchant's price 27.00, items add only their upcharges (B31); each item
+// keeps its own tax (`taxTable` empty). One item points at a deleted variant (unavailable), one is a whole category.
+export const MOCK_PRODUCT_PASTE_TRIO = {
+    ...createSimpleProduct('prod_paste_trio', 'Paste Trio', 2700, basilAlmondImg, [MOCK_CATEGORY_PASTES], 'Pick a paste and a spicy one.'),
+    productType: CFProductType.COMPOSITE,
+    taxTable: '',
+    // B43: a composite has no modifiers of its own; its items carry theirs.
+    modifiers: [],
+    composite: {
+        available: true,
+        basePrice: 2700,
+        fromPrice: 2800,
+        parts: [
+            {
+                _id: 'part_paste',
+                name: 'Paste',
+                required: true,
+                min: 1,
+                max: 1,
+                defaultPick: { itemId: 'item_basil', variantId: 'prod_basil_almond_var_main' },
+                items: [
+                    {
+                        _id: 'item_basil',
+                        variantId: 'prod_basil_almond_var_main',
+                        categoryId: null,
+                        name: 'Basil Almond Paste',
+                        extraCharge: 0,
+                        quantity: 1,
+                        cost: 0,
+                        unavailable: null,
+                        choices: [
+                            {
+                                productId: 'prod_basil_almond',
+                                variantId: 'prod_basil_almond_var_main',
+                                name: 'Basil Almond Paste',
+                                attributes: [],
+                                // The picked product's own modifiers (B28): taxed at its table, sent in the pick.
+                                modifiers: [
+                                    {
+                                        _id: 'mod_texture',
+                                        name: 'Texture',
+                                        selectionType: 'single',
+                                        required: false,
+                                        sortOrder: 0,
+                                        choices: [
+                                            { _id: 'choice_smooth', name: 'Smooth', price: 0, sortOrder: 0 },
+                                            { _id: 'choice_chunky', name: 'Chunky', price: 50, sortOrder: 1 },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        _id: 'item_gone',
+                        variantId: 'prod_gone_var_main',
+                        categoryId: null,
+                        name: '',
+                        extraCharge: 0,
+                        quantity: 1,
+                        cost: 0,
+                        unavailable: 'deleted',
+                        choices: [],
+                    },
+                ],
+            },
+            {
+                _id: 'part_spicy',
+                name: null,
+                required: true,
+                min: 1,
+                max: 2,
+                // "Pick up to 2": no preselected pick (B29 = D36) — the till shows how many are still needed.
+                defaultPick: null,
+                items: [
+                    {
+                        _id: 'item_spicy',
+                        variantId: null,
+                        categoryId: MOCK_CATEGORY_SPICY.id,
+                        name: 'Spicy',
+                        extraCharge: 100,
+                        quantity: 1,
+                        cost: 100,
+                        unavailable: null,
+                        choices: [
+                            {
+                                productId: 'prod_habanero',
+                                variantId: 'prod_habanero_var_main',
+                                name: 'Habanero Paste',
+                                attributes: [],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+};
 export const MOCK_PRODUCTS = [
+    MOCK_PRODUCT_PASTE_TRIO,
     MOCK_PRODUCT_BASIL_ALMOND,
     MOCK_PRODUCT_BEER,
     MOCK_PRODUCT_BEET,
@@ -676,6 +777,114 @@ export const MOCK_PRODUCTS = [
     MOCK_PRODUCT_HAIRCUT,
 ];
 export const MOCK_ORDERS = [MOCK_ORDER_1, MOCK_ORDER_2, MOCK_ORDER_3, MOCK_ORDER_4];
+/** Nothing hidden by default; `setMockDatabase({ catalogVisibility })` hides products at an outlet. */
+export const MOCK_CATALOG_VISIBILITY = [];
+/**
+ * The host's cart stock check for composites (kaching `compositeStockRefusal`), over the demo shelves — a copy: what the
+ * cart takes of each component's variant (plain lines and components × their line quantity) against its shelf here.
+ * The demo has no pools or units, so it counts per variant; untracked and backordered variants are never short.
+ */
+export function mockCompositeStockRefusal(products) {
+    const components = products.flatMap((product) => product.components ?? []);
+    const demand = new Map();
+    for (const product of products) {
+        if (product.components)
+            for (const component of product.components)
+                demand.set(component.variantId, (demand.get(component.variantId) ?? 0) + component.quantity * product.quantity);
+        else
+            demand.set(product.variantId, (demand.get(product.variantId) ?? 0) + product.quantity);
+    }
+    for (const component of components) {
+        const variant = MOCK_PRODUCTS.flatMap((product) => product.variants).find((candidate) => candidate._id === component.variantId);
+        if (!variant?.manageStock || variant.allowBackorder)
+            continue;
+        const left = variant.inventory?.find((row) => row.outletId === MOCK_OUTLET.id)?.stock ?? 0;
+        if ((demand.get(component.variantId) ?? 0) > left)
+            return `${component.name}: only ${left} left`;
+    }
+    return null;
+}
+/** Product ids hidden at the demo's active outlet. */
+export const mockHiddenProductIds = () => new Set(MOCK_CATALOG_VISIBILITY.filter((row) => row.outletId === MOCK_OUTLET.id).map((row) => row.productId));
+/**
+ * The host's outlet rules for a composite (kaching `resolveComposite`), over the demo's static view — a copy, change both
+ * in one step: an item whose product is hidden here is left out, a category item keeps only products sold here (none →
+ * `'empty'`), an Optional part with nothing to pick is not offered, a required one with nothing makes it unavailable,
+ * and the D36 default and "from" price are read off what is left.
+ */
+/** B41: the seats a bookable demo product has free in the slot starting at `startAt` — as the host reads them. */
+export function mockBookableWindow(productId, startAt) {
+    const at = new Date(startAt);
+    const slot = mockBookingAvailability(productId, at, new Date(+at + 86400000)).slots.find((candidate) => +new Date(candidate.startAt) === +at && candidate.canStart) ?? null;
+    return { free: slot?.free ?? 0, slot };
+}
+export const mockIsBookable = (productId) => MOCK_PRODUCTS.find((product) => product._id === productId)?.productType === CFProductType.BOOKING;
+export function mockCompositeAtOutlet(composite, hidden = mockHiddenProductIds(), 
+/** B41: the window bookable items are judged in; absent = `by_date`. */
+slot) {
+    // B41: a bookable item is judged by seats in the window, never by stock; with no window it waits for a date.
+    const bookable = (item) => !!item.variantId && item.choices.some((choice) => mockIsBookable(choice.productId));
+    const seatsFor = (item) => !slot
+        ? 'by_date'
+        : mockBookableWindow(item.choices[0].productId, slot.startAt).free >= item.quantity
+            ? null
+            : 'fully_booked';
+    const offered = (item) => !item.unavailable || item.unavailable === 'by_date';
+    // B35: a tracked variant without `quantity` on the demo shelf here (and no backorder) is sold out.
+    const soldOut = (variantId, quantity) => {
+        const variant = MOCK_PRODUCTS.flatMap((product) => product.variants).find((candidate) => candidate._id === variantId);
+        if (!variant?.manageStock || variant.allowBackorder)
+            return false;
+        return (variant.inventory?.find((row) => row.outletId === MOCK_OUTLET.id)?.stock ?? 0) < quantity;
+    };
+    // B36e: "N left" on a unit-sold tracked choice — the demo shelf already reads in the variant's own unit.
+    const withStockLeft = (choice) => {
+        const variant = MOCK_PRODUCTS.flatMap((product) => product.variants).find((candidate) => candidate._id === choice.variantId);
+        const onHand = variant?.inventory?.find((row) => row.outletId === MOCK_OUTLET.id)?.stock;
+        return variant?.unitId && variant.manageStock && typeof onHand === 'number'
+            ? { ...choice, stockLeft: onHand }
+            : choice;
+    };
+    const upcharge = (item) => ({
+        extraCharge: item.extraCharge,
+        quantity: item.quantity,
+        available: offered(item),
+    });
+    const parts = composite.parts
+        .map((part) => {
+        const items = part.items.flatMap((item) => {
+            if (item.variantId) {
+                if (item.choices.some((choice) => hidden.has(choice.productId)))
+                    return [];
+                if (!item.unavailable && bookable(item))
+                    return [{ ...item, unavailable: seatsFor(item) }];
+                return item.unavailable || !soldOut(item.variantId, item.quantity)
+                    ? [{ ...item, choices: item.choices.map(withStockLeft) }]
+                    : [{ ...item, unavailable: 'out_of_stock', choices: [] }];
+            }
+            const sold = item.choices.filter((choice) => !hidden.has(choice.productId));
+            const choices = sold.filter((choice) => !soldOut(choice.variantId, item.quantity));
+            const unavailable = item.unavailable ?? (!sold.length ? 'empty' : !choices.length ? 'out_of_stock' : null);
+            return [{ ...item, choices: unavailable ? [] : choices.map(withStockLeft), unavailable }];
+        });
+        const index = part.min === 1 && part.max === 1 ? cheapestCompositeItem(items.map(upcharge)) : undefined;
+        const cheapest = index === undefined ? undefined : items[index];
+        return {
+            ...part,
+            items,
+            defaultPick: cheapest?.variantId ? { itemId: cheapest._id, variantId: cheapest.variantId } : null,
+        };
+    })
+        .filter((part) => part.min > 0 || part.items.some(offered));
+    const cheapest = cheapestCompositePrice(parts.map((part) => ({ min: part.min, items: part.items.map(upcharge) })));
+    return {
+        ...composite,
+        available: composite.available && parts.every((part) => part.min === 0 || part.items.some(offered)),
+        needsDate: parts.some((part) => part.items.some(bookable)),
+        fromPrice: composite.basePrice === null || cheapest === undefined ? null : composite.basePrice + cheapest,
+        parts,
+    };
+}
 export const MOCK_PARKED_ORDERS = [MOCK_PARKED_ORDER_1, MOCK_PARKED_ORDER_2];
 // Compatibility Exports (reassigned by setMockDatabase)
 export let MOCK_USER = MOCK_USERS[0];
@@ -760,6 +969,9 @@ export function setMockDatabase(config) {
     if (config.bookings !== undefined) {
         MOCK_BOOKINGS.splice(0, MOCK_BOOKINGS.length, ...config.bookings);
     }
+    if (config.catalogVisibility !== undefined) {
+        MOCK_CATALOG_VISIBILITY.splice(0, MOCK_CATALOG_VISIBILITY.length, ...config.catalogVisibility);
+    }
     if (MOCK_OUTLETS.length > 0) {
         Object.assign(MOCK_OUTLET_MAIN, MOCK_OUTLETS[0]);
         if (MOCK_OUTLET_MAIN.id === undefined && MOCK_OUTLET_MAIN._id !== undefined) {
@@ -1132,6 +1344,7 @@ export const buildModifierRows = (modifiers, lineQuantity) => {
         amount: extendPrice(modifier.unitPrice * modifier.quantity, quantity),
         tax: 0,
         ...(modifier.taxTableId ? { taxTableId: modifier.taxTableId } : {}),
+        ...(modifier.componentIndex !== undefined ? { componentIndex: modifier.componentIndex } : {}),
     }));
     return { rows, modifiersTotal: rows.reduce((sum, row) => sum + row.amount, 0) };
 };

package/dist/index.d.ts

@@ -29,6 +29,8 @@ export declare const command: {
     readonly addProductNote: import(".").AddProductNote;
     readonly addProductFee: import(".").AddProductFee;
     readonly getProductModifierSelections: import(".").GetProductModifierSelections;
+    readonly getCompositePrice: import(".").GetCompositePrice;
+    readonly getCompositeAvailability: import(".").GetCompositeAvailability;
     readonly setProductModifierSelections: import(".").SetProductModifierSelections;
     readonly setActiveProductFee: import(".").SetActiveProductFee;
     readonly setActiveProductDiscount: import(".").SetActiveProductDiscount;
@@ -160,7 +162,7 @@ export type { CalculateRefundTotal, CalculateRefundTotalParams, CalculateRefundT
 export type { GetRemainingRefundableQuantities, GetRemainingRefundableQuantitiesParams, GetRemainingRefundableQuantitiesResponse, } from './actions/get-remaining-refundable-quantities/types';
 export type { ProcessPartialRefund, ProcessPartialRefundParams, ProcessPartialRefundResponse, } from './actions/process-partial-refund/types';
 export type { RedeemRefund, RedeemRefundParams, RedeemRefundResponse } from './actions/redeem-refund/types';
-export type { GetRefundPlan, GetRefundPlanParams, GetRefundPlanResponse, RefundPlanSource, RefundPlanAllocation, RefundPlanLeg, RefundPlanRowType, RefundPlanTaxLine, RefundPlanAmounts, RefundPlanRow, RefundPlanSelectedRow, RefundPlanTotals, RefundPlanBreakdown, } from './actions/get-refund-plan/types';
+export type { GetRefundPlan, GetRefundPlanParams, GetRefundPlanResponse, RefundPlanSource, RefundPlanAllocation, RefundPlanLeg, } from './actions/get-refund-plan/types';
 export type { CheckPermission, CheckPermissionParams, CheckPermissionResponse } from './actions/check-permission/types';
 export type { InitiateRefund, InitiateRefundParams, InitiateRefundResponse } from './actions/initiate-refund/types';
 export type { GetCurrentCart, GetCurrentCartResponse } from './actions/get-current-cart/types';
@@ -174,6 +176,8 @@ export type { GetFinalContext, GetFinalContextResponse } from './actions/get-fin
 export type { AddProductNote, AddProductNoteParams, AddProductNoteResponse } from './actions/add-product-note/types';
 export type { AddProductFee, AddProductFeeParams, AddProductFeeResponse } from './actions/add-product-fee/types';
 export type { GetProductModifierSelections, GetProductModifierSelectionsParams, GetProductModifierSelectionsResponse, ModifierSelection, ModifierChoiceSelection, } from './actions/get-product-modifier-selections/types';
+export type { GetCompositePrice, GetCompositePriceParams, GetCompositePriceResponse, } from './actions/get-composite-price/types';
+export type { GetCompositeAvailability, GetCompositeAvailabilityParams, GetCompositeAvailabilityResponse, CFCompositeSlot, } from './actions/get-composite-availability/types';
 export type { SetProductModifierSelections, SetProductModifierSelectionsParams, SetProductModifierSelectionsResponse, } from './actions/set-product-modifier-selections/types';
 export type { SetActiveProductFee, SetActiveProductFeeParams, SetActiveProductFeeResponse, } from './actions/set-active-product-fee/types';
 export type { SetActiveProductDiscount, SetActiveProductDiscountParams, SetActiveProductDiscountResponse, } from './actions/set-active-product-discount/types';