@final-commerce/command-frame 0.5.0 → 0.6.0-staging.1

package/README.md

@@ -10,11 +10,11 @@ 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)     |
-| **Refund commands** | Refund payments to gift cards or redeem tenders via `redeemRefund`, or mixed-destination legs on `processPartialRefund`; query engine capacity with `getRefundPlan`; pre-gate UI with `checkPermission` (`issue_refunds` is enforced runtime-side) | Request/response per call                 |
+| 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) |
+| **Refund commands** | Refund payments to gift cards or redeem tenders via `redeemRefund`, or mixed-destination legs on `processPartialRefund`; query engine capacity with `getRefundPlan`; pre-gate UI with `checkPermission` (`issue_refunds` is enforced runtime-side) | Request/response per call             |
 
 Domain models (orders, cart, customers, products, and related types) are documented in **[Types reference](./src/types/README.md)**.
 

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

@@ -3,7 +3,19 @@ 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/extension-payment/mock.d.ts

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

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

@@ -1,6 +1,6 @@
-import { MOCK_ORDERS } from "../../demo/database";
+import { MOCK_ORDERS } from '../../demo/database';
 export const mockExtensionPayment = async (params) => {
-    const paymentType = params?.paymentType ?? "redeem";
+    const paymentType = params?.paymentType ?? 'redeem';
     return {
         success: true,
         amount: params?.amount ?? null,
@@ -10,6 +10,6 @@ export const mockExtensionPayment = async (params) => {
         change: 0,
         cashRounding: 0,
         saleFinalized: true,
-        remainingBalance: 0
+        remainingBalance: 0,
     };
 };

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

@@ -1,4 +1,4 @@
-import { CFOrder } from "../../CommonTypes";
+import { CFOrder } from '../../CommonTypes';
 /** Params for extension-initiated payments; host routes by `paymentType`. */
 export interface ExtensionPaymentParams {
     paymentType: string;

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

@@ -1,4 +1,4 @@
-import type { GetAvailableTransitions } from "./types";
+import type { GetAvailableTransitions } from './types';
 /**
  * Mock implementation: returns a fixed set of plausible transitions
  * so the demo app has data to render. Mirrors an UNPAID order under the

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

@@ -7,32 +7,32 @@
 export const getAvailableTransitionsMock = () => Promise.resolve({
     transitions: [
         {
-            to: { payment: "unpaid", fulfillment: "in_progress" },
-            displayLabel: "Start Preparing",
-            conditions: [{ met: true, description: "Order has items" }]
+            to: { payment: 'unpaid', fulfillment: 'in_progress' },
+            displayLabel: 'Start Preparing',
+            conditions: [{ met: true, description: 'Order has items' }],
         },
         {
-            to: { payment: "unpaid", fulfillment: "fulfilled" },
-            displayLabel: "Mark Fulfilled",
-            conditions: [{ met: true, description: "Order has items" }]
+            to: { payment: 'unpaid', fulfillment: 'fulfilled' },
+            displayLabel: 'Mark Fulfilled',
+            conditions: [{ met: true, description: 'Order has items' }],
         },
         {
-            to: { payment: "unpaid", fulfillment: "on_hold" },
-            displayLabel: "Park Order",
-            conditions: [{ met: true, description: "Order is open" }]
+            to: { payment: 'unpaid', fulfillment: 'on_hold' },
+            displayLabel: 'Park Order',
+            conditions: [{ met: true, description: 'Order is open' }],
         },
         {
-            to: { payment: "paid", fulfillment: "fulfilled" },
-            displayLabel: "Complete Payment",
-            conditions: [{ met: true, description: "Balance due > 0" }]
+            to: { payment: 'paid', fulfillment: 'fulfilled' },
+            displayLabel: 'Complete Payment',
+            conditions: [{ met: true, description: 'Balance due > 0' }],
         },
         {
-            to: { payment: "voided", fulfillment: "cancelled" },
-            displayLabel: "Void Order",
+            to: { payment: 'voided', fulfillment: 'cancelled' },
+            displayLabel: 'Void Order',
             conditions: [
-                { met: true, description: "Order exists" },
-                { met: false, description: "No payments captured (mock: skipped)" }
-            ]
-        }
-    ]
+                { met: true, description: 'Order exists' },
+                { met: false, description: 'No payments captured (mock: skipped)' },
+            ],
+        },
+    ],
 });

package/dist/actions/get-final-context/mock.d.ts

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

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

@@ -1,6 +1,6 @@
 export const mockGetFinalContext = async () => {
-    console.log("[Mock] getFinalContext called");
+    console.log('[Mock] getFinalContext called');
     return {
-        projectName: "kaching"
+        projectName: 'kaching',
     };
 };

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

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