@final-commerce/command-frame 0.3.0-beta.3 → 0.3.0-beta.6

package/README.md

@@ -10,11 +10,12 @@ Command Frame provides a structured way to build integrations that run inside Fi
 
 The library provides three main capabilities:
 
-| Capability | Purpose | Scope |
-|-----------|---------|-------|
-| **Commands** | Call host functions from the iframe (e.g. get products, open cash drawer) | Request/response per call |
-| **Pub/Sub** | Subscribe to real-time events from the host (e.g. cart changes, payments) | Page-scoped (while iframe is mounted) |
-| **Hooks** | Register business-logic callbacks that persist across all pages | Session-scoped (survives page navigation) |
+| Capability                | Purpose                                                                                         | Scope                                          |
+| ------------------------- | ----------------------------------------------------------------------------------------------- | ---------------------------------------------- |
+| **Commands**              | Call host functions from the iframe (e.g. get products, open cash drawer)                       | Request/response per call                      |
+| **Pub/Sub**               | Subscribe to real-time events from the host (e.g. cart changes, payments)                       | Page-scoped (while iframe is mounted)          |
+| **Hooks**                 | Register business-logic callbacks that persist across all pages                                 | Session-scoped (survives page navigation)      |
+| **Interceptors**          | Gate POS flows (approve / modify / block) at named points                                       | Blocking; host waits for your response         |
 | **Host → iframe refunds** | Render asks the extension to reverse redeem / gift-card payments before completing a POS refund | Parent `postMessage` + `requestId` (see below) |
 
 Domain models (orders, cart, customers, products, and related types) are documented in **[Types reference](./src/types/README.md)**.
@@ -54,7 +55,7 @@ For building applications that run inside the Render Point of Sale interface.
 - **Features:** Order management, Product catalog, Customer management, Payments, Hardware integration (Cash drawer, Printer), Custom tables, Secrets storage.
 
 ```typescript
-import { RenderClient } from '@final-commerce/command-frame';
+import { RenderClient } from "@final-commerce/command-frame";
 
 const client = new RenderClient();
 const products = await client.getProducts();
@@ -68,7 +69,7 @@ For building applications that run inside the Final Commerce Management Dashboar
 - **Features:** Context, catalog, entities, custom tables, secrets, and optional host-specific commands (navigation, media, tax, branding, notifications) when the dashboard implements them.
 
 ```typescript
-import { ManageClient } from '@final-commerce/command-frame';
+import { ManageClient } from "@final-commerce/command-frame";
 
 const client = new ManageClient();
 const context = await client.getContext();
@@ -82,14 +83,14 @@ The pub/sub system allows iframe extensions to subscribe to topics and receive r
 - **Topics:** Cart (16), Customers (8), Orders (4), Payments (2), Products (4), Refunds (4), Print (3), Custom Tables (3), Outlet (2), Station (2), Session (2), Users (2).
 
 ```typescript
-import { topics } from '@final-commerce/command-frame';
+import { topics } from "@final-commerce/command-frame";
 
-const subscriptionId = topics.subscribe('cart', (event) => {
-    console.log('Cart event:', event.type, event.data);
+const subscriptionId = topics.subscribe("cart", event => {
+    console.log("Cart event:", event.type, event.data);
 });
 
 // Unsubscribe when done
-topics.unsubscribe('cart', subscriptionId);
+topics.unsubscribe("cart", subscriptionId);
 ```
 
 ## Hooks
@@ -101,17 +102,44 @@ Hooks are **session-scoped** event callbacks that run in the host (Render) conte
 - A stable `hookId` is required for deduplication (safe on iframe reload).
 
 ```typescript
-import { hooks } from '@final-commerce/command-frame';
-
-hooks.register('cart', async (event, hostCommands) => {
-    await hostCommands.upsertCustomTableData({
-        tableName: 'cart-events-log',
-        data: { eventType: event.type, payload: event.data, timestamp: event.timestamp },
-    });
-}, { hookId: 'my-extension:cart-log' });
+import { hooks } from "@final-commerce/command-frame";
+
+hooks.register(
+    "cart",
+    async (event, hostCommands) => {
+        await hostCommands.upsertCustomTableData({
+            tableName: "cart-events-log",
+            data: { eventType: event.type, payload: event.data, timestamp: event.timestamp }
+        });
+    },
+    { hookId: "my-extension:cart-log" }
+);
 
 // Unregister when no longer needed
-hooks.unregister('my-extension:cart-log');
+hooks.unregister("my-extension:cart-log");
+```
+
+## Interceptors
+
+Interceptors let an extension **gate a POS flow** (approve / modify / block) at a named point — the host waits for your interceptor and acts on what it returns. Unlike hooks, interceptors are **blocking**.
+
+- **[Interceptors Documentation](./src/interceptors/README.md)**
+- The callback is serialized and reconstructed on the host; it must be **self-contained** (no closures, no imports).
+- A stable `interceptorId` is required for deduplication (safe on iframe reload).
+
+```typescript
+import { interceptors } from '@final-commerce/command-frame';
+
+interceptors.register(
+    'refund_start',
+    async (payload, cmds) => {
+        if (payload.paymentTypes.includes('redeem')) {
+            return cmds.openExtensionOverlay({ point: 'refund_start', payload });
+        }
+        return true; // nothing for us to do
+    },
+    { interceptorId: 'my-extension:refund-guard' }
+);
 ```
 
 ## Host-initiated extension refunds (redeem / gift card)
@@ -127,18 +155,12 @@ hooks.unregister('my-extension:cart-log');
 Exported APIs: `installExtensionRefundListener`, `EXTENSION_REFUND_REQUEST_ACTION`, types **`ExtensionRefundParams`** / **`ExtensionRefundResponse`**.
 
 ```typescript
-import {
-    installExtensionRefundListener,
-    type ExtensionRefundParams,
-    type ExtensionRefundResponse
-} from '@final-commerce/command-frame';
+import { installExtensionRefundListener, type ExtensionRefundParams, type ExtensionRefundResponse } from "@final-commerce/command-frame";
 
 const unsubscribe = installExtensionRefundListener(async (params: ExtensionRefundParams): Promise<ExtensionRefundResponse> => {
     // params.paymentType === "redeem", params.amount in major currency units, params.saleId, params.processor, etc.
     const ok = await myGiftCardProvider.refund(params);
-    return ok
-        ? { success: true, extensionTransactionId: ok.providerRefundId }
-        : { success: false, error: 'Refund declined' };
+    return ok ? { success: true, extensionTransactionId: ok.providerRefundId } : { success: false, error: "Refund declined" };
 });
 
 // on teardown (optional)

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, CustomerNote, Attribute, AttributeOption, Category, Transaction } 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, 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>;
@@ -28,6 +28,7 @@ export type CFCartFeeItem = CartFeeItem;
 export type CFTipPayment = TipPayment;
 export type CFRefundedTipPayment = RefundedTipPayment;
 export type CFPaymentMethod = PaymentMethod;
+export type CFSplitPayment = ActiveSplitPayment;
 export type CFPosDataItem = PosDataItem;
 export type CFDiscountDetail = DiscountDetail;
 export type CFFeeDetail = FeeDetail;

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

@@ -2,17 +2,20 @@ import { MOCK_CART, mockPublishEvent } from "../../demo/database";
 export const mockAddCartDiscount = async (params) => {
     console.log("[Mock] addCartDiscount called", params);
     if (params) {
+        // Mirror render: input is raw (50 = 50%, 5 = $5). Store percent as a
+        // fraction (0.5) and fixed as minor units (500), like the real handler.
+        const minorFactor = 10 ** (MOCK_CART.minorUnits ?? 2);
+        const value = params.isPercent ? params.amount / 100 : Math.round(params.amount * minorFactor);
         MOCK_CART.discount = {
-            value: params.amount,
+            value,
             isPercent: params.isPercent,
             label: params.label
         };
-        // Simple mock calc (not real logic)
         if (params.isPercent) {
             MOCK_CART.total = MOCK_CART.subtotal * (1 - params.amount / 100);
         }
         else {
-            MOCK_CART.total = MOCK_CART.subtotal - params.amount;
+            MOCK_CART.total = MOCK_CART.subtotal - value;
         }
         MOCK_CART.amountToBeCharged = MOCK_CART.total;
         MOCK_CART.remainingBalance = MOCK_CART.total;

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

@@ -4,18 +4,18 @@ export const mockAddCartFee = async (params) => {
     if (params) {
         if (!MOCK_CART.customFee)
             MOCK_CART.customFee = [];
+        // Mirror render: input is raw (50 = 50%, 5 = $5). Store percent as a
+        // fraction (0.5) and fixed as minor units (500), like the real handler.
+        const minorFactor = 10 ** (MOCK_CART.minorUnits ?? 2);
+        const storedAmount = params.isPercent ? params.amount / 100 : Math.round(params.amount * minorFactor);
         MOCK_CART.customFee.push({
             label: params.label || "Fee",
-            amount: params.amount,
+            amount: storedAmount,
             isPercent: params.isPercent || false,
             applyTaxes: params.applyTaxes || false,
             taxTableId: params.taxTableId
         });
-        // Simple calc
-        let feeAmount = params.amount;
-        if (params.isPercent) {
-            feeAmount = MOCK_CART.subtotal * (params.amount / 100);
-        }
+        const feeAmount = params.isPercent ? MOCK_CART.subtotal * (params.amount / 100) : storedAmount;
         MOCK_CART.total += feeAmount;
         MOCK_CART.amountToBeCharged = MOCK_CART.total;
         MOCK_CART.remainingBalance = MOCK_CART.total;

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

@@ -1,11 +1,14 @@
-import { MOCK_CART } from "../../demo/database";
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
 export const mockAddCustomSale = async (params) => {
     console.log("[Mock] addCustomSale called", params);
     if (!params)
         throw new Error("Params required");
     // Simple mock ID generation
     const mockId = 'sale_' + Math.random().toString(36).substr(2, 9);
-    const price = Number(params.price);
+    // Mirror render: the flow sends raw dollars ($4); render does toMinorUnits.
+    // MOCK_CART tracks minor units, so convert here too.
+    const minorFactor = 10 ** (MOCK_CART.minorUnits ?? 2);
+    const price = Math.round(Number(params.price) * minorFactor);
     const quantity = 1; // Default to 1 for custom sale usually
     const customSale = {
         id: mockId,
@@ -24,6 +27,8 @@ export const mockAddCustomSale = async (params) => {
     MOCK_CART.total += price * quantity;
     MOCK_CART.amountToBeCharged = MOCK_CART.total;
     MOCK_CART.remainingBalance = MOCK_CART.total;
+    // Publish custom-sale-added event so cart subscribers refresh
+    mockPublishEvent('cart', 'custom-sale-added', { customSale });
     return {
         success: true,
         customSaleId: mockId,

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

@@ -1,4 +1,4 @@
-import { MOCK_CART } from "../../demo/database";
+import { MOCK_CART, mockPublishEvent } from "../../demo/database";
 export const mockAddOrderNote = async (params) => {
     console.log("[Mock] addOrderNote called", params);
     // In Render, AddOrderNote usually adds a note to the active cart if it's not checked out yet.
@@ -9,6 +9,8 @@ export const mockAddOrderNote = async (params) => {
         else {
             MOCK_CART.orderNotes = params.note;
         }
+        // Publish order-note-added event so cart subscribers refresh.
+        mockPublishEvent("cart", "order-note-added", { note: params.note });
     }
     return {
         success: true,

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

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

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

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

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * Mock implementation: applies all transitions except a few known-invalid ones
+ * so the demo app can show both successful and blocked responses.
+ */
+export const applyTransitionMock = (params) => {
+    const { to } = params;
+    if (to.payment === "refunded" && to.fulfillment === "draft") {
+        return Promise.resolve({
+            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 Promise.resolve({
+            result: {
+                allowed: false,
+                blockedBy: "cross_axis_rule",
+                guard: "no-pay-cancelled",
+                reason: "Cannot mark a cancelled order as paid"
+            }
+        });
+    }
+    return Promise.resolve({
+        result: { allowed: true },
+        from: { payment: "unpaid", fulfillment: "draft" },
+        to,
+        displayState: `${to.payment} / ${to.fulfillment}`
+    });
+};

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

@@ -0,0 +1,17 @@
+import type { CFStatePair, CFTransitionResult } from "../../common-types/order-state";
+export interface ApplyTransitionParams {
+    /** Order to transition. */
+    orderId: string;
+    /** Target state pair. */
+    to: CFStatePair;
+}
+export interface ApplyTransitionResponse {
+    result: CFTransitionResult;
+    /** Previous state — present only when the transition was applied. */
+    from?: CFStatePair;
+    /** New state — present only when the transition was applied. */
+    to?: CFStatePair;
+    /** Computed display label — present only when the transition was applied. */
+    displayState?: string;
+}
+export type ApplyTransition = (params: ApplyTransitionParams) => Promise<ApplyTransitionResponse>;

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

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

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/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,9 +9,11 @@ export interface ExtensionPaymentParams {
     referenceId?: string;
     extensionId?: string;
     metadata?: Record<string, unknown>;
-    /** EMV tag string from an integration terminal; forwarded to the order PaymentMethod's `emv`. */
-    emvData?: string;
-    /** Processor fee for an integration payment; forwarded to the order PaymentMethod's `processorFee`. */
+    /** 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. */
     processorFee?: number;
 }
 export interface ExtensionPaymentResponse {
@@ -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-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/get-products/mock.js

@@ -24,8 +24,13 @@ export const mockGetProducts = async (params) => {
             products = products.filter(p => (p.categories || []).some(c => c.name.includes(containsVal)));
         }
     }
+    const total = products.length;
+    const offset = params?.offset ?? 0;
+    const limit = params?.limit ?? 100;
+    const paged = products.slice(offset, offset + limit);
     return {
-        products: safeSerialize(products),
+        products: safeSerialize(paged),
+        total,
         timestamp: new Date().toISOString()
     };
 };

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

@@ -29,6 +29,8 @@ export interface GetProductsParams {
 }
 export interface GetProductsResponse {
     products: CFProduct[];
+    /** Total number of products matching the query, ignoring offset/limit. Optional — hosts that cannot cheaply compute the total may omit it. */
+    total?: number;
     timestamp: string;
 }
 export type GetProducts = (params?: GetProductsParams) => Promise<GetProductsResponse>;

package/dist/actions/get-smart-grid-layout/mock.d.ts

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

package/dist/actions/get-smart-grid-layout/mock.js

@@ -1,7 +1,9 @@
+import { MOCK_SMART_GRID_LAYOUTS } from "../../demo/database";
 export const mockGetSmartGridLayout = (params) => {
+    console.log("[Mock] getSmartGridLayout called", params);
     return Promise.resolve({
         success: true,
-        layout: { gridId: params.gridId, cells: [] },
+        layout: MOCK_SMART_GRID_LAYOUTS[params.gridId] ?? null,
         timestamp: new Date().toISOString()
     });
 };