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

package/src/lib/server/channel-orders.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @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 type { PluginChannelOrder, PluginChannelOrderCancelOutcome, PluginChannelOrderFee, PluginChannelOrderOutcome, PluginChannelOrders } from '@aglyn/aglyn/plugin-manager/plugin-channel-orders';
+/**
+ * ORDERS SOLD ON ANOTHER CHANNEL (AGL-3638): commerce's implementation of
+ * core's `core.channel-orders`, which a marketplace plugin records each
+ * order it brings in through.
+ *
+ * ## One transaction, so two channels cannot sell the last unit twice
+ *
+ * The order, its number, every product's count, every count's ledger row and
+ * the `order.paid` event are ONE Firestore transaction. Each product is read
+ * with `transaction.get`, which serializes this write with every other sale
+ * of that product (the AGL-2320 reasoning): a storefront checkout landing at
+ * the same moment decrements from the count this write left, never from the
+ * one it read. The marketplace plugin then pushes the new count to every
+ * other channel.
+ *
+ * A marketplace order is already sold and paid when it arrives, so a shelf
+ * that cannot cover it does not refuse it: the units the shelf held are
+ * taken, the order is recorded whole, and the merchant is told which units
+ * are short — the same loud oversell `reserve-stock.ts` raises.
+ *
+ * ## Once per outside order
+ *
+ * The order's id is derived from the channel and its order id
+ * ({@link channelOrderDocId}), and the transaction refuses to write over an
+ * order that exists, so a retried import answers `already` and moves nothing.
+ *
+ * ## No money moves here
+ *
+ * The buyer paid the channel. `totals.feeCents` — Aglyn's own take — is 0,
+ * the channel's charges are recorded on `channelSource.fees` for the
+ * merchant's books, the tax is the channel's to remit, and refunds happen on
+ * the channel. No buyer email is sent: a marketplace forbids contacting its
+ * buyers outside it, and none of them hands over a real address.
+ */
+type Firestore = FirebaseFirestore.Firestore;
+/**
+ * The order document's id for one outside order: the channel, then a hash of
+ * the channel's own id. Deterministic, so a second import of the same order
+ * finds the first; hashed, because a channel's id may hold characters a
+ * document id may not.
+ */
+export declare function channelOrderDocId(channelId: string, externalOrderId: string): string;
+/** What a seller refuses before reading anything, in the merchant's words; `null` when the order is well formed. */
+export declare function channelOrderProblem(order: PluginChannelOrder): string | null;
+export interface ChannelOrderDeps {
+    firestore: () => Firestore;
+    now: () => number;
+}
+/** Records one outside order; see the module header. */
+export declare function importChannelOrder(order: PluginChannelOrder, deps?: ChannelOrderDeps): Promise<PluginChannelOrderOutcome>;
+/**
+ * The channel canceled an order it sent: the order is cancelled here, and
+ * the units its sale took go back on the shelf — bounded by its own ledger,
+ * exactly as the console's cancel bounds them. Refuses once anything shipped.
+ */
+export declare function cancelChannelOrder(request: {
+    hostId: string;
+    recordId: string;
+    reason: string;
+}, deps?: ChannelOrderDeps): Promise<PluginChannelOrderCancelOutcome>;
+/** The channel's charges on a sale, recorded once it says; a later answer replaces an earlier one. */
+export declare function recordChannelOrderFees(request: {
+    hostId: string;
+    recordId: string;
+    fees: PluginChannelOrderFee[];
+}, deps?: ChannelOrderDeps): Promise<'recorded' | 'no_such_record'>;
+export declare const commerceChannelOrders: PluginChannelOrders;
+export {};

package/src/lib/server/channel-orders.js

@@ -0,0 +1,543 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * @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 { createResourceUid } from "@aglyn/aglyn/app-utils/create-resource-uid";
+import { notifyHostManagers } from "@aglyn/tenant-data-admin";
+import { firebaseAdmin } from "@aglyn/tenant-data-admin/server/firebase-admin";
+import { createHash } from "node:crypto";
+import * as CommerceModel from "../model/index.js";
+import { ORDER_CANCELLED_EVENT, ORDER_PAID_EVENT } from "../model/order-events.js";
+import { alertLowStockCrossing } from "./low-stock.js";
+import { stageOrderEvent } from "./order-events.js";
+import { capRestockLines, resolveTrackedRestockLines, saleReleaseCaps } from "./restock-flag.js";
+import { completeChannelOrder, recordChannelOrderRefund } from "./channel-order-updates.js";
+const DOC_ID = /^[A-Za-z0-9_-]{1,200}$/;
+const CHANNEL_ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
+const MAX_LINES = 250;
+const MAX_UNITS = 10000;
+const MAX_CENTS = 10000000000;
+/**
+ * The order document's id for one outside order: the channel, then a hash of
+ * the channel's own id. Deterministic, so a second import of the same order
+ * finds the first; hashed, because a channel's id may hold characters a
+ * document id may not.
+ */ export function channelOrderDocId(channelId, externalOrderId) {
+    const digest = createHash('sha256').update(`${channelId}\u0000${externalOrderId}`).digest('hex').slice(0, 24);
+    return `${channelId}-${digest}`;
+}
+const whole = (value, max)=>{
+    const number = Number(value);
+    return Number.isInteger(number) && number >= 0 && number <= max ? number : null;
+};
+const clip = (value, max)=>String(value != null ? value : '').trim().slice(0, max);
+/** What a seller refuses before reading anything, in the merchant's words; `null` when the order is well formed. */ export function channelOrderProblem(order) {
+    var _ref, _ref1, _order_currency;
+    var _order_channel;
+    if (!DOC_ID.test(String((_ref = order == null ? void 0 : order.hostId) != null ? _ref : '')) || /^__.*__$/.test(order.hostId)) return 'The order names no site.';
+    if (!CHANNEL_ID.test(String((_ref1 = (_order_channel = order.channel) == null ? void 0 : _order_channel.id) != null ? _ref1 : ''))) return 'The order names no channel.';
+    if (!clip(order.externalOrderId, 200)) return 'The order has no id on its channel.';
+    if (!/^[A-Za-z]{3}$/.test(String((_order_currency = order.currency) != null ? _order_currency : ''))) return 'The order names no currency.';
+    const lines = Array.isArray(order.lines) ? order.lines : [];
+    if (!lines.length) return 'The order has no items.';
+    if (lines.length > MAX_LINES) return `The order has more than ${MAX_LINES} items.`;
+    for (const line of lines){
+        if (whole(line == null ? void 0 : line.quantity, MAX_UNITS) === null || Number(line.quantity) < 1) return 'An item of the order has no quantity.';
+        if (whole(line == null ? void 0 : line.unitPriceCents, MAX_CENTS) === null) return 'An item of the order has no price.';
+        if (!clip(line == null ? void 0 : line.externalLineId, 200)) return 'An item of the order has no id on its channel.';
+    }
+    for (const amount of [
+        order.shippingCents,
+        order.taxCents,
+        order.discountCents,
+        order.totalCents
+    ]){
+        if (whole(amount, MAX_CENTS) === null) return 'The order’s totals are not whole amounts.';
+    }
+    return null;
+}
+const cleanFees = (fees)=>{
+    if (!Array.isArray(fees)) return {
+        fees: null,
+        totalCents: null
+    };
+    const kept = fees.map((fee)=>({
+            label: clip(fee == null ? void 0 : fee.label, 80) || 'Fee',
+            amountCents: whole(fee == null ? void 0 : fee.amountCents, MAX_CENTS)
+        })).filter((fee)=>fee.amountCents !== null).slice(0, 20);
+    return {
+        fees: kept,
+        totalCents: kept.reduce((sum, fee)=>sum + fee.amountCents, 0)
+    };
+};
+const address = (value)=>{
+    if (!value) return null;
+    const out = {};
+    for (const key of [
+        'name',
+        'line1',
+        'line2',
+        'city',
+        'state',
+        'postalCode',
+        'country',
+        'phone'
+    ]){
+        const text = clip(value[key], 200);
+        if (text) out[key] = key === 'country' ? text.toUpperCase() : text;
+    }
+    return Object.keys(out).length ? out : null;
+};
+/** The live variant whose SKU is `sku`, matched without regard to case; `null` when none or several products claim it. */ async function locateSku(firestore, hostId, sku) {
+    const wanted = sku.trim().toLowerCase();
+    if (!wanted) return null;
+    const snapshot = await firestore.collection('hosts').doc(hostId).collection('products').where('skus', 'array-contains', wanted).limit(5).get();
+    const found = [];
+    for (const doc of snapshot.docs){
+        if (doc.get('deletedAt')) continue;
+        const variants = Array.isArray(doc.get('variants')) ? doc.get('variants') : [];
+        const variant = variants.find((entry)=>{
+            var _ref;
+            return String((_ref = entry == null ? void 0 : entry['sku']) != null ? _ref : '').trim().toLowerCase() === wanted && (entry == null ? void 0 : entry['id']);
+        });
+        if (variant) found.push({
+            productId: doc.id,
+            variantId: String(variant['id'])
+        });
+    }
+    // Two products sharing a SKU is ambiguous; taking either's stock would be a guess.
+    return found.length === 1 ? found[0] : null;
+}
+const defaultDeps = ()=>({
+        firestore: ()=>firebaseAdmin.app().firestore(),
+        now: Date.now
+    });
+/** Records one outside order; see the module header. */ export async function importChannelOrder(order, deps = defaultDeps()) {
+    var _existing_data;
+    const problem = channelOrderProblem(order);
+    if (problem) return {
+        outcome: 'refused',
+        reason: problem
+    };
+    const firestore = deps.firestore();
+    const hostRef = firestore.collection('hosts').doc(order.hostId);
+    const orderId = channelOrderDocId(order.channel.id, clip(order.externalOrderId, 200));
+    const orderRef = hostRef.collection('orders').doc(orderId);
+    const channelLabel = clip(order.channel.label, 60) || order.channel.id;
+    // Already recorded: answered before any product is looked up.
+    const existing = await orderRef.get();
+    if (existing.exists) return alreadyOutcome(orderId, (_existing_data = existing.data()) != null ? _existing_data : {});
+    const store = await hostRef.collection('settings').doc('store').get();
+    const storeCurrency = clip(store.get('currency'), 3).toUpperCase() || 'USD';
+    const currency = order.currency.toUpperCase();
+    if (currency !== storeCurrency) {
+        return {
+            outcome: 'refused',
+            reason: `This order is in ${currency}, and the store sells in ${storeCurrency}. Ship it from ${channelLabel}.`
+        };
+    }
+    // Each line's product, found before the transaction (a query cannot run
+    // inside one) and checked again inside it, where the stock is decided.
+    const located = [];
+    for (const line of order.lines){
+        const productId = clip(line.productId, 200);
+        const variantId = clip(line.variantId, 200);
+        if (productId && variantId && DOC_ID.test(productId) && !/^__.*__$/.test(productId)) {
+            located.push({
+                productId,
+                variantId
+            });
+        } else {
+            located.push(line.sku ? await locateSku(firestore, order.hostId, line.sku) : null);
+        }
+    }
+    const nowMs = deps.now();
+    const placedAtMs = Number.isFinite(order.placedAtMs) && order.placedAtMs > 0 ? Math.min(order.placedAtMs, nowMs) : nowMs;
+    const productIds = [
+        ...new Set(located.filter((entry)=>entry !== null).map((entry)=>entry.productId))
+    ];
+    const crossings = [];
+    const result = await firestore.runTransaction(async (transaction)=>{
+        var _again_data, _counter_get;
+        const counterRef = hostRef.collection('counters').doc('orders');
+        const [again, counter, ...productSnaps] = await Promise.all([
+            transaction.get(orderRef),
+            transaction.get(counterRef),
+            ...productIds.map((productId)=>transaction.get(hostRef.collection('products').doc(productId)))
+        ]);
+        if (again.exists) return {
+            kind: 'already',
+            data: (_again_data = again.data()) != null ? _again_data : {}
+        };
+        const products = new Map();
+        productSnaps.forEach((snapshot, index)=>{
+            if (!snapshot.exists || snapshot.get('deletedAt')) return;
+            const lifted = CommerceModel.liftLegacyProduct(snapshot.data());
+            products.set(productIds[index], {
+                before: lifted,
+                current: lifted
+            });
+        });
+        const lineItems = [];
+        const shortfalls = [];
+        const unmatched = [];
+        const ledger = [];
+        order.lines.forEach((line, lineIndex)=>{
+            var _variant_options, _product_type;
+            const quantity = Number(line.quantity);
+            const place = located[lineIndex];
+            const held = place ? products.get(place.productId) : undefined;
+            const variant = held == null ? void 0 : held.current.variants.find((entry)=>entry.id === (place == null ? void 0 : place.variantId));
+            if (!place || !held || !variant) {
+                unmatched.push(lineIndex);
+                lineItems.push(_extends({
+                    productId: '',
+                    name: clip(line.name, 200) || clip(line.sku, 120) || 'Item'
+                }, line.sku ? {
+                    sku: clip(line.sku, 120)
+                } : {}, {
+                    productType: 'physical',
+                    quantity,
+                    unitAmountCents: Number(line.unitPriceCents)
+                }));
+                return;
+            }
+            const product = held.current;
+            const label = Object.values((_variant_options = variant.options) != null ? _variant_options : {}).filter(Boolean).join(' / ');
+            lineItems.push(_extends({
+                productId: place.productId,
+                variantId: variant.id,
+                name: product.name
+            }, label ? {
+                variantLabel: label
+            } : {}, variant.sku ? {
+                sku: variant.sku
+            } : line.sku ? {
+                sku: clip(line.sku, 120)
+            } : {}, {
+                productType: (_product_type = product.type) != null ? _product_type : 'physical',
+                quantity,
+                unitAmountCents: Number(line.unitPriceCents)
+            }));
+            if (variant.inventory == null) return;
+            const requested = -quantity;
+            const applied = CommerceModel.appliedVariantInventoryDelta(product, variant.id, requested);
+            const variants = CommerceModel.adjustVariantInventory(product, variant.id, requested);
+            held.current = _extends({}, product, {
+                variants
+            });
+            ledger.push(_extends({
+                productId: place.productId,
+                variantId: variant.id,
+                delta: requested
+            }, applied !== requested ? {
+                appliedDelta: applied
+            } : {}, {
+                reason: 'sale',
+                orderId,
+                source: channelLabel,
+                atMs: nowMs
+            }));
+            const short = applied - requested;
+            if (short > 0 && product.oversellPolicy !== 'backorder') {
+                var _ref, _variant_sku;
+                shortfalls.push({
+                    lineIndex,
+                    sku: (_ref = (_variant_sku = variant.sku) != null ? _variant_sku : line.sku) != null ? _ref : null,
+                    short
+                });
+            }
+        });
+        const number = Number((_counter_get = counter.get('next')) != null ? _counter_get : 1);
+        transaction.set(counterRef, {
+            next: number + 1
+        }, {
+            merge: true
+        });
+        for (const [productId, held] of products){
+            if (held.current === held.before) continue;
+            transaction.set(hostRef.collection('products').doc(productId), _extends({
+                variants: held.current.variants
+            }, CommerceModel.productStockFields(held.current), {
+                updatedAtMs: nowMs
+            }), {
+                merge: true
+            });
+            crossings.push({
+                before: held.before,
+                after: held.current
+            });
+        }
+        for (const row of ledger)transaction.set(hostRef.collection('inventoryAdjustments').doc(createResourceUid()), row);
+        const itemsCents = lineItems.reduce((sum, line)=>sum + line.unitAmountCents * line.quantity, 0);
+        const fees = cleanFees(order.fees);
+        const lines = order.lines.map((line, lineIndex)=>({
+                lineIndex,
+                externalLineId: clip(line.externalLineId, 200)
+            }));
+        const externalRef = clip(order.externalRef, 120) || clip(order.externalOrderId, 120);
+        const shipTo = address(order.shippingAddress);
+        const timeline = [
+            {
+                atMs: nowMs,
+                event: 'paid',
+                detail: `Sold on ${channelLabel}, order ${externalRef}`
+            },
+            ...unmatched.length ? [
+                {
+                    atMs: nowMs,
+                    event: 'line-unmatched',
+                    detail: `${unmatched.length} ${unmatched.length === 1 ? 'item matches' : 'items match'} no product's SKU, ` + 'so no stock was taken for ' + `${unmatched.length === 1 ? 'it' : 'them'}.`
+                }
+            ] : [],
+            ...shortfalls.length ? [
+                {
+                    atMs: nowMs,
+                    event: 'oversold',
+                    detail: `${shortfalls.reduce((sum, entry)=>sum + entry.short, 0)} sold beyond what was in stock.`
+                }
+            ] : []
+        ];
+        const data = CommerceModel.withOrderListFields(orderId, _extends({
+            number,
+            status: 'paid',
+            channel: 'marketplace',
+            channelSource: _extends({
+                channelId: order.channel.id,
+                channelLabel,
+                externalOrderId: clip(order.externalOrderId, 200),
+                externalRef,
+                lines,
+                currency,
+                taxRemittedByChannel: true,
+                fees: fees.fees,
+                feesTotalCents: fees.totalCents
+            }, order.handoff === 'courier' ? {
+                handoff: 'courier'
+            } : {}),
+            lineItems,
+            totals: {
+                itemsCents,
+                shippingCents: Number(order.shippingCents),
+                taxCents: Number(order.taxCents),
+                discountCents: Number(order.discountCents),
+                totalCents: Number(order.totalCents),
+                // Aglyn takes nothing from a sale another channel was paid for.
+                feeCents: 0
+            },
+            timeline,
+            livemode: order.testMode !== true,
+            customerName: clip(order.customerName, 200) || (shipTo == null ? void 0 : shipTo.name) || null,
+            customerEmail: null
+        }, shipTo ? {
+            shippingAddress: shipTo
+        } : {}, {
+            amountCents: Number(order.totalCents),
+            feeCents: 0,
+            createdAtMs: placedAtMs,
+            importedAtMs: nowMs,
+            createdAt: firebaseAdmin.firestore.FieldValue.serverTimestamp()
+        }));
+        transaction.set(orderRef, data);
+        // The event carries the order as stored, less the sentinel only Firestore can read.
+        const { createdAt: _sentinel } = data, eventOrder = _object_without_properties_loose(data, [
+            "createdAt"
+        ]);
+        stageOrderEvent(transaction, ORDER_PAID_EVENT, {
+            hostId: order.hostId,
+            orderId,
+            key: 'paid',
+            order: eventOrder
+        });
+        return {
+            kind: 'created',
+            number,
+            lines,
+            shortfalls,
+            unmatched
+        };
+    });
+    if (result.kind === 'already') return alreadyOutcome(orderId, result.data);
+    const displayRef = CommerceModel.formatOrderNumber({
+        number: result.number
+    }, orderId);
+    for (const crossing of crossings)alertLowStockCrossing(order.hostId, crossing.before, crossing.after);
+    const totalLabel = `${(Number(order.totalCents) / 100).toFixed(2)} ${currency}`;
+    const units = order.lines.reduce((sum, line)=>sum + Number(line.quantity), 0);
+    void notifyHostManagers(order.hostId, {
+        type: 'content.order',
+        title: `New ${channelLabel} order on {site} — ${totalLabel}`,
+        body: `Order ${displayRef} came in from ${channelLabel} (their order ${clip(order.externalRef, 120) || order.externalOrderId}): ` + `${units} item${units === 1 ? '' : 's'}, ${totalLabel}. ` + (order.handoff === 'courier' ? `Have it ready for the ${channelLabel} courier.` : `Ship it from the order here and the tracking goes back to ${channelLabel}.`),
+        link: `/${order.hostId}/products`
+    });
+    if (result.shortfalls.length) {
+        const short = result.shortfalls.reduce((sum, entry)=>sum + entry.short, 0);
+        void notifyHostManagers(order.hostId, {
+            type: 'content.lowStock',
+            title: `Oversold on ${channelLabel} — order ${displayRef}`,
+            body: `${channelLabel} sold ${short} unit${short === 1 ? '' : 's'} more than {site} had in stock ` + `(order ${displayRef}). Restock ${short === 1 ? 'it' : 'them'}, or cancel the items on ${channelLabel}.`,
+            link: `/${order.hostId}/products`
+        });
+    }
+    return {
+        outcome: 'created',
+        recordId: orderId,
+        displayRef,
+        lines: result.lines,
+        shortfalls: result.shortfalls,
+        unmatched: result.unmatched
+    };
+}
+function alreadyOutcome(recordId, data) {
+    const source = data['channelSource'];
+    return {
+        outcome: 'already',
+        recordId,
+        displayRef: CommerceModel.formatOrderNumber({
+            number: Number(data['number']) || undefined
+        }, recordId),
+        lines: Array.isArray(source == null ? void 0 : source.lines) ? source.lines : []
+    };
+}
+/**
+ * The channel canceled an order it sent: the order is cancelled here, and
+ * the units its sale took go back on the shelf — bounded by its own ledger,
+ * exactly as the console's cancel bounds them. Refuses once anything shipped.
+ */ export async function cancelChannelOrder(request, deps = defaultDeps()) {
+    var _ref, _ref1;
+    if (!DOC_ID.test(String((_ref = request == null ? void 0 : request.hostId) != null ? _ref : '')) || !DOC_ID.test(String((_ref1 = request == null ? void 0 : request.recordId) != null ? _ref1 : ''))) {
+        return {
+            outcome: 'no_such_record'
+        };
+    }
+    if (/^__.*__$/.test(request.hostId) || /^__.*__$/.test(request.recordId)) return {
+        outcome: 'no_such_record'
+    };
+    const firestore = deps.firestore();
+    const hostRef = firestore.collection('hosts').doc(request.hostId);
+    const orderRef = hostRef.collection('orders').doc(request.recordId);
+    const nowMs = deps.now();
+    const outcome = await firestore.runTransaction(async (transaction)=>{
+        var _snapshot_data, _order_fulfillments, _snapshot_data1;
+        const snapshot = await transaction.get(orderRef);
+        if (!snapshot.exists) return {
+            outcome: 'no_such_record'
+        };
+        const order = CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {});
+        if (order.channel !== 'marketplace') return {
+            outcome: 'not_cancellable',
+            status: order.status
+        };
+        if (order.status === 'cancelled') return {
+            outcome: 'already'
+        };
+        if (order.status !== 'paid' || ((_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : []).length) {
+            return {
+                outcome: 'not_cancellable',
+                status: order.status
+            };
+        }
+        const rows = await transaction.get(hostRef.collection('inventoryAdjustments').where('orderId', '==', request.recordId));
+        const caps = saleReleaseCaps(rows.docs.filter((row)=>row.get('reason') === 'sale'));
+        const { lines, products } = await resolveTrackedRestockLines(hostRef, order, (ref)=>transaction.get(ref));
+        const byProduct = new Map();
+        for (const line of capRestockLines(lines, caps)){
+            var _byProduct_get;
+            byProduct.set(line.productId, [
+                ...(_byProduct_get = byProduct.get(line.productId)) != null ? _byProduct_get : [],
+                line
+            ]);
+        }
+        let units = 0;
+        for (const [productId, productLines] of byProduct){
+            const product = products.get(productId);
+            if (!product) continue;
+            let variants = product.variants;
+            for (const line of productLines){
+                variants = CommerceModel.adjustVariantInventory({
+                    variants
+                }, line.variantId, line.quantity);
+                units += line.quantity;
+            }
+            transaction.update(hostRef.collection('products').doc(productId), _extends({
+                variants
+            }, CommerceModel.productStockFields(_extends({}, product, {
+                variants
+            })), {
+                updatedAtMs: nowMs
+            }));
+            for (const line of productLines){
+                transaction.set(hostRef.collection('inventoryAdjustments').doc(createResourceUid()), {
+                    productId,
+                    variantId: line.variantId,
+                    delta: line.quantity,
+                    reason: 'cancellation',
+                    orderId: request.recordId,
+                    atMs: nowMs
+                });
+            }
+        }
+        const reason = clip(request.reason, 200) || 'Canceled on its channel';
+        const patch = {
+            status: 'cancelled',
+            updatedAtMs: nowMs,
+            timeline: CommerceModel.appendOrderEvent(order, 'cancelled', units > 0 ? `${reason}. ${units} ${units === 1 ? 'unit' : 'units'} returned to stock.` : reason, nowMs)
+        };
+        transaction.update(orderRef, patch);
+        stageOrderEvent(transaction, ORDER_CANCELLED_EVENT, {
+            hostId: request.hostId,
+            orderId: request.recordId,
+            key: 'cancelled',
+            order: _extends({}, (_snapshot_data1 = snapshot.data()) != null ? _snapshot_data1 : {}, patch)
+        });
+        return {
+            outcome: 'cancelled',
+            restockedUnits: units
+        };
+    });
+    return outcome;
+}
+/** The channel's charges on a sale, recorded once it says; a later answer replaces an earlier one. */ export async function recordChannelOrderFees(request, deps = defaultDeps()) {
+    var _ref, _ref1;
+    if (!DOC_ID.test(String((_ref = request == null ? void 0 : request.hostId) != null ? _ref : '')) || !DOC_ID.test(String((_ref1 = request == null ? void 0 : request.recordId) != null ? _ref1 : ''))) return 'no_such_record';
+    if (/^__.*__$/.test(request.hostId) || /^__.*__$/.test(request.recordId)) return 'no_such_record';
+    const firestore = deps.firestore();
+    const orderRef = firestore.collection('hosts').doc(request.hostId).collection('orders').doc(request.recordId);
+    const fees = cleanFees(request.fees);
+    return firestore.runTransaction(async (transaction)=>{
+        const snapshot = await transaction.get(orderRef);
+        const source = snapshot.get('channelSource');
+        if (!snapshot.exists || snapshot.get('channel') !== 'marketplace' || !source) return 'no_such_record';
+        transaction.update(orderRef, {
+            channelSource: _extends({}, source, {
+                fees: fees.fees,
+                feesTotalCents: fees.totalCents
+            }),
+            updatedAtMs: deps.now()
+        });
+        return 'recorded';
+    });
+}
+export const commerceChannelOrders = {
+    importOrder: (order)=>importChannelOrder(order),
+    cancelOrder: (request)=>cancelChannelOrder(request),
+    recordFees: (request)=>recordChannelOrderFees(request),
+    // A courier's pickup and a channel's refund or adjustment (AGL-3644).
+    completeOrder: (request)=>completeChannelOrder(request),
+    recordRefund: (request)=>recordChannelOrderRefund(request)
+};
+
+//# sourceMappingURL=channel-orders.js.map