@aglyn/plugins-commerce 1.0.0-beta.232 → 1.0.0-beta.234

package/src/lib/server/pos-offline-sync.js

@@ -0,0 +1,765 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import * as Aglyn from "@aglyn/aglyn/server";
+import recordCapturedContact from "@aglyn/aglyn/plugin-manager/record-captured-contact";
+import { FieldValue } from "firebase-admin/firestore";
+import * as CommerceModel from "../model/index.js";
+import { posOfflineFlagLabels, posOfflineSaleTotals, posOfflineSoldAt, posOfflineTotalsAddUp, POS_OFFLINE_LATE_SYNC_MS, POS_OFFLINE_SYNC_BATCH_MAX, sanitizePosOfflineSale } from "../model/commerce-pos-offline.js";
+import { ORDER_PAID_EVENT } from "../model/order-events.js";
+import { posMaxDiscountPct } from "../plugin-config.js";
+import { alertLowStockCrossing } from "./low-stock.js";
+import { notifyOrderBuyer } from "./order-notifications.js";
+import { raiseOrderEvent } from "./order-events.js";
+import { offlineFeeMonthKey } from "./pos-fee-month.js";
+import { authorizePosOps, defaultPosOpsDeps, posOpsBody, posOpsCleanId, resolvePosStaffAssertion } from "./pos-ops-gate.js";
+import { notifyPosSaleCompleted } from "./pos-sale.js";
+import { decrementVariantStock } from "./reserve-stock.js";
+export function defaultPosOfflineSyncDeps() {
+    const base = defaultPosOpsDeps();
+    return _extends({}, base, {
+        feePct: (org, productType)=>Aglyn.resolveTransactionFeePct(org, productType),
+        registerWithinCap: (org, hostId, rank)=>Aglyn.checkHostRegisterQuota(org, hostId, rank).allowed,
+        decrementStock: async (input)=>{
+            const moved = await decrementVariantStock(_extends({
+                firestore: base.firestore(),
+                hostRef: input.hostRef,
+                hostId: input.hostId,
+                productId: input.productId,
+                variantId: input.variantId,
+                quantity: input.quantity
+            }, input.locationId ? {
+                locationId: input.locationId
+            } : {}, {
+                ledger: {
+                    reason: 'sale',
+                    orderId: input.orderId
+                }
+            }));
+            if (moved.before && moved.after) alertLowStockCrossing(input.hostId, moved.before, moved.after);
+            return moved;
+        },
+        afterSale: async (input)=>{
+            const settle = async (label, work)=>{
+                try {
+                    await work();
+                } catch (error) {
+                    console.error(`[pos-offline-sync] ${label} failed`, input.orderId, error);
+                }
+            };
+            if (input.email) {
+                await settle('contact', ()=>{
+                    var _ref, _ref1;
+                    var _input_order_totals, _input_order_totals1;
+                    return recordCapturedContact({
+                        orgId: '',
+                        hostId: input.hostId,
+                        identity: _extends({
+                            email: input.email
+                        }, input.name ? {
+                            name: input.name
+                        } : {}),
+                        surface: 'relationship',
+                        lifecycleFloor: 'customer',
+                        purchaseCents: Number((_ref = (_input_order_totals = input.order.totals) == null ? void 0 : _input_order_totals.totalCents) != null ? _ref : 0),
+                        interaction: {
+                            source: 'order',
+                            refId: input.orderId,
+                            summary: `In-store purchase ($${(Number((_ref1 = (_input_order_totals1 = input.order.totals) == null ? void 0 : _input_order_totals1.totalCents) != null ? _ref1 : 0) / 100).toFixed(2)})`
+                        }
+                    });
+                });
+            }
+            // The sale-completed listeners hear it too, told it was rung offline:
+            // the cloud printers must not print a receipt or pop the drawer for a
+            // sale the customer walked away with hours ago.
+            await settle('sale completed', ()=>notifyPosSaleCompleted({
+                    hostId: input.hostId,
+                    orderId: input.orderId,
+                    order: input.order,
+                    offline: true
+                }));
+            // The emailed receipt sends now, on sync (the printed one went offline).
+            await settle('receipt', ()=>notifyOrderBuyer({
+                    hostId: input.hostId,
+                    orderId: input.orderId
+                }, 'receipt', {
+                    email: input.email
+                }));
+            await settle('paid event', ()=>raiseOrderEvent(ORDER_PAID_EVENT, {
+                    hostId: input.hostId,
+                    orderId: input.orderId,
+                    key: 'paid'
+                }));
+        }
+    });
+}
+const money = (cents)=>`$${(Math.max(0, cents) / 100).toFixed(2)}`;
+/** The store's in-person tax, as every register sale computes it. */ export function posInPersonTax(settings) {
+    var _taxSettings_origin;
+    const taxSettings = settings != null ? settings : {};
+    const decision = CommerceModel.storefrontTaxDecision({
+        settings: taxSettings
+    });
+    if (decision.kind === 'undecided') {
+        return {
+            ok: false,
+            reason: CommerceModel.STOREFRONT_TAX_UNDECIDED_MESSAGE
+        };
+    }
+    const misconfigured = CommerceModel.storefrontTaxMisconfiguration(taxSettings, {
+        inPerson: true
+    });
+    if (misconfigured) return {
+        ok: false,
+        reason: misconfigured
+    };
+    const rate = decision.kind === 'manual' ? CommerceModel.resolveTaxRate(taxSettings, (_taxSettings_origin = taxSettings.origin) != null ? _taxSettings_origin : {}) : null;
+    return {
+        ok: true,
+        pct: rate && rate.pct > 0 ? rate.pct : null,
+        pricesIncludeTax: taxSettings.pricesIncludeTax === true,
+        decision
+    };
+}
+async function readRegisters(staff) {
+    const docs = (await staff.hostRef.collection('registers').get()).docs.map((doc)=>{
+        var _doc_data, _ref, _ref1;
+        var _doc_get_toMillis, _doc_get;
+        return {
+            id: doc.id,
+            data: (_doc_data = doc.data()) != null ? _doc_data : {},
+            createdAtMs: Number((_ref = (_ref1 = (_doc_get = doc.get('createdAt')) == null ? void 0 : (_doc_get_toMillis = _doc_get.toMillis) == null ? void 0 : _doc_get_toMillis.call(_doc_get)) != null ? _ref1 : doc.get('createdAtMs')) != null ? _ref : 0)
+        };
+    }).sort((a, b)=>a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id));
+    return new Map(docs.map((doc, rank)=>[
+            doc.id,
+            {
+                rank,
+                data: doc.data
+            }
+        ]));
+}
+async function readStoreTax(staff) {
+    var _store_get;
+    const store = await staff.hostRef.collection('settings').doc('store').get();
+    return (_store_get = store.get('tax')) != null ? _store_get : undefined;
+}
+/** The kit a register caches to sell offline. */ export async function buildPosOfflineKit(deps, staff) {
+    var _host_get;
+    const [registers, taxSettings, config, host, store] = await Promise.all([
+        readRegisters(staff),
+        readStoreTax(staff),
+        staff.orgId ? deps.pluginConfig(staff.orgId, staff.hostId).catch(()=>({})) : Promise.resolve({}),
+        staff.hostRef.get(),
+        staff.hostRef.collection('settings').doc('store').get()
+    ]);
+    const tax = posInPersonTax(taxSettings);
+    return _extends({
+        v: 1,
+        hostId: staff.hostId,
+        orgId: staff.orgId,
+        issuedAtMs: deps.now(),
+        available: tax.ok
+    }, 'reason' in tax ? {
+        unavailableReason: tax.reason
+    } : {}, {
+        tax: 'decision' in tax ? {
+            pct: tax.pct,
+            pricesIncludeTax: tax.pricesIncludeTax
+        } : {
+            pct: null,
+            pricesIncludeTax: false
+        },
+        maxDiscountPct: posMaxDiscountPct(config),
+        requireOpenShift: staff.settings.requireOpenShift,
+        registers: [
+            ...registers.entries()
+        ].filter(([, register])=>deps.registerWithinCap(staff.org, staff.hostId, register.rank)).map(([id, register])=>{
+            var _register_data_name;
+            return _extends({
+                id,
+                name: String((_register_data_name = register.data['name']) != null ? _register_data_name : 'Register').slice(0, 120)
+            }, register.data['locationId'] ? {
+                locationId: String(register.data['locationId'])
+            } : {}, {
+                openShiftId: posOpsCleanId(register.data['openShiftId']) || null
+            });
+        }),
+        receipt: _extends({
+            name: String((_host_get = host.get('displayName')) != null ? _host_get : '') || 'Receipt'
+        }, typeof host.get('logoUrl') === 'string' && host.get('logoUrl') ? {
+            logo: String(host.get('logoUrl'))
+        } : {}, staff.settings.receiptAddress ? {
+            address: staff.settings.receiptAddress
+        } : {}, store.get('receiptFooter') ? {
+            footer: String(store.get('receiptFooter')).slice(0, 500)
+        } : {}, staff.settings.returnPolicy ? {
+            returnPolicy: staff.settings.returnPolicy
+        } : {})
+    });
+}
+const refused = (saleKey, reason, error, retry)=>({
+        saleKey,
+        status: 'refused',
+        reason,
+        error,
+        retry
+    });
+const replayOf = (record)=>({
+        saleKey: record.saleKey,
+        status: 'replayed',
+        orderId: record.orderId,
+        number: record.number,
+        flags: record.flags,
+        stockConflicts: record.stockConflicts
+    });
+/** The take the plan owes on the goods after the discount (AGL-2111, AGL-2256). */ function takeFeeCents(deps, staff, lines, totals) {
+    let applies = false;
+    const gross = lines.reduce((sum, line)=>{
+        var _line_productType;
+        const pct = deps.feePct(staff.org, (_line_productType = line.productType) != null ? _line_productType : 'physical');
+        if (pct > 0) applies = true;
+        return sum + Math.round(line.unitAmountCents * line.quantity * pct / 100);
+    }, 0);
+    const charged = Math.max(0, totals.itemsCents - totals.discountCents);
+    const scaled = totals.itemsCents > 0 ? Math.round(gross * charged / totals.itemsCents) : 0;
+    return applies && charged > 0 ? Math.max(1, scaled) : scaled;
+}
+/**
+ * The steps after the commit, each recorded as it finishes. Run by the sync
+ * that recorded the sale, and again by any later sync of it that finds them
+ * unfinished.
+ */ async function finishSale(context, recordRef, orderRef, record) {
+    var _orderSnapshot_data;
+    const { deps, staff } = context;
+    const orderSnapshot = await orderRef.get();
+    const order = (_orderSnapshot_data = orderSnapshot.data()) != null ? _orderSnapshot_data : {};
+    let current = record;
+    if (!current.stockDone) {
+        var _order_lineItems;
+        const conflicts = [
+            ...current.stockConflicts
+        ];
+        const done = new Set(current.stockLines);
+        const lines = (_order_lineItems = order.lineItems) != null ? _order_lineItems : [];
+        for (const [index, line] of lines.entries()){
+            var _line_variantId;
+            if (done.has(index)) continue;
+            const moved = await deps.decrementStock(_extends({
+                hostRef: staff.hostRef,
+                hostId: staff.hostId,
+                productId: line.productId,
+                variantId: (_line_variantId = line.variantId) != null ? _line_variantId : 'default',
+                quantity: line.quantity
+            }, order['locationId'] ? {
+                locationId: String(order['locationId'])
+            } : {}, {
+                orderId: orderRef.id
+            }));
+            // A failed commit leaves the line for the next sync to take, rather than
+            // marking stock taken that never moved.
+            if (moved.failed) continue;
+            // Untracked stock (or a product gone since) moves nothing and is short of nothing.
+            const short = moved.before ? moved.applied - moved.requested : 0;
+            if (short > 0) {
+                conflicts.push(_extends({
+                    productId: line.productId
+                }, line.variantId ? {
+                    variantId: line.variantId
+                } : {}, {
+                    name: [
+                        line.name,
+                        line.variantLabel
+                    ].filter(Boolean).join(' — '),
+                    requested: Math.abs(moved.requested),
+                    applied: Math.abs(moved.applied),
+                    shortUnits: short
+                }));
+            }
+            done.add(index);
+            await recordRef.update({
+                stockLines: [
+                    ...done
+                ].sort((a, b)=>a - b),
+                stockConflicts: conflicts
+            });
+        }
+        const stockDone = lines.every((_line, index)=>done.has(index));
+        const flags = conflicts.length && !current.flags.includes('stock-short') ? [
+            ...current.flags,
+            'stock-short'
+        ] : current.flags;
+        current = _extends({}, current, {
+            stockLines: [
+                ...done
+            ],
+            stockConflicts: conflicts,
+            stockDone,
+            flags
+        });
+        await recordRef.update({
+            stockDone,
+            flags,
+            stockConflicts: conflicts
+        });
+        if (conflicts.length && conflicts.length !== record.stockConflicts.length) {
+            const fresh = (await orderRef.get()).data();
+            const stamp = fresh == null ? void 0 : fresh.offline;
+            await orderRef.update(_extends({}, stamp ? {
+                offline: _extends({}, stamp, {
+                    flags,
+                    stockConflicts: conflicts
+                })
+            } : {}, {
+                timeline: CommerceModel.appendOrderEvent(fresh != null ? fresh : {}, 'offline-stock-short', conflicts.map((conflict)=>`${conflict.shortUnits} of ${conflict.requested}× ${conflict.name} not in stock`).join('; ').slice(0, 500), deps.now())
+            }));
+        }
+        if (!stockDone) return current;
+    }
+    if (!current.notified) {
+        var _order_customerEmail, _order_customerName;
+        const email = String((_order_customerEmail = order.customerEmail) != null ? _order_customerEmail : '');
+        await deps.afterSale({
+            hostId: staff.hostId,
+            orderId: orderRef.id,
+            order: order,
+            email,
+            name: String((_order_customerName = order.customerName) != null ? _order_customerName : '')
+        });
+        current = _extends({}, current, {
+            notified: true,
+            status: 'settled'
+        });
+        await recordRef.update({
+            notified: true,
+            status: 'settled'
+        });
+    }
+    return current;
+}
+async function syncOne(context, raw) {
+    var _ref, _sale_customer;
+    const { deps, staff } = context;
+    const read = sanitizePosOfflineSale(raw);
+    const rawKey = String((_ref = raw == null ? void 0 : raw['saleKey']) != null ? _ref : '').slice(0, 64);
+    if ('error' in read) return refused(rawKey, 'invalid', read.error, false);
+    const sale = read.sale;
+    if (sale.hostId !== staff.hostId) {
+        return refused(sale.saleKey, 'wrong-site', 'This sale was rung for another site.', false);
+    }
+    if (sale.signedInUid !== staff.uid) {
+        return refused(sale.saleKey, 'wrong-staff', 'This sale was rung while another member was signed in. It syncs when they sign in on this register.', true);
+    }
+    if (sale.orgId && staff.orgId && sale.orgId !== staff.orgId) {
+        return refused(sale.saleKey, 'wrong-workspace', 'This sale was rung in another workspace.', false);
+    }
+    const firestore = deps.firestore();
+    const hostRef = staff.hostRef;
+    const recordRef = hostRef.collection('posOfflineSales').doc(sale.saleKey);
+    const orderRef = hostRef.collection('orders').doc(sale.saleKey);
+    const existing = await recordRef.get();
+    if (existing.exists) {
+        const record = existing.data();
+        if (record.signedInUid !== staff.uid) {
+            return refused(sale.saleKey, 'conflict', 'Another sale already used this key.', false);
+        }
+        return replayOf(record.status === 'settled' ? record : await finishSale(context, recordRef, orderRef, record));
+    }
+    const now = deps.now();
+    const flags = new Set();
+    const soldAt = posOfflineSoldAt(sale.soldAtMs, now);
+    if (soldAt.adjusted) flags.add('clock-adjusted');
+    else if (now - soldAt.atMs > POS_OFFLINE_LATE_SYNC_MS) flags.add('late-sync');
+    // The lines as sold, checked against the catalog as it stands now. The
+    // price on the order is the one rung — that is what the customer paid —
+    // and the catalog's is kept beside it where they differ.
+    const productIds = [
+        ...new Set(sale.lines.map((line)=>line.productId))
+    ];
+    const snapshots = await Promise.all(productIds.map((id)=>hostRef.collection('products').doc(id).get()));
+    const products = new Map(snapshots.map((snapshot)=>[
+            snapshot.id,
+            snapshot.exists ? CommerceModel.liftLegacyProduct(snapshot.data()) : null
+        ]));
+    const priceDrift = [];
+    const lineItems = sale.lines.map((line, index)=>{
+        var _product_variants_find, _ref, _product_type;
+        const product = products.get(line.productId);
+        if (!product) {
+            var _line_productType;
+            flags.add('unknown-product');
+            return _extends({
+                productId: line.productId
+            }, line.variantId ? {
+                variantId: line.variantId
+            } : {}, {
+                name: line.name
+            }, line.variantLabel ? {
+                variantLabel: line.variantLabel
+            } : {}, line.sku ? {
+                sku: line.sku
+            } : {}, {
+                productType: (_line_productType = line.productType) != null ? _line_productType : 'physical',
+                quantity: line.quantity,
+                unitAmountCents: line.unitAmountCents
+            });
+        }
+        const variant = (_product_variants_find = product.variants.find((item)=>item.id === line.variantId)) != null ? _product_variants_find : product.variants[0];
+        const chosen = CommerceModel.resolveLineModifiers(product, line.modifiers);
+        const currentCents = variant && CommerceModel.variantHasPrice(variant) && chosen.ok ? Math.round(Number(variant.priceUsd) * 100) + chosen.extraCents : null;
+        if (currentCents !== line.unitAmountCents) {
+            flags.add('price-changed');
+            priceDrift.push({
+                index,
+                rungCents: line.unitAmountCents,
+                currentCents: currentCents != null ? currentCents : 0
+            });
+        }
+        return _extends({
+            productId: line.productId
+        }, variant && variant.id !== 'default' ? {
+            variantId: variant.id
+        } : {}, {
+            name: product.name || line.name
+        }, line.variantLabel ? {
+            variantLabel: line.variantLabel
+        } : {}, (variant == null ? void 0 : variant.sku) ? {
+            sku: variant.sku
+        } : line.sku ? {
+            sku: line.sku
+        } : {}, {
+            productType: (_ref = (_product_type = product.type) != null ? _product_type : line.productType) != null ? _ref : 'physical',
+            quantity: line.quantity,
+            unitAmountCents: line.unitAmountCents
+        }, chosen.ok && chosen.modifiers.length ? {
+            modifiers: chosen.modifiers
+        } : {});
+    });
+    // The money: what the register rang, when its own arithmetic holds; the
+    // arithmetic of its lines, with the tax it rang, when it does not.
+    let totals;
+    if (posOfflineTotalsAddUp(sale)) {
+        totals = CommerceModel.computeOrderTotals(lineItems, {
+            discountCents: sale.totals.discountCents,
+            taxCents: sale.totals.taxCents
+        });
+    } else {
+        flags.add('totals-restated');
+        const restated = posOfflineSaleTotals({
+            lines: sale.lines,
+            discountPct: sale.discountPct,
+            tax: {
+                pct: null,
+                pricesIncludeTax: false
+            }
+        });
+        totals = CommerceModel.computeOrderTotals(lineItems, {
+            discountCents: restated.discountCents,
+            taxCents: Math.min(sale.totals.taxCents, restated.itemsCents - restated.discountCents)
+        });
+    }
+    if ('decision' in context.tax) {
+        const expected = posOfflineSaleTotals({
+            lines: sale.lines,
+            discountPct: sale.discountPct,
+            tax: {
+                pct: context.tax.pct,
+                pricesIncludeTax: context.tax.pricesIncludeTax
+            }
+        });
+        if (expected.taxCents !== totals.taxCents) flags.add('tax-differs');
+    } else if (totals.taxCents > 0) {
+        flags.add('tax-differs');
+    }
+    if (sale.discountPct > posMaxDiscountPct(context.config)) flags.add('discount-over-limit');
+    if (sale.cashTenderedCents < totals.totalCents) flags.add('cash-short');
+    // Where it was rung.
+    const register = context.registers.get(sale.registerId);
+    if (!register) flags.add('unknown-register');
+    else if (!deps.registerWithinCap(staff.org, staff.hostId, register.rank)) flags.add('register-over-cap');
+    let shiftId = '';
+    if (sale.shiftId && register) {
+        const shift = await hostRef.collection('registers').doc(sale.registerId).collection('shifts').doc(sale.shiftId).get();
+        if (shift.exists) {
+            shiftId = sale.shiftId;
+            if (shift.get('status') !== 'open') flags.add('shift-closed');
+        }
+    }
+    if (!shiftId && staff.settings.requireOpenShift) flags.add('no-shift');
+    // Who rang it: a PIN-switched cashier's assertion is read as of the moment
+    // the cash was taken (it was valid then, and expiring since is the normal
+    // case for a sale that waited to sync), and the member is re-checked NOW.
+    let cashierId = staff.uid;
+    if (sale.cashierAssertion) {
+        const memberUid = await resolvePosStaffAssertion(_extends({}, deps, {
+            now: ()=>soldAt.atMs
+        }), hostRef, sale.cashierAssertion, {
+            hostId: staff.hostId,
+            registerId: sale.registerId,
+            purpose: 'cashier'
+        });
+        if (memberUid) cashierId = memberUid;
+        else flags.add('cashier-unverified');
+    }
+    const takeFee = takeFeeCents(deps, staff, lineItems, totals);
+    totals = _extends({}, totals, {
+        feeCents: takeFee
+    });
+    const changeCents = Math.max(0, sale.cashTenderedCents - totals.totalCents);
+    const flagList = [
+        ...flags
+    ];
+    const stamp = _extends({
+        saleKey: sale.saleKey,
+        soldAtMs: soldAt.atMs,
+        syncedAtMs: now,
+        syncedBy: staff.uid,
+        flags: flagList
+    }, priceDrift.length ? {
+        priceDrift
+    } : {});
+    const customer = (_sale_customer = sale.customer) != null ? _sale_customer : {};
+    const feeMonth = offlineFeeMonthKey(new Date(now));
+    const feeRef = staff.orgId ? firestore.collection('orgs').doc(staff.orgId).collection('offlineFees').doc(feeMonth) : null;
+    const counterRef = hostRef.collection('counters').doc('orders');
+    const committed = await firestore.runTransaction(async (transaction)=>{
+        var _counter_get;
+        const raced = await transaction.get(recordRef);
+        if (raced.exists) return {
+            raced: raced.data()
+        };
+        const taken = await transaction.get(orderRef);
+        if (taken.exists) return {
+            collision: true
+        };
+        const counter = await transaction.get(counterRef);
+        const number = Number((_counter_get = counter.get('next')) != null ? _counter_get : 1);
+        transaction.set(counterRef, {
+            next: number + 1
+        }, {
+            merge: true
+        });
+        const paidDetail = `Cash — received ${money(sale.cashTenderedCents)}, change ${money(changeCents)}. ` + 'Rung while the register was offline.';
+        const timeline = [
+            {
+                atMs: soldAt.atMs,
+                event: 'paid',
+                detail: paidDetail
+            },
+            {
+                atMs: now,
+                event: 'offline-synced',
+                detail: flagList.length ? `Synced. Check: ${posOfflineFlagLabels(flagList).join('; ')}`.slice(0, 1000) : 'Synced.'
+            }
+        ];
+        transaction.create(orderRef, CommerceModel.withOrderListFields(orderRef.id, _extends({
+            number,
+            status: 'paid',
+            channel: 'pos',
+            registerId: sale.registerId,
+            cashierId
+        }, shiftId ? {
+            shiftId
+        } : {}, customer.name ? {
+            customerName: customer.name
+        } : {}, customer.kind && customer.id ? {
+            customerRecord: {
+                kind: customer.kind,
+                id: customer.id
+            }
+        } : {}, sale.discountPct > 0 ? {
+            discountPct: sale.discountPct,
+            discountBy: cashierId
+        } : {}, sale.locationId ? {
+            locationId: sale.locationId
+        } : {}, {
+            lineItems,
+            totals,
+            taxMode: 'decision' in context.tax ? CommerceModel.storefrontTaxModeForDecision(context.tax.decision, totals.taxCents) : totals.taxCents > 0 ? 'manual' : 'none'
+        }, takeFee > 0 ? {
+            feeCollection: 'invoice'
+        } : {}, {
+            payments: [
+                {
+                    id: 'pay_cash',
+                    method: 'cash',
+                    amountCents: totals.totalCents,
+                    status: 'succeeded',
+                    atMs: soldAt.atMs,
+                    settledAtMs: soldAt.atMs,
+                    takeFeeCents: takeFee,
+                    feeCents: 0,
+                    cashierId,
+                    cashTenderedCents: sale.cashTenderedCents,
+                    changeCents
+                }
+            ],
+            customerEmail: customer.email || null,
+            timeline,
+            offline: stamp,
+            createdAtMs: soldAt.atMs,
+            createdAt: FieldValue.serverTimestamp()
+        })));
+        const record = {
+            saleKey: sale.saleKey,
+            orderId: orderRef.id,
+            number,
+            signedInUid: staff.uid,
+            registerId: sale.registerId,
+            soldAtMs: soldAt.atMs,
+            syncedAtMs: now,
+            status: 'recorded',
+            flags: flagList,
+            stockConflicts: [],
+            stockLines: [],
+            stockDone: false,
+            notified: false
+        };
+        transaction.create(recordRef, record);
+        // The take accrues with the order, in the same transaction (AGL-2111).
+        if (takeFee > 0 && feeRef) {
+            transaction.set(feeRef, {
+                month: feeMonth,
+                feeCents: FieldValue.increment(takeFee),
+                orders: FieldValue.increment(1)
+            }, {
+                merge: true
+            });
+        }
+        return {
+            record
+        };
+    });
+    if ('collision' in committed) {
+        return refused(sale.saleKey, 'conflict', 'Another order already has this sale’s key.', false);
+    }
+    if ('raced' in committed) {
+        const record = committed.raced;
+        if (record.signedInUid !== staff.uid) {
+            return refused(sale.saleKey, 'conflict', 'Another sale already used this key.', false);
+        }
+        return replayOf(record);
+    }
+    const finished = await finishSale(context, recordRef, orderRef, committed.record);
+    return {
+        saleKey: sale.saleKey,
+        status: 'recorded',
+        orderId: orderRef.id,
+        number: finished.number,
+        flags: finished.flags,
+        stockConflicts: finished.stockConflicts
+    };
+}
+export async function handlePosOfflineSync(deps, req) {
+    var _req_query;
+    if (req.method !== 'GET' && req.method !== 'POST') {
+        return {
+            status: 405,
+            body: {
+                error: 'Method not allowed'
+            }
+        };
+    }
+    const body = req.method === 'GET' ? Object.fromEntries(Object.entries((_req_query = req.query) != null ? _req_query : {}).map(([key, value])=>[
+            key,
+            Array.isArray(value) ? value[0] : value
+        ])) : posOpsBody(req);
+    const gate = await authorizePosOps(deps, req, body['hostId']);
+    if ('error' in gate) return {
+        status: gate.status,
+        body: {
+            error: gate.error
+        }
+    };
+    const staff = gate.staff;
+    if (req.method === 'GET') {
+        return {
+            status: 200,
+            body: {
+                kit: await buildPosOfflineKit(deps, staff)
+            }
+        };
+    }
+    const sales = Array.isArray(body['sales']) ? body['sales'] : null;
+    if (!sales) return {
+        status: 400,
+        body: {
+            error: 'Missing sales'
+        }
+    };
+    if (sales.length > POS_OFFLINE_SYNC_BATCH_MAX) {
+        return {
+            status: 400,
+            body: {
+                error: `Send at most ${POS_OFFLINE_SYNC_BATCH_MAX} sales at a time`
+            }
+        };
+    }
+    if (sales.length === 0) return {
+        status: 200,
+        body: {
+            results: []
+        }
+    };
+    const [registers, taxSettings, config] = await Promise.all([
+        readRegisters(staff),
+        readStoreTax(staff),
+        staff.orgId ? deps.pluginConfig(staff.orgId, staff.hostId).catch(()=>({})) : Promise.resolve({})
+    ]);
+    const context = {
+        deps,
+        staff,
+        config,
+        tax: posInPersonTax(taxSettings),
+        registers
+    };
+    const results = [];
+    // One at a time, in the order they were rung, so order numbers follow the
+    // till and one sale's failure cannot take the rest with it.
+    for (const sale of sales){
+        try {
+            results.push(await syncOne(context, sale));
+        } catch (error) {
+            var _ref;
+            console.error('[pos-offline-sync] sale failed', error);
+            const key = String((_ref = sale == null ? void 0 : sale['saleKey']) != null ? _ref : '').slice(0, 64);
+            results.push(refused(key, 'failed', 'The sale could not be synced yet. It stays on this register.', true));
+        }
+    }
+    return {
+        status: 200,
+        body: {
+            results
+        }
+    };
+}
+export function createPosOfflineSyncHandler(deps = defaultPosOfflineSyncDeps) {
+    return async (req, res)=>{
+        try {
+            const outcome = await handlePosOfflineSync(deps(), req);
+            return res.status(outcome.status).json(outcome.body);
+        } catch (error) {
+            console.error('[pos-offline-sync] failed', error);
+            return res.status(500).json({
+                error: 'The offline sales could not be synced'
+            });
+        }
+    };
+}
+export const posOfflineSyncHandler = createPosOfflineSyncHandler();
+
+//# sourceMappingURL=pos-offline-sync.js.map