@final-commerce/command-frame 0.1.73 → 0.1.75

package/dist/actions/can-transition/action.js

@@ -0,0 +1,4 @@
+import { commandFrameClient } from "../../client";
+export const canTransition = async (params) => {
+    return await commandFrameClient.call("canTransition", params);
+};

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

@@ -0,0 +1,6 @@
+import type { CanTransitionParams, CanTransitionResponse } from "./types";
+/**
+ * Mock implementation: allows all transitions except a few known-invalid ones
+ * so the demo app can show both allowed and blocked responses.
+ */
+export declare const canTransitionMock: (params: CanTransitionParams) => Promise<CanTransitionResponse>;

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

@@ -0,0 +1,28 @@
+/**
+ * Mock implementation: allows all transitions except a few known-invalid ones
+ * so the demo app can show both allowed and blocked responses.
+ */
+export const canTransitionMock = async (params) => {
+    const to = params.to;
+    if (to.payment === "refunded" && to.fulfillment === "draft") {
+        return {
+            result: {
+                allowed: false,
+                blockedBy: "financial_invariant",
+                guard: "no-refund-in-draft",
+                reason: "Cannot refund an order that is still in draft",
+            },
+        };
+    }
+    if (to.payment === "paid" && to.fulfillment === "cancelled") {
+        return {
+            result: {
+                allowed: false,
+                blockedBy: "cross_axis_rule",
+                guard: "no-pay-cancelled",
+                reason: "Cannot mark a cancelled order as paid",
+            },
+        };
+    }
+    return { result: { allowed: true } };
+};

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

@@ -0,0 +1,11 @@
+import type { CFStatePair, CFTransitionResult } from "../../common-types/order-state";
+export interface CanTransitionParams {
+    /** Order to evaluate. If omitted, evaluates against a new order (from = null). */
+    orderId?: string;
+    /** Target state pair to transition to. */
+    to: CFStatePair;
+}
+export interface CanTransitionResponse {
+    result: CFTransitionResult;
+}
+export type CanTransition = (params: CanTransitionParams) => Promise<CanTransitionResponse>;

package/dist/actions/can-transition/types.js

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

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

@@ -1,14 +1,14 @@
-import { createOrderFromCart, MOCK_CART, mockPublishEvent } from "../../demo/database";
+import { applyMockPayment, MOCK_CART } from "../../demo/database";
 export const mockCashPayment = async (params) => {
     console.log("[Mock] cashPayment called", params);
-    // Default to true to match action behavior
+    // Default to true to match action behavior.
     const openChangeCalculator = params?.openChangeCalculator ?? true;
-    let amount = params?.amount || MOCK_CART.total;
+    // Amount due for THIS tender (the queued amount-to-be-charged), in minor units.
+    const due = params?.amount ?? MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
     if (openChangeCalculator) {
         try {
-            const input = window.prompt(`Total Due: $${MOCK_CART.total.toFixed(2)}\nEnter amount tendered:`, amount.toString());
+            const input = window.prompt(`Amount due: $${(due / 100).toFixed(2)}\nEnter amount tendered:`, (due / 100).toFixed(2));
             if (input === null) {
-                // User cancelled
                 return {
                     success: false,
                     amount: 0,
@@ -18,28 +18,22 @@ export const mockCashPayment = async (params) => {
                     timestamp: new Date().toISOString()
                 };
             }
-            const tendered = parseFloat(input);
+            const tendered = parseFloat(input); // dollars
             if (!isNaN(tendered)) {
-                amount = tendered;
-                const change = tendered - MOCK_CART.total;
-                if (change >= 0) {
-                    window.alert(`Change Due: $${change.toFixed(2)}`);
-                }
-                else {
-                    window.alert(`Warning: Tendered amount is less than total. Short by: $${Math.abs(change).toFixed(2)}`);
-                }
+                const change = tendered - due / 100;
+                window.alert(change >= 0
+                    ? `Change Due: $${change.toFixed(2)}`
+                    : `Warning: Tendered is short by: $${Math.abs(change).toFixed(2)}`);
             }
         }
         catch (e) {
             console.warn("Could not open prompt/alert (possibly in non-interactive environment)", e);
         }
     }
-    const order = createOrderFromCart("cash", amount, "cash");
-    // Publish payment-done event
-    mockPublishEvent('payments', 'payment-done', { order });
+    const order = applyMockPayment(due, "cash", "cash");
     return {
         success: true,
-        amount,
+        amount: due,
         openChangeCalculator,
         paymentType: "cash",
         order,

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

@@ -1,9 +1,12 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface CashPaymentParams {
     /** If not provided, uses the cart total. */
     amount?: number;
     /** Defaults to false. */
     openChangeCalculator?: boolean;
+    /** Override the fulfillment state after full payment. Render resolves the cascade. */
+    checkoutFulfillmentTarget?: string;
 }
 export interface CashPaymentResponse {
     success: boolean;
@@ -12,5 +15,7 @@ export interface CashPaymentResponse {
     paymentType: string;
     order: CFOrder | null;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type CashPayment = (params?: CashPaymentParams) => Promise<CashPaymentResponse>;

package/dist/actions/delete-parked-order/mock.js

@@ -1,10 +1,12 @@
-import { MOCK_PARKED_ORDERS } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, mockPublishEvent } from "../../demo/database";
 export const mockDeleteParkedOrder = async (params) => {
     console.log("[Mock] deleteParkedOrder called", params);
     if (params?.orderId) {
         const index = MOCK_PARKED_ORDERS.findIndex(o => o._id === params.orderId);
         if (index !== -1) {
             MOCK_PARKED_ORDERS.splice(index, 1);
+            // Refresh order lists (the parked-order modal reads getOrders).
+            mockPublishEvent("orders", "parked-order-deleted", { orderId: params.orderId });
         }
     }
     return {

package/dist/actions/delete-parked-order/types.d.ts

@@ -1,3 +1,4 @@
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface DeleteParkedOrderParams {
     orderId: string;
 }
@@ -5,5 +6,7 @@ export interface DeleteParkedOrderResponse {
     success: boolean;
     orderId: string;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type DeleteParkedOrder = (params?: DeleteParkedOrderParams) => Promise<DeleteParkedOrderResponse>;

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

@@ -1,4 +1,5 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 /** Params for extension-initiated payments; host routes by `paymentType`. */
 export interface ExtensionPaymentParams {
     paymentType: string;
@@ -8,6 +9,8 @@ export interface ExtensionPaymentParams {
     referenceId?: string;
     extensionId?: string;
     metadata?: Record<string, unknown>;
+    /** Override the fulfillment state after full payment. Render resolves the cascade. */
+    checkoutFulfillmentTarget?: string;
     /** EMV data when the underlying payment carries one (typed as `IntegrationEmvData` by the integration wrapper). */
     emvData?: unknown;
     /** Processor fee in minor units; recorded on the order's paymentMethod.processorFee. */
@@ -19,5 +22,7 @@ export interface ExtensionPaymentResponse {
     paymentType: string;
     order: CFOrder | null;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type ExtensionPayment = (params?: ExtensionPaymentParams) => Promise<ExtensionPaymentResponse>;

package/dist/actions/get-available-transitions/action.d.ts

@@ -0,0 +1,2 @@
+import type { GetAvailableTransitions } from "./types";
+export declare const getAvailableTransitions: GetAvailableTransitions;

package/dist/actions/get-available-transitions/action.js

@@ -0,0 +1,4 @@
+import { commandFrameClient } from "../../client";
+export const getAvailableTransitions = async (params) => {
+    return await commandFrameClient.call("getAvailableTransitions", params);
+};

package/dist/actions/get-available-transitions/mock.d.ts

@@ -0,0 +1,6 @@
+import type { GetAvailableTransitionsParams, GetAvailableTransitionsResponse } from "./types";
+/**
+ * Mock implementation: returns a fixed set of plausible transitions
+ * so the demo app has data to render.
+ */
+export declare const getAvailableTransitionsMock: (_params: GetAvailableTransitionsParams) => Promise<GetAvailableTransitionsResponse>;

package/dist/actions/get-available-transitions/mock.js

@@ -0,0 +1,26 @@
+/**
+ * Mock implementation: returns a fixed set of plausible transitions
+ * so the demo app has data to render.
+ */
+export const getAvailableTransitionsMock = async (_params) => ({
+    transitions: [
+        {
+            to: { payment: "refunded", fulfillment: "returned" },
+            displayLabel: "Full Refund",
+            conditions: [{ met: true, description: "Order is paid" }],
+        },
+        {
+            to: { payment: "partially_refunded", fulfillment: "partially_returned" },
+            displayLabel: "Partial Refund",
+            conditions: [{ met: true, description: "Order is paid" }],
+        },
+        {
+            to: { payment: "voided", fulfillment: "cancelled" },
+            displayLabel: "Void Order",
+            conditions: [
+                { met: true, description: "Order exists" },
+                { met: false, description: "No payments captured (mock: skipped)" },
+            ],
+        },
+    ],
+});

package/dist/actions/get-available-transitions/types.d.ts

@@ -0,0 +1,9 @@
+import type { CFAvailableTransition } from "../../common-types/order-state";
+export interface GetAvailableTransitionsParams {
+    /** Order to evaluate. Required — we need the current state. */
+    orderId: string;
+}
+export interface GetAvailableTransitionsResponse {
+    transitions: CFAvailableTransition[];
+}
+export type GetAvailableTransitions = (params: GetAvailableTransitionsParams) => Promise<GetAvailableTransitionsResponse>;

package/dist/actions/get-available-transitions/types.js

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

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

@@ -24,7 +24,7 @@ export const mockGetContext = () => {
         thousandSeparator: ",",
         decimalSeparator: ".",
         user: null,
-        company: null,
+        company: { _id: MOCK_COMPANY.id, name: MOCK_COMPANY.name, logo: MOCK_COMPANY.logo },
         station: null,
         outlet: null,
         timestamp: new Date().toISOString()

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

@@ -1,8 +1,8 @@
-import { MOCK_ORDERS, MOCK_USERS, MOCK_STATIONS, MOCK_OUTLETS, safeSerialize } from "../../demo/database";
+import { MOCK_ORDERS, MOCK_PARKED_ORDERS, MOCK_USERS, MOCK_STATIONS, MOCK_OUTLETS, safeSerialize } from "../../demo/database";
 export const mockGetOrders = async (params) => {
     console.log("[Mock] getOrders called", params);
-    // Start with a safe copy of mock orders
-    let orders = safeSerialize(MOCK_ORDERS);
+    // Start with a safe copy of mock orders, including parked (status: "parked").
+    let orders = safeSerialize([...MOCK_ORDERS, ...MOCK_PARKED_ORDERS]);
     // Filter simulation
     if (params) {
         const { customerId, status, sessionId, searchValue, limit, offset, sortBy, sortDirection } = params;

package/dist/actions/initiate-refund/types.d.ts

@@ -1,3 +1,4 @@
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface InitiateRefundParams {
     /** The ID of the order to refund. If not provided, uses the currently active order. */
     orderId?: string;
@@ -6,5 +7,7 @@ export interface InitiateRefundResponse {
     success: boolean;
     orderId: string;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type InitiateRefund = (params?: InitiateRefundParams) => Promise<InitiateRefundResponse>;

package/dist/actions/open-extension-overlay/mock.d.ts

@@ -0,0 +1,2 @@
+import type { OpenExtensionOverlay } from "./types";
+export declare const mockOpenExtensionOverlay: OpenExtensionOverlay;

package/dist/actions/open-extension-overlay/mock.js

@@ -0,0 +1 @@
+export const mockOpenExtensionOverlay = async (_params) => true;

package/dist/actions/open-extension-overlay/types.d.ts

@@ -0,0 +1,9 @@
+import type { InterceptorPoint, InterceptorReturn } from "../../interceptors/types";
+export interface OpenExtensionOverlayParams {
+    point: InterceptorPoint;
+    payload?: any;
+    /** Owning extension id. Injected by the host for interceptor-originated calls; optional for direct calls. */
+    extensionId?: string;
+}
+export type OpenExtensionOverlayResponse = InterceptorReturn;
+export type OpenExtensionOverlay = (params: OpenExtensionOverlayParams) => Promise<OpenExtensionOverlayResponse>;

package/dist/actions/open-extension-overlay/types.js

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

package/dist/actions/park-order/mock.js

@@ -1,4 +1,4 @@
-import { MOCK_PARKED_ORDERS, createOrderFromCart, MOCK_ORDERS } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, createOrderFromCart, MOCK_ORDERS, mockPublishEvent } from "../../demo/database";
 export const mockParkOrder = async () => {
     console.log("[Mock] parkOrder called");
     // Create a temporary order to capture cart state
@@ -13,6 +13,9 @@ export const mockParkOrder = async () => {
         MOCK_ORDERS.splice(foundIndex, 1);
     }
     MOCK_PARKED_ORDERS.push(tempOrder);
+    // Refresh order lists so the new parked order appears (createOrderFromCart
+    // already published the cart-created event that clears the cart).
+    mockPublishEvent("orders", "order-parked", { order: tempOrder });
     return {
         success: true,
         order: tempOrder,

package/dist/actions/park-order/types.d.ts

@@ -1,7 +1,10 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface ParkOrderResponse {
     success: boolean;
     order: CFOrder;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type ParkOrder = () => Promise<ParkOrderResponse>;

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

@@ -1,17 +1,35 @@
-import { MOCK_ORDERS } from "../../demo/database";
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
 export const mockPartialPayment = async (params) => {
     console.log("[Mock] partialPayment called", params);
     const openUI = params?.openUI ?? true;
     if (openUI) {
-        // Simulate UI opening
+        // Split-payment UI is host-owned; nothing to simulate here.
         window.alert("Demo: Split Payment UI would open here.");
+        return {
+            success: true,
+            amount: params?.amount,
+            isPercent: params?.isPercent || false,
+            openUI,
+            order: null,
+            timestamp: new Date().toISOString()
+        };
     }
+    // Queue a partial amount as the next tender. The remaining balance is left
+    // untouched until the payment is actually taken (see applyMockPayment).
+    const remaining = MOCK_CART.remainingBalance ?? MOCK_CART.total;
+    const raw = params?.amount ?? 0;
+    // Mirror render: fixed amount is raw dollars (render does toMinorUnits), so
+    // convert to minor units here; percent is a percentage of the remaining total.
+    const minorFactor = 10 ** (MOCK_CART.minorUnits ?? 2);
+    const charge = params?.isPercent ? Math.round((remaining * raw) / 100) : Math.round(raw * minorFactor);
+    MOCK_CART.amountToBeCharged = Math.min(Math.max(0, charge), remaining);
+    mockPublishEvent("cart", "partial-payment-set", { amountToBeCharged: MOCK_CART.amountToBeCharged });
     return {
         success: true,
         amount: params?.amount,
         isPercent: params?.isPercent || false,
         openUI,
-        order: openUI ? null : MOCK_ORDERS[0],
+        order: null,
         timestamp: new Date().toISOString()
     };
 };

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

@@ -1,4 +1,5 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface PartialPaymentParams {
     /** The payment amount (required if openUI is false). */
     amount?: number;
@@ -6,6 +7,8 @@ export interface PartialPaymentParams {
     isPercent?: boolean;
     /** If true, opens the split payment UI. */
     openUI?: boolean;
+    /** Override the fulfillment state after full payment. Render resolves the cascade. */
+    checkoutFulfillmentTarget?: string;
 }
 export interface PartialPaymentResponse {
     success: boolean;
@@ -14,5 +17,7 @@ export interface PartialPaymentResponse {
     openUI: boolean;
     order: CFOrder | null;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type PartialPayment = (params?: PartialPaymentParams) => Promise<PartialPaymentResponse>;

package/dist/actions/process-partial-refund/types.d.ts

@@ -1,3 +1,4 @@
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface ProcessPartialRefundParams {
     /** Optional refund reason. */
     reason?: string;
@@ -15,5 +16,7 @@ export interface ProcessPartialRefundResponse {
     success: boolean;
     refundId: string;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type ProcessPartialRefund = (params?: ProcessPartialRefundParams) => Promise<ProcessPartialRefundResponse>;

package/dist/actions/remove-custom-sale/mock.d.ts

@@ -0,0 +1,2 @@
+import { RemoveCustomSale } from "./types";
+export declare const mockRemoveCustomSale: RemoveCustomSale;

package/dist/actions/remove-custom-sale/mock.js

@@ -0,0 +1,29 @@
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
+export const mockRemoveCustomSale = (params) => {
+    console.log("[Mock] removeCustomSale called", params);
+    if (!params?.id) {
+        throw new Error("id is required");
+    }
+    const { id } = params;
+    const sales = MOCK_CART.customSales ?? [];
+    const index = sales.findIndex(s => s.id === id);
+    if (index === -1) {
+        throw new Error(`Custom sale with id ${id} not found`);
+    }
+    const sale = sales[index];
+    // Remove from cart
+    sales.splice(index, 1);
+    // Recalculate totals
+    const lineTotal = sale.price * sale.quantity;
+    MOCK_CART.subtotal -= lineTotal;
+    MOCK_CART.total -= lineTotal;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    // Publish custom-sale-removed event so cart subscribers refresh
+    mockPublishEvent("cart", "custom-sale-removed", { customSale: sale, id });
+    return Promise.resolve({
+        success: true,
+        id,
+        timestamp: new Date().toISOString()
+    });
+};

package/dist/actions/remove-customer-from-cart/mock.js

@@ -1,8 +1,10 @@
-import { MOCK_CART } from "../../demo/database";
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
 export const mockRemoveCustomerFromCart = async () => {
     console.log("[Mock] removeCustomerFromCart called");
     // Actually remove the customer from the mock cart
     MOCK_CART.customer = null;
+    // Publish customer-removed event so cart subscribers refresh
+    mockPublishEvent('cart', 'customer-removed', {});
     return {
         success: true,
         timestamp: new Date().toISOString()

package/dist/actions/remove-order-note/mock.d.ts

@@ -0,0 +1,2 @@
+import { RemoveOrderNote } from "./types";
+export declare const mockRemoveOrderNote: RemoveOrderNote;

package/dist/actions/remove-order-note/mock.js

@@ -0,0 +1,12 @@
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
+export const mockRemoveOrderNote = () => {
+    console.log("[Mock] removeOrderNote called");
+    // Clear the active cart's note.
+    MOCK_CART.orderNotes = undefined;
+    // Publish order-note-removed event so cart subscribers refresh.
+    mockPublishEvent("cart", "order-note-removed", {});
+    return Promise.resolve({
+        success: true,
+        timestamp: new Date().toISOString()
+    });
+};

package/dist/actions/remove-product-discount/mock.d.ts

@@ -0,0 +1,2 @@
+import { RemoveProductDiscount } from "./types";
+export declare const mockRemoveProductDiscount: RemoveProductDiscount;

package/dist/actions/remove-product-discount/mock.js

@@ -0,0 +1,17 @@
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
+export const mockRemoveProductDiscount = (params) => {
+    console.log("[Mock] removeProductDiscount called", params);
+    const item = params?.internalId
+        ? MOCK_CART.products.find(p => p.internalId === params.internalId)
+        : MOCK_CART.products[MOCK_CART.products.length - 1];
+    if (item) {
+        delete item.discount;
+        // Publish so cart subscribers refresh.
+        mockPublishEvent("cart", "product-discount-removed", { internalId: params?.internalId });
+    }
+    return Promise.resolve({
+        success: true,
+        internalId: params?.internalId,
+        timestamp: new Date().toISOString()
+    });
+};

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

@@ -0,0 +1,2 @@
+import { RemoveProductFee } from "./types";
+export declare const mockRemoveProductFee: RemoveProductFee;

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

@@ -0,0 +1,17 @@
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
+export const mockRemoveProductFee = (params) => {
+    console.log("[Mock] removeProductFee called", params);
+    const item = params?.internalId
+        ? MOCK_CART.products.find(p => p.internalId === params.internalId)
+        : MOCK_CART.products[MOCK_CART.products.length - 1];
+    if (item) {
+        delete item.fee;
+        // Publish so cart subscribers refresh.
+        mockPublishEvent("cart", "product-fee-removed", { internalId: params?.internalId });
+    }
+    return Promise.resolve({
+        success: true,
+        internalId: params?.internalId,
+        timestamp: new Date().toISOString()
+    });
+};

package/dist/actions/remove-product-from-cart/mock.js

@@ -1,8 +1,8 @@
 import { MOCK_CART, mockPublishEvent } from "../../demo/database";
-export const mockRemoveProductFromCart = async (params) => {
+export const mockRemoveProductFromCart = (params) => {
     console.log("[Mock] removeProductFromCart called", params);
     if (!params?.internalId) {
-        throw new Error('internalId is required');
+        throw new Error("internalId is required");
     }
     const { internalId } = params;
     // Find the product in the cart
@@ -20,13 +20,13 @@ export const mockRemoveProductFromCart = async (params) => {
     MOCK_CART.amountToBeCharged = MOCK_CART.total;
     MOCK_CART.remainingBalance = MOCK_CART.total;
     // Publish product-deleted event
-    mockPublishEvent('cart', 'product-deleted', {
+    mockPublishEvent("cart", "product-deleted", {
         product: product,
         internalId: internalId
     });
-    return {
+    return Promise.resolve({
         success: true,
         internalId: internalId,
         timestamp: new Date().toISOString()
-    };
+    });
 };

package/dist/actions/resolve-extension-overlay/mock.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveExtensionOverlay } from "./types";
+export declare const mockResolveExtensionOverlay: ResolveExtensionOverlay;

package/dist/actions/resolve-extension-overlay/mock.js

@@ -0,0 +1 @@
+export const mockResolveExtensionOverlay = async (_params) => ({ success: true });

package/dist/actions/resolve-extension-overlay/types.d.ts

@@ -0,0 +1,9 @@
+import type { InterceptorReturn } from "../../interceptors/types";
+export interface ResolveExtensionOverlayParams {
+    overlayId: string;
+    result: InterceptorReturn;
+}
+export interface ResolveExtensionOverlayResponse {
+    success: boolean;
+}
+export type ResolveExtensionOverlay = (params: ResolveExtensionOverlayParams) => Promise<ResolveExtensionOverlayResponse>;

package/dist/actions/resolve-extension-overlay/types.js

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

package/dist/actions/resume-parked-order/mock.js

@@ -1,4 +1,4 @@
-import { MOCK_PARKED_ORDERS, MOCK_CART, resetMockCart } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, MOCK_CART, resetMockCart, mockPublishEvent } from "../../demo/database";
 export const mockResumeParkedOrder = async (params) => {
     console.log("[Mock] resumeParkedOrder called", params);
     const orderId = params?.orderId;
@@ -45,6 +45,9 @@ export const mockResumeParkedOrder = async (params) => {
     MOCK_CART.remainingBalance = MOCK_CART.total;
     // Remove from parked
     MOCK_PARKED_ORDERS.splice(index, 1);
+    // Refresh the restored cart and the order lists.
+    mockPublishEvent("cart", "parked-order-resumed", { orderId });
+    mockPublishEvent("orders", "parked-order-resumed", { orderId });
     return {
         success: true,
         order: orderToResume,

package/dist/actions/resume-parked-order/types.d.ts

@@ -1,4 +1,5 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface ResumeParkedOrderParams {
     orderId: string;
 }
@@ -6,5 +7,7 @@ export interface ResumeParkedOrderResponse {
     success: boolean;
     order: CFOrder;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type ResumeParkedOrder = (params?: ResumeParkedOrderParams) => Promise<ResumeParkedOrderResponse>;

package/dist/actions/tap-to-pay-payment/mock.js

@@ -1,13 +1,15 @@
-import { MOCK_ORDERS } from "../../demo/database";
+import { applyMockPayment, MOCK_CART } from "../../demo/database";
 export const mockTapToPayPayment = async (params) => {
     console.log("[Mock] tapToPayPayment called", params);
     // Simulate Tap to Pay interaction
     window.alert("Demo: Processing Tap to Pay...\n(Please tap card or device on screen)");
+    const due = params?.amount ?? MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
+    const order = applyMockPayment(due, "card", "tapToPay");
     return {
         success: true,
-        amount: params?.amount || null,
+        amount: due,
         paymentType: "tapToPay",
-        order: MOCK_ORDERS[0],
+        order,
         timestamp: new Date().toISOString()
     };
 };