@final-commerce/command-frame 0.5.1 → 0.6.0-preprod.2

package/dist/CommonTypes.d.ts

@@ -1,6 +1,6 @@
-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, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment } from "@final-commerce/common/pos-types";
-export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from "@final-commerce/common";
+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, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment } 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>;
 export type CFDiscount = Discount;
@@ -52,7 +52,7 @@ export type CFActiveCart = ActiveCart;
 export type CFActivePark = ActivePark;
 export type CFActiveCompany = ActiveCompany;
 /** Tile kinds a SmartGrid cell can represent. Mirrors common's `BaseTile['type']`. */
-export type CFTileType = "empty" | "product" | "action" | "category" | "folder" | "back";
+export type CFTileType = 'empty' | 'product' | 'action' | 'category' | 'folder' | 'back';
 /**
  * A single positioned cell in a SmartGrid layout. The wire/extension-facing shape
  * (Render's adapter maps this to/from common's `BaseTile`).
@@ -96,7 +96,7 @@ export interface CFActiveRefundDetails {
     refundProcessingStatus?: CFRefundProcessingStatus | null;
     sessionRefundedTotal?: number;
 }
-export type CFProjectName = "kaching" | "Manage";
+export type CFProjectName = 'kaching' | 'Manage';
 export interface CFContextRender {
     userId: string | null;
     companyId: string | null;
@@ -126,7 +126,7 @@ export interface CFContextRender {
     thousandSeparator: string | null;
     decimalSeparator: string | null;
     user: Record<string, unknown> | null;
-    company: Omit<Record<string, unknown>, "settings"> | null;
+    company: Omit<Record<string, unknown>, 'settings'> | null;
     station: Record<string, unknown> | null;
     outlet: Record<string, unknown> | null;
     timestamp: string;

package/dist/CommonTypes.js

@@ -1,6 +1,6 @@
-export * from "./common-types";
+export * from './common-types';
 // Enums — re-exported from common (single source). CurrencyCode keeps its name;
 // CFProductType/CFUserTypes alias common's ProductType/UserTypes. Note: common's
 // UserTypes uses `COMPANY_OWNER` where command-frame's enum previously had `OWNER`
 // (same value `'owner'`).
-export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from "@final-commerce/common";
+export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from '@final-commerce/common';

package/dist/actions/add-cart-discount/mock.d.ts

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

package/dist/actions/add-cart-discount/mock.js

@@ -1,18 +1,18 @@
-import { MOCK_CART, mockPublishEvent } from "../../demo/database";
-import { percentToFraction, requireMinorUnitsInteger } from "../../demo/units";
+import { MOCK_CART, mockPublishEvent } from '../../demo/database';
+import { percentToFraction, requireMinorUnitsInteger } from '../../demo/units';
 export const mockAddCartDiscount = async (params) => {
-    console.log("[Mock] addCartDiscount called", params);
+    console.log('[Mock] addCartDiscount called', params);
     if (params) {
         // FI-6991: a fixed amount arrives as an INTEGER in MINOR units (500 =
         // $5.00) and is stored directly; a percent arrives raw (50 = 50%) and is
         // stored as a fraction (0.5). Same as the real handler.
         const value = params.isPercent
             ? percentToFraction(params.amount)
-            : requireMinorUnitsInteger(params.amount, "Discount amount");
+            : requireMinorUnitsInteger(params.amount, 'Discount amount');
         MOCK_CART.discount = {
             value,
             isPercent: params.isPercent,
-            label: params.label
+            label: params.label,
         };
         if (params.isPercent) {
             MOCK_CART.total = MOCK_CART.subtotal * (1 - value);
@@ -24,14 +24,14 @@ export const mockAddCartDiscount = async (params) => {
         MOCK_CART.remainingBalance = MOCK_CART.total;
         // Publish cart-discount-added event
         mockPublishEvent('cart', 'cart-discount-added', {
-            discount: MOCK_CART.discount
+            discount: MOCK_CART.discount,
         });
     }
     return {
         success: true,
         amount: params?.amount || 0,
         isPercent: params?.isPercent || false,
-        label: params?.label || "",
-        timestamp: new Date().toISOString()
+        label: params?.label || '',
+        timestamp: new Date().toISOString(),
     };
 };

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

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

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

@@ -1,7 +1,7 @@
-import { MOCK_CART } from "../../demo/database";
-import { percentToFraction, requireMinorUnitsInteger } from "../../demo/units";
+import { MOCK_CART } from '../../demo/database';
+import { percentToFraction, requireMinorUnitsInteger } from '../../demo/units';
 export const mockAddCartFee = async (params) => {
-    console.log("[Mock] addCartFee called", params);
+    console.log('[Mock] addCartFee called', params);
     if (params) {
         if (!MOCK_CART.customFee)
             MOCK_CART.customFee = [];
@@ -10,13 +10,13 @@ export const mockAddCartFee = async (params) => {
         // stored as a fraction (0.5). Same as the real handler.
         const storedAmount = params.isPercent
             ? percentToFraction(params.amount)
-            : requireMinorUnitsInteger(params.amount, "Fee amount");
+            : requireMinorUnitsInteger(params.amount, 'Fee amount');
         MOCK_CART.customFee.push({
-            label: params.label || "Fee",
+            label: params.label || 'Fee',
             amount: storedAmount,
             isPercent: params.isPercent || false,
             applyTaxes: params.applyTaxes || false,
-            taxTableId: params.taxTableId
+            taxTableId: params.taxTableId,
         });
         const feeAmount = params.isPercent ? MOCK_CART.subtotal * storedAmount : storedAmount;
         MOCK_CART.total += feeAmount;
@@ -27,8 +27,8 @@ export const mockAddCartFee = async (params) => {
         success: true,
         amount: params?.amount || 0,
         isPercent: params?.isPercent || false,
-        label: params?.label || "",
+        label: params?.label || '',
         applyTaxes: params?.applyTaxes || false,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

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

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

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

@@ -1,15 +1,19 @@
-import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from "../../demo/database";
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
+import { extendPrice, isValidQuantity, resolveUnit } from '@final-commerce/common';
 export const mockAddProductToCart = async (params) => {
-    console.log("[Mock] addProductToCart called", params);
+    console.log('[Mock] addProductToCart called', params);
     const variantId = params?.variantId;
     const quantity = params?.quantity || 1;
+    if (!Number.isFinite(quantity) || quantity <= 0) {
+        throw new Error(`${quantity} is not a quantity`);
+    }
     let product = MOCK_PRODUCTS[0]; // Default fallback
     let variant = product.variants[0];
     // Determine variant and product from variantId
     if (variantId) {
         // Search through all products to find the one containing this variant
         for (const p of MOCK_PRODUCTS) {
-            const foundVariant = p.variants.find(v => v._id === variantId);
+            const foundVariant = p.variants.find((v) => v._id === variantId);
             if (foundVariant) {
                 product = p;
                 variant = foundVariant;
@@ -17,12 +21,20 @@ export const mockAddProductToCart = async (params) => {
             }
         }
     }
+    // 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;
+    if (!isValidQuantity(quantity, unit ?? { unitId: 'piece', ratioToBase: 1, precision: 0 })) {
+        throw new Error(unit
+            ? `${quantity} is finer than ${unit.abbreviation} can express (${unit.precision} decimals)`
+            : `${product.name} is sold by the piece, so ${quantity} is not a quantity it can sell in`);
+    }
     // Add to MOCK_CART
-    const internalId = product._id + "_" + Date.now();
+    const internalId = product._id + '_' + Date.now();
     // Process optional fields for mock
     let note = undefined;
     if (params?.notes) {
-        note = Array.isArray(params.notes) ? params.notes.join(", ") : params.notes;
+        note = Array.isArray(params.notes) ? params.notes.join(', ') : params.notes;
     }
     const activeProduct = {
         ...product,
@@ -33,16 +45,18 @@ export const mockAddProductToCart = async (params) => {
         price: Number(variant.price),
         taxTableId: product.taxTable,
         stock: variant.inventory?.[0]?.stock || 0,
+        ...(unit ? { unit } : {}),
         images: product.images || [],
         localQuantity: quantity,
         sku: variant.sku,
-        attributes: variant.attributes.map(a => `${a.name}: ${a.value}`).join(", "),
-        note: note
+        attributes: variant.attributes.map((a) => `${a.name}: ${a.value}`).join(', '),
+        note: note,
         // discount/fee could be added here to mock object if CFActiveProduct supports it
     };
     MOCK_CART.products.push(activeProduct);
-    // Recalculate totals
-    const lineTotal = activeProduct.price * quantity;
+    // Recalculate totals. extendPrice, not a raw multiply: a fractional quantity times an
+    // integer-minor price leaves fractional cents, which no order may carry.
+    const lineTotal = extendPrice(activeProduct.price, quantity);
     MOCK_CART.subtotal += lineTotal;
     // Simple total calculation (ignoring taxes/fees for mock simplicity unless needed)
     MOCK_CART.total += lineTotal;
@@ -57,6 +71,6 @@ export const mockAddProductToCart = async (params) => {
         internalId: activeProduct.internalId,
         name: activeProduct.name,
         quantity: quantity,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

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

@@ -1,9 +1,21 @@
-import type { AddProductDiscountParams } from "../add-product-discount/types";
-import type { AddProductFeeParams } from "../add-product-fee/types";
+import type { AddProductDiscountParams } from '../add-product-discount/types';
+import type { AddProductFeeParams } from '../add-product-fee/types';
 export interface AddProductToCartParams {
     /** ID of the variant to add. */
     variantId: string;
-    /** Defaults to 1. */
+    /**
+     * Defaults to 1. **May be fractional** — a variant sold by weight, volume or length is priced
+     * per its own unit and keyed in that unit, so `0.456` kg is a quantity, not a typo.
+     *
+     * How many decimals are allowed is the variant's own business: `variant.unit.precision` —
+     * `3` for a litre, `0` for anything sold by the piece. The engine refuses a quantity finer
+     * than that and says which unit it was measured against; do not round, floor or clamp before
+     * sending, and never key a quantity in base units to work around it (a per-100g price with a
+     * gram count is explicitly not supported).
+     *
+     * A quantity field should take its step and its decimal count from `variant.unit.precision`,
+     * not from a constant.
+     */
     quantity?: number;
     /** Array of discounts to apply immediately. */
     discounts?: AddProductDiscountParams[];

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

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

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

@@ -1,6 +1,6 @@
-import { MOCK_PRODUCTS } from "../../demo/database";
+import { MOCK_PRODUCTS } from '../../demo/database';
 export const mockAdjustInventory = async (params) => {
-    console.log("[Mock] adjustInventory called", params);
+    console.log('[Mock] adjustInventory called', params);
     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.
@@ -8,7 +8,7 @@ export const mockAdjustInventory = async (params) => {
         const variantId = params.variantId;
         let variant;
         for (const product of MOCK_PRODUCTS) {
-            const match = product.variants.find(v => v._id === variantId);
+            const match = product.variants.find((v) => v._id === variantId);
             if (match) {
                 variant = match;
                 break;
@@ -32,9 +32,9 @@ export const mockAdjustInventory = async (params) => {
     }
     return {
         success: true,
-        amount: params?.amount || "0",
-        stockType: params?.stockType || "set",
+        amount: params?.amount || '0',
+        stockType: params?.stockType || 'set',
         newStock,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/apply-transition/mock.d.ts

@@ -1,4 +1,4 @@
-import type { ApplyTransitionParams, ApplyTransitionResponse } from "./types";
+import type { ApplyTransitionParams, ApplyTransitionResponse } from './types';
 /**
  * Mock implementation: applies all transitions except a known-invalid one
  * so the demo app can show both successful and blocked responses.

package/dist/actions/apply-transition/mock.js

@@ -4,20 +4,20 @@
  */
 export const applyTransitionMock = (params) => {
     const { targetFulfillmentState } = params;
-    if (targetFulfillmentState === "cancelled") {
+    if (targetFulfillmentState === 'cancelled') {
         return Promise.resolve({
             result: {
                 allowed: false,
-                blockedBy: "condition",
-                guard: "no-cancel-open-order",
-                reason: "Cannot cancel an order with open items"
-            }
+                blockedBy: 'condition',
+                guard: 'no-cancel-open-order',
+                reason: 'Cannot cancel an order with open items',
+            },
         });
     }
     return Promise.resolve({
         result: { allowed: true },
-        from: { payment: "unpaid", fulfillment: "draft" },
-        to: { payment: "unpaid", fulfillment: targetFulfillmentState },
-        displayState: `unpaid / ${targetFulfillmentState}`
+        from: { payment: 'unpaid', fulfillment: 'draft' },
+        to: { payment: 'unpaid', fulfillment: targetFulfillmentState },
+        displayState: `unpaid / ${targetFulfillmentState}`,
     });
 };

package/dist/actions/apply-transition/types.d.ts

@@ -1,4 +1,4 @@
-import type { CFStatePair, CFTransitionResult } from "../../common-types/order-state";
+import type { CFStatePair, CFTransitionResult } from '../../common-types/order-state';
 export interface ApplyTransitionParams {
     /** Order to transition. Omit to target the active order — materializing one from the live cart if none exists. */
     orderId?: string;

package/dist/actions/authenticate-user/mock.d.ts

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

package/dist/actions/authenticate-user/mock.js

@@ -1,12 +1,12 @@
 export const mockAuthenticateUser = async (params) => {
-    console.log("[Mock] authenticateUser called", params);
+    console.log('[Mock] authenticateUser called', params);
     // Headless path requires both userId and pin together (mirrors the handler guard).
     if ((params?.userId || params?.pin) && !(params?.userId && params?.pin)) {
-        throw new Error("userId and pin must be provided together");
+        throw new Error('userId and pin must be provided together');
     }
     return {
         success: true,
         roleIds: params?.roleIds || [],
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/calculate-refund-total/action.d.ts

@@ -2,5 +2,5 @@
  * Calculate refund total action
  * Calls the calculateRefundTotal action on the parent window
  */
-import type { CalculateRefundTotal } from "./types";
+import type { CalculateRefundTotal } from './types';
 export declare const calculateRefundTotal: CalculateRefundTotal;

package/dist/actions/calculate-refund-total/action.js

@@ -2,7 +2,7 @@
  * Calculate refund total action
  * Calls the calculateRefundTotal action on the parent window
  */
-import { commandFrameClient } from "../../client";
+import { commandFrameClient } from '../../client';
 export const calculateRefundTotal = async (params) => {
-    return await commandFrameClient.call("calculateRefundTotal", params);
+    return await commandFrameClient.call('calculateRefundTotal', params);
 };

package/dist/actions/can-transition/types.d.ts

@@ -1,4 +1,4 @@
-import type { CFStatePair, CFTransitionResult } from "../../common-types/order-state";
+import type { CFStatePair, CFTransitionResult } from '../../common-types/order-state';
 export interface CanTransitionParams {
     /** Order to evaluate. Defaults to the active order; if there is no active order (or none matches), evaluates as a brand-new order (from = null). */
     orderId?: string;

package/dist/actions/cash-payment/mock.d.ts

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

package/dist/actions/cash-payment/mock.js

@@ -1,6 +1,6 @@
-import { applyMockPayment, MOCK_CART } from "../../demo/database";
+import { applyMockPayment, MOCK_CART } from '../../demo/database';
 export const mockCashPayment = async (params) => {
-    console.log("[Mock] cashPayment called", params);
+    console.log('[Mock] cashPayment called', params);
     const fail = (reason) => {
         console.warn(`[Mock] cashPayment rejected: ${reason}`);
         return {
@@ -9,17 +9,17 @@ export const mockCashPayment = async (params) => {
             openChangeCalculator: params?.openChangeCalculator ?? false,
             change: 0,
             cashRounding: 0,
-            paymentType: "cash",
+            paymentType: 'cash',
             order: null,
             timestamp: new Date().toISOString(),
             saleFinalized: false,
-            remainingBalance: 0
+            remainingBalance: 0,
         };
     };
     // Contract: `amount` is required, integer MINOR currency units — same
     // scale as the mock cart's totals, so comparisons are direct.
     if (params?.amount === undefined || params.amount === null) {
-        return fail("amount is required (integer minor currency units)");
+        return fail('amount is required (integer minor currency units)');
     }
     const balanceDue = MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
     if (params.amount > balanceDue) {
@@ -38,16 +38,16 @@ export const mockCashPayment = async (params) => {
         try {
             const input = window.prompt(`Amount due: $${(params.amount / 100).toFixed(2)}\nEnter amount tendered (dollars):`, (params.amount / 100).toFixed(2));
             if (input === null)
-                return fail("cancelled");
+                return fail('cancelled');
             const tendered = parseFloat(input);
             if (!isNaN(tendered))
                 change = Math.round(tendered * 100) - params.amount;
         }
         catch (e) {
-            console.warn("Could not open prompt/alert (possibly in non-interactive environment)", e);
+            console.warn('Could not open prompt/alert (possibly in non-interactive environment)', e);
         }
     }
-    const order = applyMockPayment(params.amount, "cash", "cash");
+    const order = applyMockPayment(params.amount, 'cash', 'cash');
     return {
         success: true,
         amount: params.amount,
@@ -55,10 +55,10 @@ export const mockCashPayment = async (params) => {
         change,
         tenderedAmount: params.tenderedAmount,
         cashRounding: 0,
-        paymentType: "cash",
+        paymentType: 'cash',
         order,
         timestamp: new Date().toISOString(),
         saleFinalized: true,
-        remainingBalance: 0
+        remainingBalance: 0,
     };
 };

package/dist/actions/cash-payment/types.d.ts

@@ -1,4 +1,4 @@
-import { CFOrder } from "../../CommonTypes";
+import { CFOrder } from '../../CommonTypes';
 export interface CashPaymentParams {
     /**
      * The amount to pay with this tender, in integer MINOR currency units

package/dist/actions/charge-moto/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Charge MOTO action
+ * Calls the chargeMoto action on the parent window
+ */
+import type { ChargeMoto } from './types';
+export declare const chargeMoto: ChargeMoto;

package/dist/actions/charge-moto/action.js

@@ -0,0 +1,8 @@
+/**
+ * Charge MOTO action
+ * Calls the chargeMoto action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const chargeMoto = async (params) => {
+    return await commandFrameClient.call('chargeMoto', params);
+};

package/dist/actions/charge-moto/mock.d.ts

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

package/dist/actions/charge-moto/mock.js

@@ -0,0 +1,47 @@
+import { applyMockPayment, MOCK_CART } from '../../demo/database';
+/** Mirrors kaching's `MOTO_MIN_AMOUNT_MINOR` — the processors' floor. */
+const MOTO_MIN_AMOUNT_MINOR = 50;
+/** The card fields that must be present and non-empty on every keyed charge. */
+const REQUIRED_CARD_FIELDS = [
+    'encryptedCardNumber',
+    'encryptedExpiryMonth',
+    'encryptedExpiryYear',
+    'encryptedSecurityCode',
+];
+export const mockChargeMoto = async (params) => {
+    console.log('[Mock] chargeMoto called', params);
+    if (!params)
+        throw new Error('Params required');
+    if (!Number.isInteger(params.amount)) {
+        throw new Error('amount must be an integer number of minor units');
+    }
+    if (params.amount < MOTO_MIN_AMOUNT_MINOR) {
+        throw new Error(`amount must be at least ${MOTO_MIN_AMOUNT_MINOR} minor units`);
+    }
+    for (const field of REQUIRED_CARD_FIELDS) {
+        const value = params.card?.[field];
+        if (!value || !value.trim()) {
+            throw new Error(`card.${field} is required`);
+        }
+    }
+    if (!params.idempotencyKey || !params.idempotencyKey.trim()) {
+        throw new Error('idempotencyKey is required so a retry replays instead of recharging');
+    }
+    const balanceDue = MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
+    if (params.amount > balanceDue) {
+        throw new Error(`amount ${params.amount} exceeds balance due ${balanceDue}`);
+    }
+    // The mock always completes the sale in one leg — it does not model
+    // kaching's real partial-leg (`saleFinalized: false`) path.
+    const order = applyMockPayment(balanceDue, 'card', 'adyen');
+    if (!order) {
+        throw new Error('MOCK_CHARGE_MOTO_PARTIAL_UNSUPPORTED: the mock only supports charging the full balance due');
+    }
+    return {
+        success: true,
+        timestamp: new Date().toISOString(),
+        order,
+        saleFinalized: true,
+        remainingBalance: 0,
+    };
+};

package/dist/actions/charge-moto/types.d.ts

@@ -0,0 +1,53 @@
+import { CFOrder } from '../../CommonTypes';
+/**
+ * Provider-encrypted card fields, opaque to this library — mirrors kaching's
+ * `MotoCardFields` field for field. Never a raw PAN: these are the CSE blobs
+ * the provider's own client-side encrypter produces.
+ */
+export interface ChargeMotoCardFields {
+    encryptedCardNumber: string;
+    encryptedExpiryMonth: string;
+    encryptedExpiryYear: string;
+    encryptedSecurityCode: string;
+    /** Optional AVS postal code the operator entered. */
+    postalCode?: string;
+    /** Provider-side `reference` for this payment. Defaults to the idempotency key server-side. */
+    reference?: string;
+}
+export interface ChargeMotoParams {
+    /**
+     * Total to charge, base + tip, in integer MINOR currency units. Minimum 50
+     * minor units (the processors' floor). This is the leg amount: a value
+     * below the cart's balance due records a partial payment.
+     */
+    amount: number;
+    /** Tip portion of `amount`, already collected by the caller's own UI. Defaults to 0. */
+    tipAmount?: number;
+    /**
+     * ISO 4217 code. Optional — the active company's currency is authoritative.
+     * When supplied it must match, or the charge is rejected before anything is sent.
+     */
+    currency?: string;
+    card: ChargeMotoCardFields;
+    /**
+     * Idempotency key for this charge, HELD BY THE CALLER across retries. A
+     * retried charge must carry the SAME key so the charge is replayed instead
+     * of doubled; use a NEW key after changing the amount.
+     */
+    idempotencyKey: string;
+    /** Optional tender label recorded on the payment method. */
+    paymentName?: string;
+    /** Fulfillment state to land on after full payment (default: auto-fulfill). */
+    targetFulfillmentState?: string;
+}
+export interface ChargeMotoResponse {
+    success: boolean;
+    timestamp: string;
+    /** The persisted order the charge landed on. */
+    order: CFOrder;
+    /** True only when this charge completed the sale (`paymentState === 'paid'`). */
+    saleFinalized: boolean;
+    /** Balance still due after this charge, in integer minor units. 0 when finalized. */
+    remainingBalance: number;
+}
+export type ChargeMoto = (params: ChargeMotoParams) => Promise<ChargeMotoResponse>;

package/dist/actions/charge-moto/types.js

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

package/dist/actions/create-payment-link/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create payment link action
+ * Calls the createPaymentLink action on the parent window
+ */
+import type { CreatePaymentLink } from './types';
+export declare const createPaymentLink: CreatePaymentLink;

package/dist/actions/create-payment-link/action.js

@@ -0,0 +1,8 @@
+/**
+ * Create payment link action
+ * Calls the createPaymentLink action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const createPaymentLink = async (params) => {
+    return await commandFrameClient.call('createPaymentLink', params);
+};

package/dist/actions/create-payment-link/mock.d.ts

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