@final-commerce/command-frame 0.6.1 → 0.7.0-staging.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, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment } 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, 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>;
@@ -18,6 +18,16 @@ export type CFTransaction = Transaction;
 export type CFCategory = Category;
 export type CFProductVariant = ProductVariant;
 export type CFProduct = FullProduct;
+export type CFBookingAvailability = BookingAvailability;
+export type CFBookingSlot = BookingSlot;
+export type CFBookingSlotResource = BookingSlotResource;
+export type CFBookingResource = BookingResource;
+export type CFBooking = Booking;
+/** A service sitting in the cart, and the same sale once it is on an order. A flow that draws a
+ *  cart or a receipt needs both by name — reaching into the package's dist for them is not an
+ *  interface. */
+export type CFCartReservation = CartReservation;
+export type CFOrderReservation = OrderReservation;
 export type CFActiveProduct = ActiveProduct;
 export type CFCustomer = ActiveCustomer;
 export type CFActiveCustomer = ActiveCustomer;

package/dist/actions/add-booking-to-cart/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Add booking to cart action
+ * Calls the addBookingToCart action on the parent window
+ */
+import type { AddBookingToCart } from './types';
+export declare const addBookingToCart: AddBookingToCart;

package/dist/actions/add-booking-to-cart/action.js

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

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

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

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

@@ -0,0 +1,8 @@
+import { mockHoldBooking } from '../hold-booking/mock';
+export const mockAddBookingToCart = async (params) => {
+    console.log('[Mock] addBookingToCart called', params);
+    // Same claim as holdBooking — including its refusal when the window is already taken. The mock
+    // cart is not modelled here; what a booking screen must handle is the refusal, not the line.
+    const { booking } = await mockHoldBooking(params);
+    return { booking, reservationInternalId: `res_${booking.id}`, timestamp: new Date().toISOString() };
+};

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

@@ -0,0 +1,23 @@
+import { CFBooking } from '../../CommonTypes';
+export interface AddBookingToCartParams {
+    /** The bookable product (`productType: 'booking'`). */
+    productId: string;
+    /** Which resource serves it: a member of staff, a room, a scooter. */
+    resourceId: string;
+    /** Must be the START of a slot getBookingAvailability offered, ISO 8601. */
+    startAt: string;
+    /** End of the window — the slot's own `endAt`, or the last slot's for a stay. */
+    endAt: string;
+    /** The variant being sold. Defaults to the product's only variant. */
+    variantId?: string;
+    /** Whom the booking is for. Omit for a walk-in. */
+    customerId?: string;
+}
+export interface AddBookingToCartResponse {
+    /** The claim the cart now stands on: `id` cancels or releases it, `expiresAt` is your clock. */
+    booking: CFBooking;
+    /** Identity of the reservation inside the cart and, later, the order. */
+    reservationInternalId: string;
+    timestamp: string;
+}
+export type AddBookingToCart = (params: AddBookingToCartParams) => Promise<AddBookingToCartResponse>;

package/dist/actions/cancel-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cancel booking action
+ * Calls the cancelBooking action on the parent window
+ */
+import type { CancelBooking } from './types';
+export declare const cancelBooking: CancelBooking;

package/dist/actions/cancel-booking/action.js

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

package/dist/actions/cancel-booking/mock.d.ts

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

package/dist/actions/cancel-booking/mock.js

@@ -0,0 +1,10 @@
+import { MOCK_BOOKINGS } from '../../demo/database';
+import { ReservationStatus } from '@final-commerce/common';
+export const mockCancelBooking = async (params) => {
+    console.log('[Mock] cancelBooking called', params);
+    const booking = MOCK_BOOKINGS.find(({ id }) => id === params.bookingId);
+    if (!booking)
+        throw new Error(`No booking ${params.bookingId}`);
+    booking.status = ReservationStatus.CANCELLED;
+    return { booking, timestamp: new Date().toISOString() };
+};

package/dist/actions/cancel-booking/types.d.ts

@@ -0,0 +1,10 @@
+import { CFBooking } from '../../CommonTypes';
+export interface CancelBookingParams {
+    /** `id` of the booking returned by holdBooking or getBookings. */
+    bookingId: string;
+}
+export interface CancelBookingResponse {
+    booking: CFBooking;
+    timestamp: string;
+}
+export type CancelBooking = (params: CancelBookingParams) => Promise<CancelBookingResponse>;

package/dist/actions/cancel-booking/types.js

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

package/dist/actions/get-booking-availability/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking availability action
+ * Calls the getBookingAvailability action on the parent window
+ */
+import type { GetBookingAvailability } from './types';
+export declare const getBookingAvailability: GetBookingAvailability;

package/dist/actions/get-booking-availability/action.js

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

package/dist/actions/get-booking-availability/mock.d.ts

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

package/dist/actions/get-booking-availability/mock.js

@@ -0,0 +1,6 @@
+import { mockBookingAvailability } from '../../demo/database';
+export const mockGetBookingAvailability = async (params) => {
+    console.log('[Mock] getBookingAvailability called', params);
+    const availability = mockBookingAvailability(params.productId, new Date(params.from), new Date(params.to), params.resourceId);
+    return { availability, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-availability/types.d.ts

@@ -0,0 +1,18 @@
+import { CFBookingAvailability } from '../../CommonTypes';
+export interface GetBookingAvailabilityParams {
+    /** The bookable product (`productType: 'booking'`) whose calendar you are drawing. */
+    productId: string;
+    /** Range start, ISO 8601. */
+    from: string;
+    /** Range end, ISO 8601. */
+    to: string;
+    /** Narrow the answer to one resource — "only Marco", "only room 4". */
+    resourceId?: string;
+    /** Narrow to the resources standing at one outlet. */
+    outletId?: string;
+}
+export interface GetBookingAvailabilityResponse {
+    availability: CFBookingAvailability;
+    timestamp: string;
+}
+export type GetBookingAvailability = (params: GetBookingAvailabilityParams) => Promise<GetBookingAvailabilityResponse>;

package/dist/actions/get-booking-availability/types.js

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

package/dist/actions/get-booking-resources/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking resources action
+ * Calls the getBookingResources action on the parent window
+ */
+import type { GetBookingResources } from './types';
+export declare const getBookingResources: GetBookingResources;

package/dist/actions/get-booking-resources/action.js

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

package/dist/actions/get-booking-resources/mock.d.ts

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

package/dist/actions/get-booking-resources/mock.js

@@ -0,0 +1,7 @@
+import { MOCK_BOOKING_RESOURCES } from '../../demo/database';
+export const mockGetBookingResources = async (params) => {
+    console.log('[Mock] getBookingResources called', params);
+    // A resource knows nothing about outlets — where it works lives in its own records, which the
+    // host reads. The mock has no such records, so `outletId` narrows nothing here.
+    return { resources: MOCK_BOOKING_RESOURCES, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-resources/types.d.ts

@@ -0,0 +1,12 @@
+import { CFBookingResource } from '../../CommonTypes';
+export interface GetBookingResourcesParams {
+    /** Only the resources that serve this bookable product. Omit for the whole company. */
+    productId?: string;
+    /** Only resources standing at this outlet (a resource with no outlet serves all of them). */
+    outletId?: string;
+}
+export interface GetBookingResourcesResponse {
+    resources: CFBookingResource[];
+    timestamp: string;
+}
+export type GetBookingResources = (params?: GetBookingResourcesParams) => Promise<GetBookingResourcesResponse>;

package/dist/actions/get-booking-resources/types.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { MOCK_BOOKINGS, mockLiveBookings } from '../../demo/database';
+export const mockGetBookings = async (params) => {
+    console.log('[Mock] getBookings called', params);
+    let bookings = params?.includeExpired ? MOCK_BOOKINGS : mockLiveBookings();
+    if (params?.resourceId)
+        bookings = bookings.filter((entry) => entry.resourceId === params.resourceId);
+    if (params?.productId)
+        bookings = bookings.filter((entry) => entry.productId === params.productId);
+    if (params?.customerId)
+        bookings = bookings.filter((entry) => entry.customerId === params.customerId);
+    if (params?.from) {
+        const from = new Date(params.from);
+        bookings = bookings.filter((entry) => new Date(entry.bufferEndAt) > from);
+    }
+    if (params?.to) {
+        const to = new Date(params.to);
+        bookings = bookings.filter((entry) => new Date(entry.startAt) < to);
+    }
+    return { bookings, timestamp: new Date().toISOString() };
+};

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

@@ -0,0 +1,18 @@
+import { CFBooking } from '../../CommonTypes';
+export interface GetBookingsParams {
+    /** Everything taking this resource's time — the one query a day view needs. */
+    resourceId?: string;
+    productId?: string;
+    /** This customer's appointments. */
+    customerId?: string;
+    /** Bookings whose window overlaps this range, ISO 8601. */
+    from?: string;
+    to?: string;
+    /** Defaults to live bookings only (confirmed, plus holds that have not expired). */
+    includeExpired?: boolean;
+}
+export interface GetBookingsResponse {
+    bookings: CFBooking[];
+    timestamp: string;
+}
+export type GetBookings = (params?: GetBookingsParams) => Promise<GetBookingsResponse>;

package/dist/actions/get-bookings/types.js

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

package/dist/actions/hold-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hold booking action
+ * Calls the holdBooking action on the parent window
+ */
+import type { HoldBooking } from './types';
+export declare const holdBooking: HoldBooking;

package/dist/actions/hold-booking/action.js

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

package/dist/actions/hold-booking/mock.d.ts

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

package/dist/actions/hold-booking/mock.js

@@ -0,0 +1,33 @@
+import { MOCK_BOOKINGS, MOCK_BOOKING_RESOURCES, mockLiveBookings } from '../../demo/database';
+import { ReservationStatus } from '@final-commerce/common';
+const BUFFER_MINUTES = 5;
+const HOLD_MINUTES = 10;
+export const mockHoldBooking = async (params) => {
+    console.log('[Mock] holdBooking called', params);
+    const startAt = new Date(params.startAt);
+    const endAt = new Date(params.endAt);
+    const bufferEndAt = new Date(endAt.getTime() + BUFFER_MINUTES * 60000);
+    // The mock refuses a taken window like the host does. A mock that always said yes would
+    // let a booking screen ship without ever handling the one error it will actually meet.
+    const clash = mockLiveBookings().some((entry) => entry.resourceId === params.resourceId &&
+        new Date(entry.startAt) < bufferEndAt &&
+        new Date(entry.bufferEndAt) > startAt);
+    if (clash)
+        throw new Error('That window has just been taken — pick another slot.');
+    const booking = {
+        id: `bk_mock_${Date.now()}`,
+        productId: params.productId,
+        resourceId: params.resourceId,
+        variantId: params.variantId,
+        startAt: startAt.toISOString(),
+        endAt: endAt.toISOString(),
+        bufferEndAt: bufferEndAt.toISOString(),
+        customerId: params.customerId,
+        status: ReservationStatus.HELD,
+        expiresAt: new Date(Date.now() + HOLD_MINUTES * 60000).toISOString(),
+        resourceName: MOCK_BOOKING_RESOURCES.find(({ id }) => id === params.resourceId)?.name,
+    };
+    // Held in the same list availability reads, so the slot really does disappear.
+    MOCK_BOOKINGS.push(booking);
+    return { booking, timestamp: new Date().toISOString() };
+};

package/dist/actions/hold-booking/types.d.ts

@@ -0,0 +1,24 @@
+import { CFBooking } from '../../CommonTypes';
+export interface HoldBookingParams {
+    productId: string;
+    /** Which resource serves it: a member of staff, a room, a scooter. */
+    resourceId: string;
+    /** Must be the START of a slot the host offered, ISO 8601. */
+    startAt: string;
+    /**
+     * End of the window — the `endAt` of the slot you picked, or of the last slot in a stay.
+     * Required: the server refuses a window it cannot line up with its own grid, and the till
+     * has no local copy of the rules to derive it from.
+     */
+    endAt: string;
+    /** The variant being sold, when the flow already knows which one. */
+    variantId?: string;
+    /** Whom the booking is for. Omit for a walk-in. */
+    customerId?: string;
+}
+export interface HoldBookingResponse {
+    /** The claim. `expiresAt` says how long it survives unpaid; `id` is what you confirm or cancel. */
+    booking: CFBooking;
+    timestamp: string;
+}
+export type HoldBooking = (params: HoldBookingParams) => Promise<HoldBookingResponse>;

package/dist/actions/hold-booking/types.js

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

package/dist/actions/remove-booking-from-cart/action.d.ts

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

package/dist/actions/remove-booking-from-cart/action.js

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

package/dist/actions/remove-booking-from-cart/mock.d.ts

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

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

@@ -0,0 +1,16 @@
+import { MOCK_BOOKINGS } from '../../demo/database';
+export const mockRemoveBookingFromCart = async (params) => {
+    console.log('[Mock] removeBookingFromCart called', params);
+    // The hold has to go back, or the mock is a trap: `addBookingToCart` pushes into the very list
+    // availability reads, so add → remove → add the same slot used to refuse forever with "that
+    // window has just been taken". The reservation id the mock hands out is `res_<booking.id>`,
+    // which is the only link back to the row.
+    const bookingId = params.reservationInternalId.replace(/^res_/, '');
+    const index = MOCK_BOOKINGS.findIndex(({ id }) => id === bookingId);
+    const [released] = index >= 0 ? MOCK_BOOKINGS.splice(index, 1) : [];
+    return {
+        reservationInternalId: params.reservationInternalId,
+        booking: released,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/remove-booking-from-cart/types.d.ts

@@ -0,0 +1,12 @@
+import { CFBooking } from '../../CommonTypes';
+export interface RemoveBookingFromCartParams {
+    /** The reservation's own id, as `addBookingToCart` returned it. */
+    reservationInternalId: string;
+}
+export interface RemoveBookingFromCartResponse {
+    reservationInternalId: string;
+    /** The released hold, so the caller can see it is no longer held. */
+    booking?: CFBooking;
+    timestamp: string;
+}
+export type RemoveBookingFromCart = (params: RemoveBookingFromCartParams) => Promise<RemoveBookingFromCartResponse>;

package/dist/actions/remove-booking-from-cart/types.js

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

package/dist/demo/database.d.ts

@@ -2,7 +2,7 @@
  * Mock Database for Standalone/Demo Mode
  * Stores mock data that mimics the Render environment
  */
-import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout } from '../CommonTypes';
+import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout, CFBooking, CFBookingAvailability, CFBookingResource } from '../CommonTypes';
 export * from './mocks';
 /** Replace mock catalog / context data in place (same array references mock handlers use). */
 export interface MockDatabaseConfig {
@@ -59,6 +59,7 @@ export declare const MOCK_STATIONS: import("@final-commerce/common/pos-types").A
 export declare const MOCK_OUTLETS: import("@final-commerce/common/pos-types").ActiveOutlet[];
 export declare const MOCK_CUSTOMERS: import("@final-commerce/common/pos-types").ActiveCustomer[];
 export declare const MOCK_CATEGORIES: import("@final-commerce/common/pos-types").Category[];
+export declare const MOCK_PRODUCT_HAIRCUT: CFProduct;
 export declare const MOCK_PRODUCTS: import("@final-commerce/common/pos-types").FullProduct[];
 export declare const MOCK_ORDERS: import("@final-commerce/common/pos-types").ActiveOrder[];
 export declare const MOCK_PARKED_ORDERS: CFActiveOrder[];
@@ -87,3 +88,9 @@ export declare const createOrderFromCart: (paymentType: string, amount: number,
  * open with `amountToBeCharged` reset to what's left, and returns null.
  */
 export declare const applyMockPayment: (amount: number, paymentType: string, processor?: string) => CFActiveOrder | null;
+export declare const MOCK_BOOKING_RULES_ID = "rule_salon_30";
+export declare const MOCK_BOOKING_RESOURCES: CFBookingResource[];
+export declare const MOCK_BOOKINGS: CFBooking[];
+/** Live = confirmed, or held and not yet expired. An expired hold occupies nothing. */
+export declare const mockLiveBookings: () => CFBooking[];
+export declare const mockBookingAvailability: (productId: string, from: Date, to: Date, resourceId?: string) => CFBookingAvailability;

package/dist/demo/database.js

@@ -4,6 +4,7 @@
  */
 import { CFProductType, CFUserTypes, CurrencyCode, } from '../CommonTypes';
 import { extendPrice, resolveUnit, toBase } from '@final-commerce/common';
+import { BookingRatePeriod, BookingResourceKind, BookingType, ReservationStatus } from '@final-commerce/common';
 export * from './mocks';
 // Asset Imports - Using Remote URLs to avoid build complexity with asset copying
 const ASSETS_BASE_URL = 'https://raw.githubusercontent.com/Final-Commerce/command-frame/refs/heads/main/src/demo/assets';
@@ -649,6 +650,14 @@ export const MOCK_CATEGORIES = [
     MOCK_CATEGORY_VEGAN,
     MOCK_CATEGORY_SPICY,
 ];
+// A service, not a thing on a shelf: no stock, sold as a slot of somebody's time.
+// `bookingRulesId` is what tells a catalogue screen to ask for slots instead of stock.
+export const MOCK_PRODUCT_HAIRCUT = {
+    ...createSimpleProduct('prod_haircut', 'Haircut', 4500, '', [MOCK_CATEGORY_SPECIALTY], 'Cut and finish, 30 minutes.'),
+    images: [],
+    productType: CFProductType.BOOKING,
+    bookingRulesId: 'rule_salon_30',
+};
 export const MOCK_PRODUCTS = [
     MOCK_PRODUCT_BASIL_ALMOND,
     MOCK_PRODUCT_BEER,
@@ -664,6 +673,7 @@ export const MOCK_PRODUCTS = [
     MOCK_PRODUCT_CHILI_GARLIC,
     MOCK_PRODUCT_HABANERO,
     MOCK_PRODUCT_BLACK_GARLIC,
+    MOCK_PRODUCT_HAIRCUT,
 ];
 export const MOCK_ORDERS = [MOCK_ORDER_1, MOCK_ORDER_2, MOCK_ORDER_3, MOCK_ORDER_4];
 export const MOCK_PARKED_ORDERS = [MOCK_PARKED_ORDER_1, MOCK_PARKED_ORDER_2];
@@ -914,3 +924,86 @@ export const applyMockPayment = (amount, paymentType, processor = 'cash') => {
     mockPublishEvent('payments', 'payment-done', { order });
     return order;
 };
+// ── Booking (FT-0064) ────────────────────────────────────────────────────────────
+// A salon: one service, two people who can perform it, a 30-minute slot with a
+// 5-minute turnaround, open 9–18. Enough to click through a booking screen with no
+// server. Availability here is COMPUTED, exactly as the host computes it — a mock
+// that returned a fixed list of slots would hide the one behaviour that matters:
+// a slot disappears once somebody takes it.
+export const MOCK_BOOKING_RULES_ID = 'rule_salon_30';
+const SLOT_MINUTES = 30;
+const BUFFER_MINUTES = 5;
+const OPEN_HOUR = 9;
+const CLOSE_HOUR = 18;
+export const MOCK_BOOKING_RESOURCES = [
+    { id: 'res_marco', name: 'Marco', kind: BookingResourceKind.STAFF },
+    { id: 'res_jessica', name: 'Jessica', kind: BookingResourceKind.STAFF },
+];
+const at = (dayOffset, hour, minute = 0) => {
+    const date = new Date();
+    date.setDate(date.getDate() + dayOffset);
+    date.setHours(hour, minute, 0, 0);
+    return date;
+};
+const booking = (id, resourceId, start, status, customerName) => ({
+    id,
+    productId: MOCK_PRODUCT_HAIRCUT._id,
+    resourceId,
+    startAt: start.toISOString(),
+    endAt: new Date(start.getTime() + SLOT_MINUTES * 60000).toISOString(),
+    bufferEndAt: new Date(start.getTime() + (SLOT_MINUTES + BUFFER_MINUTES) * 60000).toISOString(),
+    status,
+    productName: MOCK_PRODUCT_HAIRCUT.name,
+    resourceName: MOCK_BOOKING_RESOURCES.find((resource) => resource.id === resourceId)?.name,
+    customerName,
+});
+export const MOCK_BOOKINGS = [
+    booking('bk_1', 'res_marco', at(0, 10), ReservationStatus.CONFIRMED, 'Alex Green'),
+    booking('bk_2', 'res_jessica', at(0, 11, 30), ReservationStatus.CONFIRMED, 'Dana White'),
+    booking('bk_3', 'res_marco', at(1, 9, 30), ReservationStatus.CONFIRMED, 'Sam Blue'),
+];
+/** Live = confirmed, or held and not yet expired. An expired hold occupies nothing. */
+export const mockLiveBookings = () => MOCK_BOOKINGS.filter(({ status, expiresAt }) => status === ReservationStatus.CONFIRMED ||
+    (status === ReservationStatus.HELD && (!expiresAt || new Date(expiresAt) > new Date())));
+const takenBy = (resourceId, startAt, bufferEndAt) => mockLiveBookings().some((entry) => entry.resourceId === resourceId && new Date(entry.startAt) < bufferEndAt && new Date(entry.bufferEndAt) > startAt);
+export const mockBookingAvailability = (productId, from, to, resourceId) => {
+    const serving = resourceId
+        ? MOCK_BOOKING_RESOURCES.filter((resource) => resource.id === resourceId)
+        : MOCK_BOOKING_RESOURCES;
+    const slots = [];
+    const step = (SLOT_MINUTES + BUFFER_MINUTES) * 60000;
+    for (let day = 0; day < 14; day += 1) {
+        const open = at(day, OPEN_HOUR);
+        if (open < from || open > to)
+            continue;
+        const close = at(day, CLOSE_HOUR);
+        for (let start = open.getTime(); start + SLOT_MINUTES * 60000 <= close.getTime(); start += step) {
+            const startAt = new Date(start);
+            const endAt = new Date(start + SLOT_MINUTES * 60000);
+            const bufferEndAt = new Date(start + (SLOT_MINUTES + BUFFER_MINUTES) * 60000);
+            if (bufferEndAt < new Date())
+                continue;
+            const resources = serving.map((resource) => {
+                const free = takenBy(resource.id, startAt, bufferEndAt) ? 0 : 1;
+                return { resourceId: resource.id, name: resource.name, capacity: 1, booked: 1 - free, free };
+            });
+            slots.push({
+                startAt: startAt.toISOString(),
+                endAt: endAt.toISOString(),
+                bufferEndAt: bufferEndAt.toISOString(),
+                canStart: true,
+                capacity: resources.length,
+                booked: resources.reduce((sum, entry) => sum + entry.booked, 0),
+                free: resources.reduce((sum, entry) => sum + entry.free, 0),
+                resources,
+            });
+        }
+    }
+    return {
+        productId,
+        bookingRulesId: MOCK_BOOKING_RULES_ID,
+        bookingType: BookingType.APPOINTMENT,
+        ratePeriod: BookingRatePeriod.SLOT,
+        slots,
+    };
+};