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

package/dist/CommonTypes.d.ts

@@ -1,5 +1,5 @@
 export * from './common-types';
-import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation, Composite, CompositePart, CompositeItem, CompositeChoice, CompositeItemUnavailable, CompositePick, CartLineComponent, OrderLineItemComponent } from '@final-commerce/common/pos-types';
+import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
 export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from '@final-commerce/common';
 /** Open record used as a base for active entities. */
 export type CFActiveEntity = Record<string, unknown>;
@@ -18,30 +18,6 @@ export type CFTransaction = Transaction;
 export type CFCategory = Category;
 export type CFProductVariant = ProductVariant;
 export type CFProduct = FullProduct;
-/** Composite products (FT-83): `CFProduct.composite`, the picks `addProductToCart` takes, the cart/order line's
- *  components. The host decides availability, prices and tax; a flow renders them and sends picks. */
-/**
- * B41: `needsDate: true` — the composite holds a bookable item and CANNOT be sold without a time. Show "By date" and a
- * date and time picker filled from `getCompositeAvailability`, then pass the chosen `compositeSlot` to `addProductToCart`.
- * Until a time is chosen its bookable items read `unavailable: 'by_date'` — still pickable, never greyed out.
- * INTERIM here until `common/pos-types` Composite carries it (ob_agent).
- */
-export type CFComposite = Composite & {
-    needsDate: boolean;
-};
-export type CFCompositePart = CompositePart;
-export type CFCompositeItem = CompositeItem;
-export type CFCompositeChoice = CompositeChoice;
-export type CFCompositeItemUnavailable = CompositeItemUnavailable;
-/**
- * B41: `resourceId` — on a bookable pick only: the resource that must serve it. Omitted = the host takes the first one
- * free in that window. INTERIM here until `common/pos-types` CompositePick carries it (ob_agent).
- */
-export type CFCompositePick = CompositePick & {
-    resourceId?: string;
-};
-export type CFCartLineComponent = CartLineComponent;
-export type CFOrderLineItemComponent = OrderLineItemComponent;
 export type CFBookingAvailability = BookingAvailability;
 export type CFBookingSlot = BookingSlot;
 export type CFBookingSlotResource = BookingSlotResource;

package/dist/actions/add-product-fee/mock.d.ts

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

package/dist/actions/add-product-fee/mock.js

@@ -1,36 +1,30 @@
-import { MOCK_CART } from '../../demo/database';
+import { MOCK_CART } from "../../demo/database";
 export const mockAddProductFee = async (params) => {
-    console.log('[Mock] addProductFee called', params);
+    console.log("[Mock] addProductFee called", params);
     if (params) {
         let item = null;
         if (params.internalId) {
-            item = MOCK_CART.products.find((p) => p.internalId === params.internalId);
+            item = MOCK_CART.products.find(p => p.internalId === params.internalId);
         }
         else if (MOCK_CART.products.length > 0) {
             item = MOCK_CART.products[MOCK_CART.products.length - 1];
         }
-        // Like the host (FT-83): a composite taxed by its items has no table a taxable fee could inherit.
-        if (item && params.applyTaxes && !item.taxTableId && item.components?.length) {
-            throw new Error(`${item.name} is taxed by its items: a taxable fee on it has no table to inherit`);
-        }
         if (item) {
-            item.fees = [
-                {
-                    label: params.label || 'Fee',
+            item.fees = [{
+                    label: params.label || "Fee",
                     amount: params.amount,
                     isPercent: params.isPercent || false,
-                    applyTaxes: params.applyTaxes || false,
-                },
-            ];
+                    applyTaxes: params.applyTaxes || false
+                }];
         }
     }
     return {
         success: true,
         amount: params?.amount || 0,
         isPercent: params?.isPercent || false,
-        label: params?.label || '',
+        label: params?.label || "",
         applyTaxes: params?.applyTaxes || false,
         internalId: params?.internalId,
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 };

package/dist/actions/add-product-to-cart/mock.d.ts

@@ -1,25 +1,2 @@
 import { AddProductToCart } from './types';
-import { CFCartLineComponent, CFCartLineModifier, CFComposite, CFCompositePick } from '../../CommonTypes';
 export declare const mockAddProductToCart: AddProductToCart;
-/** The host's pick checks (kaching `validateCompositePicks`), same order and texts; null = valid. */
-export declare function compositePicksRefusal(composite: CFComposite, picks: CFCompositePick[]): string | null;
-/** The host's `picksStillNeeded` (kaching `resolveComposite.ts`): per part, what is left of its min; an Optional part
- *  left empty is not listed. A copy — change both in one step. */
-export declare function mockPicksStillNeeded(composite: CFComposite, picks: CFCompositePick[]): {
-    partId: string;
-    needed: number;
-}[];
-type MockCompositeLine = {
-    price: number;
-    components: CFCartLineComponent[];
-    modifiers: CFCartLineModifier[];
-};
-/** kaching `buildCompositeLine` (B31): a component's share of ONE composite = the composite price split by the picked
- *  variant's price × units (all 0 → units) + its own upcharge; Σ = price. Item modifiers flat with `componentIndex`
- *  and quantity × the component's units. A copy — change both in one step. */
-export declare function mockCompositeLine(composite: CFComposite, picks: CFCompositePick[], ownTax: boolean): MockCompositeLine | string;
-/** The host's B41 refusal (kaching `loadCompositeLine`), word for word: a composite with a booking needs a slot. */
-export declare function mockNeedsDateRefusal(name: string, composite: CFComposite, slot?: {
-    startAt: string;
-}): string | null;
-export {};

package/dist/actions/add-product-to-cart/mock.js

@@ -1,6 +1,4 @@
-import { MOCK_CART, MOCK_OUTLET, mockCompositeAtOutlet, mockCompositeStockRefusal, mockHiddenProductIds, MOCK_PRODUCTS, buildCartLineModifiers, buildModifierRows, mockPublishEvent, mockBookableWindow, mockIsBookable, } from '../../demo/database';
-import { mockHoldBooking } from '../hold-booking/mock';
-import { mockCancelBooking } from '../cancel-booking/mock';
+import { MOCK_CART, MOCK_PRODUCTS, buildCartLineModifiers, buildModifierRows, mockPublishEvent, } from '../../demo/database';
 import { extendPrice, isValidQuantity, resolveUnit } from '@final-commerce/common';
 export const mockAddProductToCart = async (params) => {
     console.log('[Mock] addProductToCart called', params);
@@ -23,47 +21,6 @@ export const mockAddProductToCart = async (params) => {
             }
         }
     }
-    // Composites: the host's refusals with its texts, then the same line it builds (kaching `buildCompositeLine`).
-    let compositeLine;
-    if (product.composite || params?.composite?.length) {
-        const ownTax = !product.taxTable;
-        const picks = params?.composite ?? [];
-        // What this outlet sells (the host's catalog-visibility rules).
-        const composite = product.composite && mockCompositeAtOutlet(product.composite, undefined, params?.compositeSlot);
-        const reason = !composite
-            ? `${product.name} is not a composite: it takes no composite picks`
-            : mockHiddenProductIds().has(product._id)
-                ? `${product.name} is not sold at this outlet`
-                : params?.modifiers?.length
-                    ? `${product.name} takes no modifiers of its own: send them on its picks (composite[].modifiers)`
-                    : ownTax && params?.fees?.some((fee) => fee.applyTaxes)
-                        ? `${product.name} is taxed by its items: a taxable fee on it has no table to inherit`
-                        : (mockNeedsDateRefusal(product.name, composite, params?.compositeSlot) ??
-                            compositePicksRefusal(composite, picks) ??
-                            undefined);
-        const built = reason ?? mockCompositeLine(composite, picks, ownTax);
-        const line = typeof built !== 'string'
-            ? (mockCompositeStockRefusal([
-                ...MOCK_CART.products,
-                { variantId: variant._id, quantity, components: built.components },
-            ]) ?? built)
-            : built;
-        if (typeof line === 'string') {
-            return {
-                success: false,
-                reason: line,
-                productId: product._id,
-                variantId: variant._id,
-                internalId: '',
-                name: product.name,
-                quantity: 0,
-                rows: [],
-                modifiersTotal: 0,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        compositeLine = line;
-    }
     // A measured variant carries a resolved unit; the host does the same. What the unit can
     // express is its precision — 1.5 of a kilogram is a sale, 1.5 of a piece is a typo.
     const unit = variant.unitId ? resolveUnit(variant.unitId) : undefined;
@@ -101,8 +58,6 @@ export const mockAddProductToCart = async (params) => {
     // shapes, one name. Drop it before anything reads the line, or every surface renders the
     // whole catalogue as if the cashier had picked all of it.
     delete activeProduct.modifiers;
-    // Same for the catalogue's `composite` picker: a cart line carries `components`, never the menu.
-    delete activeProduct.composite;
     // Keep the raw answers AND the priced rows, the same pair the real host writes. The cart
     // TOTAL is deliberately left alone: like a product fee (see add-product-fee), per-line
     // money is not accumulated by this mock — `total` stays Σ extendPrice(price, quantity).
@@ -110,31 +65,6 @@ export const mockAddProductToCart = async (params) => {
         activeProduct.modifierSelections = params.modifiers;
         activeProduct.modifiers = buildCartLineModifiers(product.modifiers, params.modifiers, product.taxTable);
     }
-    if (compositeLine) {
-        activeProduct.price = compositeLine.price;
-        activeProduct.components = compositeLine.components;
-        if (compositeLine.modifiers.length) {
-            activeProduct.modifiers = [...(activeProduct.modifiers ?? []), ...compositeLine.modifiers];
-        }
-    }
-    // B41: every bookable component held in one step, or the add is refused and nothing is kept.
-    const booked = compositeLine && (await mockHoldCompositeBookings(compositeLine, quantity, internalId, params));
-    if (typeof booked === 'string') {
-        return {
-            success: false,
-            reason: booked,
-            productId: product._id,
-            variantId: variant._id,
-            internalId: '',
-            name: product.name,
-            quantity: 0,
-            rows: [],
-            modifiersTotal: 0,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    if (booked?.length)
-        MOCK_CART.reservations = [...(MOCK_CART.reservations ?? []), ...booked];
     MOCK_CART.products.push(activeProduct);
     // Recalculate totals. extendPrice, not a raw multiply: a fractional quantity times an
     // integer-minor price leaves fractional cents, which no order may carry.
@@ -161,232 +91,3 @@ export const mockAddProductToCart = async (params) => {
         timestamp: new Date().toISOString(),
     };
 };
-/** The host's pick checks (kaching `validateCompositePicks`), same order and texts; null = valid. */
-export function compositePicksRefusal(composite, picks) {
-    if (!composite.available) {
-        if (!composite.parts.length)
-            return 'This composite has no parts on this till yet';
-        const blocking = composite.parts.find((part) => part.min > 0 && !part.items.some((item) => !item.unavailable || item.unavailable === 'by_date'));
-        return blocking
-            ? `${blocking.name ?? 'Choose'}: nothing can be picked at this outlet`
-            : 'This composite is unavailable: a part it needs has nothing to pick';
-    }
-    const counts = new Map();
-    for (const pick of picks) {
-        const quantity = pick.quantity ?? 1;
-        const part = composite.parts.find((candidate) => candidate.items.some((item) => item._id === pick.itemId));
-        const item = part?.items.find((candidate) => candidate._id === pick.itemId);
-        if (!part || !item)
-            return `Composite item ${pick.itemId} is not offered here`;
-        if (!Number.isInteger(quantity) || quantity <= 0)
-            return `${item.name}: quantity must be a positive whole number`;
-        if (item.unavailable === 'by_date')
-            return `${item.name}: choose a date and time`;
-        if (item.unavailable === 'fully_booked')
-            return `${item.name} is fully booked at that time`;
-        if (item.unavailable)
-            return `${item.name} is not available`;
-        const choice = item.choices.find((candidate) => candidate.variantId === pick.variantId);
-        if (!choice)
-            return `${item.name}: that variant is not one of its choices`;
-        // The picked product's own modifiers, by its own rules (B28).
-        const modifiers = mockSelectionsRefusal(choice.modifiers ?? [], pick.modifiers ?? []);
-        if (modifiers)
-            return `${choice.name}: ${modifiers}`;
-        counts.set(part._id, (counts.get(part._id) ?? 0) + quantity);
-    }
-    for (const part of composite.parts) {
-        const count = counts.get(part._id) ?? 0;
-        if (count < part.min)
-            return `${part.name ?? 'Choose'}: pick ${part.min === part.max ? '' : 'at least '}${part.min}`;
-        if (count > part.max)
-            return `${part.name ?? 'Choose'}: pick at most ${part.max}`;
-    }
-    return null;
-}
-/** The host's modifier rules (kaching `validateModifiers.ts` `validateSelections`), same order and texts, at the demo
- *  outlet; null = valid. A copy — change both in one step. */
-function mockSelectionsRefusal(modifiers, selections) {
-    const outletId = MOCK_OUTLET.id;
-    const sellable = (choice) => !(choice.unavailableOutletIds ?? []).includes(outletId);
-    if (new Set(selections.map((selection) => selection.modifierId)).size !== selections.length) {
-        return 'Duplicate selection for the same modifier';
-    }
-    if (selections.some((selection) => !modifiers.some((modifier) => modifier._id === selection.modifierId))) {
-        return 'A selected modifier does not apply to this product';
-    }
-    for (const modifier of modifiers) {
-        if (modifier.required && !modifier.choices.some(sellable)) {
-            return `${modifier.name} is required, but nothing is sold at this outlet`;
-        }
-        const picked = selections.find((selection) => selection.modifierId === modifier._id)?.choices ?? [];
-        for (const { choiceId, quantity } of picked) {
-            const choice = modifier.choices.find((candidate) => candidate._id === choiceId);
-            if (!choice)
-                return `Unknown choice for ${modifier.name}`;
-            if (!sellable(choice))
-                return `${choice.name} is not sold at this outlet`;
-            if (!Number.isInteger(quantity) || quantity < 1)
-                return `${choice.name}: quantity must be a positive whole number`;
-            const takesQuantity = modifier.selectionType === 'quantity' || (modifier.selectionType === 'multiple' && modifier.allowQuantity);
-            if (!takesQuantity && quantity !== 1)
-                return `${modifier.name} does not take quantities`;
-        }
-        if (new Set(picked.map((choice) => choice.choiceId)).size !== picked.length)
-            return `${modifier.name}: duplicate choice`;
-        const units = picked.reduce((sum, choice) => sum + choice.quantity, 0);
-        if (modifier.selectionType === 'single') {
-            if (units > 1)
-                return `${modifier.name}: pick one`;
-            if (modifier.required && units < 1)
-                return `${modifier.name} is required`;
-            continue;
-        }
-        const min = modifier.required ? Math.max(1, modifier.min ?? 1) : 0;
-        if (units < min)
-            return `${modifier.name}: pick at least ${min}`;
-        if (modifier.max != null && units > modifier.max)
-            return `${modifier.name}: at most ${modifier.max}`;
-    }
-    return null;
-}
-/** The host's `picksStillNeeded` (kaching `resolveComposite.ts`): per part, what is left of its min; an Optional part
- *  left empty is not listed. A copy — change both in one step. */
-export function mockPicksStillNeeded(composite, picks) {
-    return composite.parts.flatMap((part) => {
-        const count = picks
-            .filter((pick) => part.items.some((item) => item._id === pick.itemId))
-            .reduce((sum, pick) => sum + (pick.quantity ?? 1), 0);
-        const needed = Math.max(0, part.min - count);
-        return needed > 0 ? [{ partId: part._id, needed }] : [];
-    });
-}
-/** kaching `buildCompositeLine` (B31): a component's share of ONE composite = the composite price split by the picked
- *  variant's price × units (all 0 → units) + its own upcharge; Σ = price. Item modifiers flat with `componentIndex`
- *  and quantity × the component's units. A copy — change both in one step. */
-export function mockCompositeLine(composite, picks, ownTax) {
-    const rows = picks.map((pick) => {
-        const part = composite.parts.find((candidate) => candidate.items.some((item) => item._id === pick.itemId));
-        const item = part.items.find((candidate) => candidate._id === pick.itemId);
-        const choice = item.choices.find((candidate) => candidate.variantId === pick.variantId);
-        const product = MOCK_PRODUCTS.find((candidate) => candidate._id === choice.productId);
-        const variant = product?.variants.find((candidate) => candidate._id === choice.variantId);
-        const selected = variant?.isOnSale ? variant.salePrice : variant?.price;
-        return {
-            part,
-            item,
-            choice,
-            productName: product?.name ?? choice.name,
-            taxTable: product?.taxTable || undefined,
-            price: typeof selected === 'number' && Number.isFinite(selected) ? Math.round(selected) : null,
-            pickQuantity: pick.quantity ?? 1,
-            units: (pick.quantity ?? 1) * item.quantity,
-        };
-    });
-    const unreadable = rows.find((row) => row.price === null);
-    if (unreadable)
-        return `${unreadable.productName}: its price cannot be read, so the composite cannot be split`;
-    const base = composite.basePrice ?? 0;
-    if (ownTax && rows.length === 0 && base > 0)
-        return 'Pick at least one item: this composite is taxed by its items';
-    const priced = rows.map((row) => row.price * row.units);
-    const weights = priced.some((weight) => weight > 0) ? priced : rows.map((row) => row.units);
-    const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
-    // Largest remainder, ties to the first — the host's allocateRateAcrossLines.
-    const floors = weights.map((weight) => (totalWeight ? Math.floor((base * weight) / totalWeight) : 0));
-    const ranked = weights
-        .map((weight, index) => ({ index, remainder: totalWeight ? (base * weight) % totalWeight : 0 }))
-        .sort((a, b) => b.remainder - a.remainder || a.index - b.index);
-    for (let k = 0; k < (totalWeight ? base - floors.reduce((a, b) => a + b, 0) : 0); k++)
-        floors[ranked[k].index] += 1;
-    const components = rows.map((row, index) => ({
-        ...(row.part.name ? { partName: row.part.name } : {}),
-        productId: row.choice.productId,
-        variantId: row.choice.variantId,
-        name: row.choice.name,
-        ...(row.choice.attributes.length ? { attributes: row.choice.attributes } : {}),
-        quantity: row.units,
-        unitPrice: row.item.cost * row.pickQuantity + floors[index],
-        ...(ownTax && row.taxTable ? { taxTableId: row.taxTable } : {}),
-    }));
-    const modifiers = rows.flatMap((row, index) => buildCartLineModifiers(row.choice.modifiers, picks[index].modifiers, row.taxTable).map((modifier) => ({
-        ...modifier,
-        quantity: modifier.quantity * row.units,
-        componentIndex: index,
-    })));
-    return { price: rows.reduce((sum, row) => sum + row.item.cost * row.pickQuantity, base), components, modifiers };
-}
-/**
- * The host's B41 step (kaching `holdCompositeBookings`): seats of one resource, else several, else refused; each hold a
- * price-0 reservation linked to the line. Returns the rows, or the refusal after releasing what it took.
- */
-async function mockHoldCompositeBookings(line, quantity, lineItemInternalId, params) {
-    const rows = [];
-    const refuse = async (reason) => {
-        for (const row of rows)
-            await mockCancelBooking({ bookingId: row.bookingId });
-        return reason;
-    };
-    for (const [componentIndex, component] of line.components.entries()) {
-        if (!mockIsBookable(component.productId))
-            continue;
-        if (!params?.compositeSlot)
-            return refuse(`${component.name}: choose a date and time`);
-        const seats = component.quantity * quantity;
-        const { slot } = mockBookableWindow(component.productId, params.compositeSlot.startAt);
-        const named = params.composite?.[componentIndex]?.resourceId;
-        const resources = (slot?.resources ?? []).filter((resource) => !named || resource.resourceId === named);
-        const whole = resources.find((resource) => resource.free >= seats);
-        const plan = whole
-            ? [{ resourceId: whole.resourceId, qty: seats }]
-            : named
-                ? []
-                : resources
-                    .filter((resource) => resource.free > 0)
-                    .map((resource) => ({ resourceId: resource.resourceId, qty: resource.free }));
-        let left = seats;
-        const taken = plan.flatMap((entry) => {
-            const qty = Math.min(entry.qty, left);
-            left -= qty;
-            return qty > 0 ? [{ ...entry, qty }] : [];
-        });
-        if (!slot || left > 0)
-            return refuse(`${component.name}: ${seats} seat(s) are not free at that time`);
-        for (const { resourceId, qty } of taken) {
-            const held = await mockHoldBooking({
-                productId: component.productId,
-                resourceId,
-                variantId: component.variantId,
-                startAt: slot.startAt,
-                endAt: slot.endAt,
-            });
-            if (!held.success || !held.booking)
-                return refuse(`${component.name}: ${held.reason}`);
-            rows.push({
-                internalId: `res_${held.booking.id}`,
-                bookingId: held.booking.id,
-                productId: component.productId,
-                variantId: component.variantId,
-                resourceId,
-                name: component.name,
-                resourceName: held.booking.resourceName,
-                price: 0,
-                quantity: qty,
-                total: 0,
-                startAt: held.booking.startAt,
-                endAt: held.booking.endAt,
-                bufferEndAt: held.booking.bufferEndAt,
-                expiresAt: held.booking.expiresAt,
-                lineItemInternalId,
-                componentIndex,
-            });
-        }
-    }
-    return rows;
-}
-/** The host's B41 refusal (kaching `loadCompositeLine`), word for word: a composite with a booking needs a slot. */
-export function mockNeedsDateRefusal(name, composite, slot) {
-    return composite.needsDate && !slot
-        ? `${name} includes a booking: show a date and time picker (getCompositeAvailability) and pass compositeSlot to addProductToCart`
-        : null;
-}

package/dist/actions/add-product-to-cart/types.d.ts

@@ -1,7 +1,7 @@
 import type { AddProductDiscountParams } from '../add-product-discount/types';
 import type { AddProductFeeParams } from '../add-product-fee/types';
 import type { ModifierSelection } from '../get-product-modifier-selections/types';
-import type { CFCompositePick, CFProdModifierBreakdown } from '../../CommonTypes';
+import type { CFProdModifierBreakdown } from '../../CommonTypes';
 export interface AddProductToCartParams {
     /** ID of the variant to add. */
     variantId: string;
@@ -25,32 +25,6 @@ export interface AddProductToCartParams {
     fees?: AddProductFeeParams[];
     /** Modifier selections to apply immediately. */
     modifiers?: ModifierSelection[];
-    /**
-     * Picks for a composite product (`CFProduct.composite`), validated by the host against each part's
-     * required / min / max, availability and each picked item's own modifier rules before the line exists; a
-     * rejected add returns `success: false` with a `reason`. Refused for a product that is not a composite.
-     *
-     * `composite[].modifiers` are the PICKED ITEM's modifiers (`choices[].modifiers`), taxed at that item's table
-     * (B28); send their quantity per one pick — the host multiplies it by the pick's units. The line comes back with
-     * `components[]` and those rows in its flat `modifiers[]` with `componentIndex`.
-     *
-     * A composite has no modifiers of its own (B43): `modifiers` sent with `composite` are refused — every modifier of a
-     * composite line is a picked item's and carries `componentIndex`. A taxable `fee` on a composite taxed by its items is
-     * refused too: there is no table for it to inherit.
-     */
-    composite?: CFCompositePick[];
-    /**
-     * B41: REQUIRED when `composite.needsDate` is true — the ONE date and time every bookable pick of this composite is
-     * booked for: show a date and time picker and send the `startAt` of a slot `getCompositeAvailability` offered. Without
-     * it the add is refused with a `reason`; if a seat went meanwhile, ask availability again — never retry the same slot.
-     * The host checks goods stock, then seats, then holds each bookable in one step: any failure releases what it
-     * took and the add is refused with a `reason`. Each hold lands in `cart.reservations[]` at price 0, linked to the line
-     * (`lineItemInternalId`, `componentIndex`); the component carries the money. Such a line's quantity cannot be
-     * changed, and it is refunded whole only.
-     */
-    compositeSlot?: {
-        startAt: string;
-    };
     /** Note or array of notes to add immediately. */
     notes?: string | string[];
 }

package/dist/actions/adjust-inventory/mock.js

@@ -1,6 +1,26 @@
 import { MOCK_PRODUCTS } from '../../demo/database';
+// Same rules and messages as the kaching handler.
+const STOCK_TYPE_BY_REASON = {
+    STOCK_RECEIVED: 'add',
+    RESTOCK_RETURN: 'add',
+    DAMAGE: 'subtract',
+    THEFT: 'subtract',
+    LOSS: 'subtract',
+    INVENTORY_RECOUNT: 'set',
+};
 export const mockAdjustInventory = async (params) => {
     console.log('[Mock] adjustInventory called', params);
+    if (params?.specificAction != null) {
+        const { specificAction, stockType, customActionId } = params;
+        if (customActionId)
+            throw new Error('Pass either customActionId or specificAction, not both');
+        const reasonStockType = STOCK_TYPE_BY_REASON[specificAction];
+        if (!reasonStockType)
+            throw new Error(`Unknown specificAction: ${specificAction}`);
+        if (reasonStockType !== stockType) {
+            throw new Error(`specificAction ${specificAction} requires stockType '${reasonStockType}', got '${stockType}'`);
+        }
+    }
     let newStock = 0;
     // Real handler keys off variantId (falling back to the active product's
     // variant); mirror that here by finding the owning product for the variant.

package/dist/actions/adjust-inventory/types.d.ts

@@ -1,3 +1,5 @@
+/** The manual reasons a person can pick, as hub-api's InventorySpecificActionType names them. */
+export type ManualStockReason = 'STOCK_RECEIVED' | 'RESTOCK_RETURN' | 'DAMAGE' | 'THEFT' | 'LOSS' | 'INVENTORY_RECOUNT';
 export interface AdjustInventoryParams {
     /** String to preserve precision. */
     amount: string;
@@ -5,6 +7,17 @@ export interface AdjustInventoryParams {
     stockType: 'add' | 'subtract' | 'set';
     /** Variant to adjust. Omit to use the active product's selected variant. */
     variantId?: string;
+    /**
+     * A company action from getCustomStockActions. The movement is recorded under its name;
+     * `stockType` must match its baseAction (ADD → 'add', REMOVE → 'subtract', RECOUNT → 'set').
+     */
+    customActionId?: string;
+    /**
+     * A built-in reason to record instead of the host's default for `stockType`. Must match it:
+     * STOCK_RECEIVED / RESTOCK_RETURN → 'add', DAMAGE / THEFT / LOSS → 'subtract', INVENTORY_RECOUNT → 'set'.
+     * Rejected together with `customActionId`.
+     */
+    specificAction?: ManualStockReason;
 }
 export interface AdjustInventoryResponse {
     success: boolean;

package/dist/actions/adjust-inventory/types.js

@@ -1 +1,2 @@
+// Adjust Inventory Types
 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,19 +1,9 @@
-import { MOCK_CART, buildModifierRows, safeSerialize } from '../../demo/database';
-import { extendPrice } from '@final-commerce/common';
+import { MOCK_CART, safeSerialize } from "../../demo/database";
 export const mockGetCurrentCart = async () => {
-    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)]),
-    ]);
+    console.log("[Mock] getCurrentCart called");
     return {
         success: true,
         cart: safeSerialize(MOCK_CART),
-        lineTotals,
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 };

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

@@ -1,13 +1,7 @@
-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-custom-stock-actions/action.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get custom stock actions action — the company's own stock adjustment actions.
+ */
+import type { GetCustomStockActions } from './types';
+export declare const getCustomStockActions: GetCustomStockActions;

package/dist/actions/get-custom-stock-actions/action.js

@@ -0,0 +1,7 @@
+/**
+ * Get custom stock actions action — the company's own stock adjustment actions.
+ */
+import { commandFrameClient } from '../../client';
+export const getCustomStockActions = async () => {
+    return await commandFrameClient.call('getCustomStockActions');
+};

package/dist/actions/get-custom-stock-actions/mock.d.ts

@@ -0,0 +1,2 @@
+import { GetCustomStockActions } from './types';
+export declare const mockGetCustomStockActions: GetCustomStockActions;

package/dist/actions/get-custom-stock-actions/mock.js

@@ -0,0 +1,11 @@
+export const mockGetCustomStockActions = async () => {
+    console.log('[Mock] getCustomStockActions called');
+    return {
+        customStockActions: [
+            { _id: 'mock_custom_action_1', name: 'Opening stock', baseAction: 'ADD' },
+            { _id: 'mock_custom_action_2', name: 'Exhibition loan', baseAction: 'REMOVE' },
+            { _id: 'mock_custom_action_3', name: 'Year-end count', baseAction: 'RECOUNT' },
+        ],
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/get-custom-stock-actions/types.d.ts

@@ -0,0 +1,12 @@
+export interface CustomStockActionPayload {
+    _id: string;
+    /** Name the company gave the action, shown in pickers and stock history. */
+    name: string;
+    /** What the action does to stock — pass the matching `stockType` to adjustInventory. */
+    baseAction: 'ADD' | 'REMOVE' | 'RECOUNT';
+}
+export interface GetCustomStockActionsResponse {
+    customStockActions: CustomStockActionPayload[];
+    timestamp: string;
+}
+export type GetCustomStockActions = () => Promise<GetCustomStockActionsResponse>;

package/dist/actions/get-custom-stock-actions/types.js

@@ -0,0 +1,2 @@
+// Get Custom Stock Actions Types
+export {};