@final-commerce/command-frame 0.8.1-online.1 → 0.9.0-preprod.2

package/dist/CommonTypes.d.ts

@@ -1,5 +1,5 @@
 export * from './common-types';
-import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
+import type { Tax, Tip, Address, MetadataItem, OrderAssignedUser, OrderInCart, OrderCustomStatus, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
 export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from '@final-commerce/common';
 /** Open record used as a base for active entities. */
 export type CFActiveEntity = Record<string, unknown>;
@@ -7,6 +7,9 @@ export type CFDiscount = Discount;
 export type CFCustomFee = CustomFee;
 export type CFAddress = Address;
 export type CFMetadataItem = MetadataItem;
+export type CFOrderAssignedUser = OrderAssignedUser;
+export type CFOrderInCart = OrderInCart;
+export type CFOrderCustomStatus = OrderCustomStatus;
 export type CFTax = Tax;
 export type CFCartFeeTaxEntry = CartFeeTaxEntry;
 export type CFInventory = Inventory;
@@ -181,23 +184,9 @@ export interface CFOutletInfo {
         state?: string;
         postCode?: string;
     };
-    address2?: string;
     city?: string;
     state?: string;
     country?: string;
-    postCode?: string;
-    phone?: string;
-    /** Short display alias, when the merchant set one (e.g. `DTWN`). */
-    alias?: string;
-    /**
-     * Whether this location can take an ONLINE payment. Storefront only — it is
-     * absent on a register, where it has no meaning.
-     *
-     * `false` means the outlet has no completed payment connection, so starting a
-     * checkout against it WILL fail. A pickup picker must not offer it as a
-     * selectable location, or must show it as unavailable.
-     */
-    connected?: boolean;
 }
 export interface CFContextManage {
     user: unknown;

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

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

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

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

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

@@ -1 +1,2 @@
+// Adjust Inventory Types
 export {};

package/dist/actions/assign-order-user/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Assign order user action
+ * Calls the assignOrderUser action on the parent window
+ */
+import type { AssignOrderUser } from './types';
+export declare const assignOrderUser: AssignOrderUser;

package/dist/actions/assign-order-user/action.js

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

package/dist/actions/assign-order-user/mock.d.ts

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

package/dist/actions/assign-order-user/mock.js

@@ -0,0 +1,30 @@
+import { MOCK_ORDERS, MOCK_PARKED_ORDERS, MOCK_USERS, mockPublishEvent } from '../../demo/database';
+export const mockAssignOrderUser = async (params) => {
+    console.log('[Mock] assignOrderUser called', params);
+    if (!params?.orderId) {
+        throw new Error('assignOrderUser: the demo has no live-cart order — pass an orderId');
+    }
+    if (params.userId !== null && typeof params.userId !== 'string') {
+        throw new Error('assignOrderUser: userId must be a user id or null');
+    }
+    const order = [...MOCK_ORDERS, ...MOCK_PARKED_ORDERS].find((o) => o._id === params.orderId);
+    if (!order) {
+        throw new Error(`Order with ID ${params.orderId} not found`);
+    }
+    if (params.userId === null) {
+        order.assignedUser = null;
+    }
+    else if (order.assignedUser?.userId !== params.userId) {
+        if (!MOCK_USERS.some((u) => u.id === params.userId)) {
+            throw new Error(`User with ID ${params.userId} not found`);
+        }
+        order.assignedUser = { userId: params.userId, assignedAt: new Date().toISOString() };
+    }
+    mockPublishEvent('orders', 'order-updated', { order });
+    return {
+        success: true,
+        orderId: order._id,
+        assignedUser: order.assignedUser ?? null,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/assign-order-user/types.d.ts

@@ -0,0 +1,15 @@
+import type { CFOrderAssignedUser } from '../../CommonTypes';
+export interface AssignOrderUserParams {
+    /** Order to assign. Omit to target the live cart's order — it must already exist (parked, paid or transitioned). */
+    orderId?: string;
+    /** User to assign (e.g. the driver), or null to unassign. Replaces any current assignee. */
+    userId: string | null;
+}
+export interface AssignOrderUserResponse {
+    success: boolean;
+    orderId: string;
+    /** The order's assignee after the call; null when unassigned. */
+    assignedUser: CFOrderAssignedUser | null;
+    timestamp: string;
+}
+export type AssignOrderUser = (params: AssignOrderUserParams) => Promise<AssignOrderUserResponse>;

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/actions/get-order-statuses/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get order statuses action
+ * Calls the getOrderStatuses action on the parent window
+ */
+import type { GetOrderStatuses } from './types';
+export declare const getOrderStatuses: GetOrderStatuses;

package/dist/actions/get-order-statuses/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get order statuses action
+ * Calls the getOrderStatuses action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getOrderStatuses = async () => {
+    return await commandFrameClient.call('getOrderStatuses', undefined);
+};

package/dist/actions/get-order-statuses/mock.d.ts

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

package/dist/actions/get-order-statuses/mock.js

@@ -0,0 +1,5 @@
+import { MOCK_ORDER_STATUSES } from '../../demo/database';
+export const mockGetOrderStatuses = async () => {
+    console.log('[Mock] getOrderStatuses called');
+    return { success: true, statuses: MOCK_ORDER_STATUSES.map((s) => ({ ...s })), timestamp: new Date().toISOString() };
+};

package/dist/actions/get-order-statuses/types.d.ts

@@ -0,0 +1,8 @@
+import type { CFOrderStatusDefinition } from '../../common-types/order-state';
+export interface GetOrderStatusesResponse {
+    success: boolean;
+    /** The company's order statuses, in the order they were defined. Empty when none are defined. */
+    statuses: CFOrderStatusDefinition[];
+    timestamp: string;
+}
+export type GetOrderStatuses = () => Promise<GetOrderStatusesResponse>;

package/dist/actions/get-orders/action.d.ts

@@ -2,5 +2,5 @@
  * Get orders action
  * Calls the getOrders action on the parent window
  */
-import type { GetOrders } from "./types";
+import type { GetOrders } from './types';
 export declare const getOrders: GetOrders;

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

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

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

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

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

@@ -1,26 +1,60 @@
-import { MOCK_ORDERS, MOCK_PARKED_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);
+    console.log('[Mock] getOrders called', params);
     // 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;
+        const { customerId, status, sessionId, paymentState, fulfillmentState, outletId, assignedUserId, inCart, orderType, customStatusId, searchValue, limit, offset, sortBy, sortDirection, } = params;
         // 1. Filtering
         if (customerId) {
-            orders = orders.filter(o => o.customer &&
-                '_id' in o.customer &&
-                o.customer._id === customerId);
+            orders = orders.filter((o) => o.customer && '_id' in o.customer && o.customer._id === customerId);
         }
         if (status) {
-            orders = orders.filter(o => o.status === status);
+            orders = orders.filter((o) => o.status === status);
         }
         if (sessionId) {
-            orders = orders.filter(o => o.sessionId === sessionId);
+            orders = orders.filter((o) => o.sessionId === sessionId);
+        }
+        const anyOf = (criteria, value) => criteria === undefined ||
+            (Array.isArray(criteria) ? criteria.length === 0 || criteria.includes(value ?? '') : criteria === value);
+        if (paymentState !== undefined) {
+            orders = orders.filter((o) => anyOf(paymentState, o.paymentState));
+        }
+        if (fulfillmentState !== undefined) {
+            orders = orders.filter((o) => anyOf(fulfillmentState, o.fulfillmentState));
+        }
+        if (outletId) {
+            orders = orders.filter((o) => o.posData?.outlet === outletId);
+        }
+        if (assignedUserId) {
+            orders = orders.filter((o) => o.assignedUser?.userId === assignedUserId);
+        }
+        else if (assignedUserId === null) {
+            orders = orders.filter((o) => o.assignedUser == null);
+        }
+        if (orderType !== undefined) {
+            const types = Array.isArray(orderType) ? orderType : [orderType];
+            if (types.length)
+                orders = orders.filter((o) => types.includes(o.orderType ?? ''));
+        }
+        if (customStatusId !== undefined) {
+            const ids = Array.isArray(customStatusId) ? customStatusId : [customStatusId];
+            if (ids.length)
+                orders = orders.filter((o) => !!o.customStatus && ids.includes(o.customStatus.id));
+        }
+        if (typeof inCart === 'boolean') {
+            // Mirrors common's isInCart: the flag when present, else the legacy reading.
+            const orderInCart = (o) => o.inCart != null
+                ? o.inCart.active
+                : o.fulfillmentState
+                    ? o.fulfillmentState === 'draft'
+                    : o.status === 'in-cart';
+            orders = orders.filter((o) => orderInCart(o) === inCart);
         }
         if (searchValue) {
             const searchLower = String(searchValue).toLowerCase();
-            orders = orders.filter(o => {
+            orders = orders.filter((o) => {
                 const receiptMatch = o.receiptId?.toLowerCase().includes(searchLower);
                 const customerNameMatch = o.customer && 'firstName' in o.customer
                     ? `${o.customer.firstName} ${o.customer.lastName}`.toLowerCase().includes(searchLower)
@@ -42,14 +76,10 @@ export const mockGetOrders = async (params) => {
                 if (!valB && sortBy === 'createdAt')
                     valB = b.createdAt || '';
                 if (typeof valA === 'string' && typeof valB === 'string') {
-                    return sortDirection === 'descending'
-                        ? valB.localeCompare(valA)
-                        : valA.localeCompare(valB);
+                    return sortDirection === 'descending' ? valB.localeCompare(valA) : valA.localeCompare(valB);
                 }
                 // Number comparison
-                return sortDirection === 'descending'
-                    ? (valB || 0) - (valA || 0)
-                    : (valA || 0) - (valB || 0);
+                return sortDirection === 'descending' ? (valB || 0) - (valA || 0) : (valA || 0) - (valB || 0);
             });
         }
         else {
@@ -73,21 +103,21 @@ export const mockGetOrders = async (params) => {
         if (enrichedOrder.posData) {
             // Enrich Employee
             if (typeof enrichedOrder.posData.employee === 'string') {
-                const employee = MOCK_USERS.find(u => u.id === enrichedOrder.posData.employee);
+                const employee = MOCK_USERS.find((u) => u.id === enrichedOrder.posData.employee);
                 if (employee) {
                     enrichedOrder.posData.employee = employee;
                 }
             }
             // Enrich Station
             if (typeof enrichedOrder.posData.station === 'string') {
-                const station = MOCK_STATIONS.find(s => s._id === enrichedOrder.posData.station);
+                const station = MOCK_STATIONS.find((s) => s._id === enrichedOrder.posData.station);
                 if (station) {
                     enrichedOrder.posData.station = station;
                 }
             }
             // Enrich Outlet
             if (typeof enrichedOrder.posData.outlet === 'string') {
-                const outlet = MOCK_OUTLETS.find(o => o.id === enrichedOrder.posData.outlet);
+                const outlet = MOCK_OUTLETS.find((o) => o.id === enrichedOrder.posData.outlet);
                 if (outlet) {
                     enrichedOrder.posData.outlet = outlet;
                 }
@@ -99,6 +129,6 @@ export const mockGetOrders = async (params) => {
         success: true,
         orders: enrichedOrders,
         total: MOCK_ORDERS.length, // Total before pagination
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

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

@@ -1,9 +1,29 @@
-import { CFOrder } from "../../CommonTypes";
+import { CFOrder } from '../../CommonTypes';
 export interface GetOrdersParams {
     /** e.g. 'completed', 'parked', 'refunded'. */
     status?: string;
     customerId?: string;
     sessionId?: string;
+    /** Payment state(s), e.g. 'paid' or ['unpaid', 'partially_paid']. A list matches any of them. */
+    paymentState?: string | string[];
+    /** Fulfillment state(s), e.g. 'in_progress' or ['pending', 'in_progress']. A list matches any of them. */
+    fulfillmentState?: string | string[];
+    /** Only orders placed at this outlet (`posData.outlet`). Without it, orders from every outlet in the company are returned. */
+    outletId?: string;
+    /**
+     * Only orders assigned to this user (`assignedUser.userId`), e.g. a driver's deliveries.
+     * `null`: only orders nobody is assigned to yet (e.g. deliveries awaiting a driver).
+     */
+    assignedUserId?: string | null;
+    /**
+     * true: only orders loaded in a cart; false: only orders that aren't. Reads `order.inCart` when the order
+     * carries it, otherwise the legacy reading (fulfillment 'draft' / status 'in-cart').
+     */
+    inCart?: boolean;
+    /** Order type label(s) set with setOrderType, e.g. 'delivery' or ['pickup', 'takeout']. Exact match; a list matches any. */
+    orderType?: string | string[];
+    /** Custom status id(s) set with setOrderStatus, e.g. 'in-kitchen'. A list matches any of them. */
+    customStatusId?: string | string[];
     /** Default: 50. */
     limit?: number;
     /** Default: 0. */

package/dist/actions/get-outlets/action.js

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

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

@@ -1,14 +1,2 @@
 import { GetOutlets } from "./types";
-/**
- * A second location that CANNOT take an online payment.
- *
- * The shared demo data has exactly one outlet, so without this a pickup picker
- * built against mocks would never render the case that matters: an outlet a
- * shopper must not be allowed to check out against. `setOutlet` refuses this id,
- * so the two mocks tell the same story.
- *
- * Mock-only, and deliberately NOT added to `MOCK_OUTLETS` — that array is shared
- * with every other outlet mock and `MOCK_OUTLET`.
- */
-export declare const MOCK_UNCONNECTED_OUTLET_ID = "outlet-mock-unconnected";
 export declare const mockGetOutlets: GetOutlets;

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

@@ -1,40 +1,16 @@
 import { MOCK_OUTLETS, safeSerialize } from "../../demo/database";
-/**
- * A second location that CANNOT take an online payment.
- *
- * The shared demo data has exactly one outlet, so without this a pickup picker
- * built against mocks would never render the case that matters: an outlet a
- * shopper must not be allowed to check out against. `setOutlet` refuses this id,
- * so the two mocks tell the same story.
- *
- * Mock-only, and deliberately NOT added to `MOCK_OUTLETS` — that array is shared
- * with every other outlet mock and `MOCK_OUTLET`.
- */
-export const MOCK_UNCONNECTED_OUTLET_ID = "outlet-mock-unconnected";
-const UNCONNECTED_OUTLET = {
-    _id: MOCK_UNCONNECTED_OUTLET_ID,
-    name: "Airport (not connected)",
-    address: "2 Terminal Road",
-    city: "San Francisco",
-    state: "CA",
-    country: "US",
-    postCode: "94128",
-    connected: false
-};
-export const mockGetOutlets = async (params) => {
-    console.log("[Mock] getOutlets called", params);
+export const mockGetOutlets = async () => {
+    console.log("[Mock] getOutlets called");
     const outlets = safeSerialize(MOCK_OUTLETS).map((o) => ({
         _id: o._id || o.id,
         name: o.name || "",
         address: o.address,
         city: o.city,
         state: o.state,
-        country: o.country,
-        connected: true
+        country: o.country
     }));
-    const all = [...outlets, UNCONNECTED_OUTLET];
     return {
-        outlets: params?.connectedOnly ? all.filter((o) => o.connected) : all,
+        outlets,
         timestamp: new Date().toISOString()
     };
 };

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

@@ -1,24 +1,6 @@
 import { CFOutletInfo } from "../../CommonTypes";
-export interface GetOutletsParams {
-    /**
-     * Return only locations that can take an online payment. Storefront only.
-     * Default `false`, so a flow sees every outlet and decides how to present
-     * the ones it cannot sell from.
-     */
-    connectedOnly?: boolean;
-}
 export interface GetOutletsResponse {
     outlets: CFOutletInfo[];
     timestamp: string;
 }
-/**
- * List the company's outlets.
- *
- * ON A STOREFRONT this is the pickup picker's source. Each outlet carries
- * `connected`, and an outlet with `connected: false` cannot take a payment, so
- * `setOutlet` refuses it — filter those out rather than relying on the refusal.
- *
- * There are no coordinates on an outlet, so "closest branch" is not something
- * this can answer; sort on the address fields or let the shopper choose.
- */
-export type GetOutlets = (params?: GetOutletsParams) => Promise<GetOutletsResponse>;
+export type GetOutlets = () => Promise<GetOutletsResponse>;

package/dist/actions/record-external-payment/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Record external payment action
+ * Calls the recordExternalPayment action on the parent window
+ */
+import type { RecordExternalPayment } from './types';
+export declare const recordExternalPayment: RecordExternalPayment;

package/dist/actions/record-external-payment/action.js

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

package/dist/actions/record-external-payment/mock.d.ts

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

package/dist/actions/record-external-payment/mock.js

@@ -0,0 +1,36 @@
+import { isFulfillmentState } from '@final-commerce/common';
+import { applyMockPayment, MOCK_CART } from '../../demo/database';
+export const mockRecordExternalPayment = async (params) => {
+    console.log('[Mock] recordExternalPayment called', params);
+    const label = typeof params?.label === 'string' ? params.label.trim() : '';
+    if (!label) {
+        throw new Error('recordExternalPayment: label is required');
+    }
+    const balanceDue = MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
+    const amount = params.amount ?? balanceDue;
+    // Same rule as the host: positive, except on a zero-balance checkout.
+    if (!Number.isFinite(amount) || amount < 0 || (amount === 0 && balanceDue > 0)) {
+        throw new Error('recordExternalPayment: amount must be a positive integer (minor units)');
+    }
+    const target = params.checkoutFulfillmentTarget;
+    if (target !== undefined && !isFulfillmentState(target)) {
+        throw new Error(`recordExternalPayment: invalid checkoutFulfillmentTarget "${String(target)}"`);
+    }
+    if (amount > balanceDue) {
+        throw new Error(`recordExternalPayment: amount ${amount} exceeds the balance due ${balanceDue}`);
+    }
+    const order = applyMockPayment(amount, 'external', label);
+    const remainingBalance = MOCK_CART.remainingBalance ?? 0;
+    return {
+        success: true,
+        amount,
+        label,
+        paymentType: 'external',
+        change: 0,
+        cashRounding: 0,
+        order,
+        saleFinalized: !!order,
+        remainingBalance: order ? 0 : remainingBalance,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/record-external-payment/types.d.ts

@@ -0,0 +1,37 @@
+import { CFOrder } from '../../CommonTypes';
+export interface RecordExternalPaymentParams {
+    /**
+     * What the payment was — shown on the order and in reports, e.g. 'Paid online',
+     * 'Uber Eats', 'Voucher'. Required; trimmed. Not checked against a list, so keep
+     * labels consistent across flows.
+     */
+    label: string;
+    /**
+     * Amount to record, in integer MINOR currency units. Omit to record the full balance
+     * due (completing the order). Below the balance due it records a partial payment —
+     * the rest can be taken with any other tender. Above the balance due is an error.
+     */
+    amount?: number;
+    /** Fulfillment state to land on after full payment, e.g. 'pending' to keep the order going to the kitchen. */
+    checkoutFulfillmentTarget?: string;
+}
+export interface RecordExternalPaymentResponse {
+    success: boolean;
+    /** The amount recorded, in integer MINOR currency units. */
+    amount: number;
+    /** The label, as recorded. */
+    label: string;
+    paymentType: 'external';
+    /** Always 0 — no money changes hands at the terminal. */
+    change: number;
+    /** Always 0 — cash rounding applies to cash only. */
+    cashRounding: number;
+    /** The order once the sale completes; null for a partial (split) leg. */
+    order: CFOrder | null;
+    /** True when this payment settled the remaining balance. */
+    saleFinalized: boolean;
+    /** Balance still due after this payment, in integer MINOR currency units. */
+    remainingBalance: number;
+    timestamp: string;
+}
+export type RecordExternalPayment = (params: RecordExternalPaymentParams) => Promise<RecordExternalPaymentResponse>;

package/dist/actions/release-from-cart/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Release from cart action
+ * Calls the releaseFromCart action on the parent window
+ */
+import type { ReleaseFromCart } from './types';
+export declare const releaseFromCart: ReleaseFromCart;