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

package/src/lib/server/fulfill-order.js

@@ -15,8 +15,56 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */ import * as CommerceModel from "../model/index.js";
+import { announcePluginShipment } from "@aglyn/aglyn/plugin-manager/plugin-shipment-records";
 import { createResourceUid } from "@aglyn/aglyn/server";
 import { firebaseAdmin } from "@aglyn/tenant-data-admin";
+import { notifyOrderBuyer } from "./order-notifications.js";
+import { ORDER_DELIVERED_EVENT, ORDER_FULFILLED_EVENT } from "../model/order-events.js";
+import { fulfillmentEventView, stageOrderEvent } from "./order-events.js";
+import { createHash } from "crypto";
+/** How long a carrier name and a tracking number may be, on every door. */ export const CARRIER_MAX = 40;
+export const TRACKING_NUMBER_MAX = 60;
+const URL_MAX = 2048;
+/** Trims a carrier and a tracking number to what every door stores. */ export function boundTracking(input) {
+    var _input_carrier, _input_trackingNumber;
+    return {
+        carrier: String((_input_carrier = input.carrier) != null ? _input_carrier : '').trim().slice(0, CARRIER_MAX),
+        trackingNumber: String((_input_trackingNumber = input.trackingNumber) != null ? _input_trackingNumber : '').trim().slice(0, TRACKING_NUMBER_MAX)
+    };
+}
+/** An https link or nothing: a stored link is rendered to buyers as an anchor. */ export function safeHttpsUrl(value) {
+    const text = String(value != null ? value : '').trim();
+    if (!text || text.length > URL_MAX) return undefined;
+    try {
+        const url = new URL(text);
+        return url.protocol === 'https:' ? url.toString() : undefined;
+    } catch (unused) {
+        return undefined;
+    }
+}
+/** The fulfillment id a keyed attempt writes, so a retry finds it. */ export function fulfillmentIdForKey(orderId, key) {
+    return `f-${createHash('sha256').update(`${orderId}:${key}`).digest('hex').slice(0, 20)}`;
+}
+/** The tracking keys a fulfillment stores: the number, the carrier and the link. */ function trackingFields(carrier, trackingNumber, explicitUrl) {
+    var _CommerceModel_trackingUrlFor;
+    const trackingUrl = explicitUrl != null ? explicitUrl : trackingNumber ? (_CommerceModel_trackingUrlFor = CommerceModel.trackingUrlFor(carrier, trackingNumber)) != null ? _CommerceModel_trackingUrlFor : undefined : undefined;
+    return _extends({}, carrier ? {
+        carrier
+    } : {}, trackingNumber ? {
+        trackingNumber
+    } : {}, trackingUrl ? {
+        trackingUrl
+    } : {});
+}
+/** The timeline's words for a shipment. */ function shipmentDetail(order, lines, partial, carrier, trackingNumber) {
+    const tracking = trackingNumber ? `${carrier || 'Shipped'} ${trackingNumber}` : '';
+    if (!partial) return tracking || 'Fulfilled';
+    const what = CommerceModel.describeFulfillmentLines(order, lines);
+    return tracking ? `${what} — ${tracking}` : `${what} shipped`;
+}
+function orderRefFor(hostId, orderId) {
+    return firebaseAdmin.app().firestore().collection('hosts').doc(hostId).collection('orders').doc(orderId);
+}
 /**
  * Record a shipment — the transaction, with NO authorization of any kind
  * (AGL-2461).
@@ -37,58 +85,322 @@ import { firebaseAdmin } from "@aglyn/tenant-data-admin";
  * trust in ways that have nothing in common (a Firebase uid in `memberRoles`
  * for the console; an org credential that owns the host for `/v1`).
  *
+ * QUANTITIES (AGL-3611). A shipment names units, not just lines, and the
+ * remaining count is computed from the transaction's own read, so two admins
+ * shipping the last 3 mugs at once cannot ship 6: the second meets
+ * `invalid_lines` with `over_fulfilled`. The resulting status is computed
+ * from the fulfillments (`statusFromFulfillments`) — `partially_fulfilled`
+ * until every shippable unit is covered — and the transition rule is re-asked
+ * only when the status actually moves, since a second partial shipment on a
+ * `partially_fulfilled` order changes nothing the table speaks to.
+ *
  * Every guarantee AGL-1819 built is inside the transaction and therefore
  * inherited by both callers: `canTransitionOrder` is re-asked under the write
  * so a stale caller cannot skip a state, the already-in-target case returns
- * without writing so a retry cannot append a duplicate shipment, and
- * `lineItemIds` and the timeline are computed from the transaction's OWN read
- * so a note landed from another tab survives.
- */ export async function recordOrderShipment({ hostId, orderId, to, carrier, trackingNumber }) {
+ * without writing so a retry cannot append a duplicate shipment, and the
+ * lines and the timeline are computed from the transaction's OWN read so a
+ * note landed from another tab survives.
+ */ export async function recordOrderShipment(request) {
+    var _result_fulfillment, _result_fulfillment1;
+    const { hostId, orderId, to } = request;
+    const { carrier, trackingNumber } = boundTracking(request);
+    const explicitUrl = safeHttpsUrl(request.trackingUrl);
+    const labelUrl = safeHttpsUrl(request.labelUrl);
     const firestore = firebaseAdmin.app().firestore();
-    const orderRef = firestore.collection('hosts').doc(hostId).collection('orders').doc(orderId);
-    return firestore.runTransaction(async (transaction)=>{
-        var _snapshot_data, _order_fulfillments, _order_lineItems;
+    const orderRef = orderRefFor(hostId, orderId);
+    const keyedId = request.idempotencyKey ? fulfillmentIdForKey(orderId, String(request.idempotencyKey).slice(0, 200)) : null;
+    const result = await firestore.runTransaction(async (transaction)=>{
+        var _snapshot_data, _request_lineItems, _order_fulfillments;
         const snapshot = await transaction.get(orderRef);
         if (!snapshot.exists) return {
             outcome: 'no_such_order'
         };
         const order = CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {});
-        // A redelivered click, or the second of two admins. Success because it
-        // IS the state the caller asked for — but nothing is written, so a
-        // retry cannot append a second copy of the same fulfillment.
-        if (order.status === to) return {
+        const atMs = Date.now();
+        if (to === 'delivered') {
+            if (order.status === 'delivered') return {
+                outcome: 'already'
+            };
+            if (!CommerceModel.canTransitionOrder(order.status, 'delivered')) {
+                return {
+                    outcome: 'blocked',
+                    from: order.status
+                };
+            }
+            const delivered = {
+                status: 'delivered',
+                updatedAtMs: atMs,
+                timeline: CommerceModel.appendOrderEvent(order, 'delivered', undefined, atMs)
+            };
+            transaction.update(orderRef, delivered);
+            stageOrderEvent(transaction, ORDER_DELIVERED_EVENT, {
+                hostId,
+                orderId,
+                key: 'delivered',
+                order: _extends({}, snapshot.data(), delivered)
+            });
+            return {
+                outcome: 'recorded',
+                status: 'delivered'
+            };
+        }
+        // A redelivered keyed attempt: the fulfillment it wrote is there.
+        if (keyedId) {
+            var _order_fulfillments1;
+            const existing = ((_order_fulfillments1 = order.fulfillments) != null ? _order_fulfillments1 : []).find((entry)=>entry.id === keyedId);
+            if (existing) return {
+                outcome: 'already',
+                fulfillment: existing
+            };
+        }
+        if (request.onceByTracking && trackingNumber) {
+            const same = CommerceModel.fulfillmentWithTracking(order, trackingNumber);
+            if (same) return {
+                outcome: 'already',
+                fulfillment: same
+            };
+        }
+        const named = ((_request_lineItems = request.lineItems) != null ? _request_lineItems : []).length > 0;
+        // A redelivered click, or the second of two admins, on a "fulfil
+        // everything". Success because it IS the state the caller asked for —
+        // but nothing is written, so a retry cannot append a second copy.
+        if (!named && order.status === 'fulfilled') return {
             outcome: 'already'
         };
-        if (!CommerceModel.canTransitionOrder(order.status, to)) {
+        if (order.status !== 'partially_fulfilled' && order.status !== 'fulfilled' && !CommerceModel.canTransitionOrder(order.status, 'partially_fulfilled') && !CommerceModel.canTransitionOrder(order.status, 'fulfilled')) {
+            return {
+                outcome: 'blocked',
+                from: order.status
+            };
+        }
+        let lines;
+        if (named) {
+            var _request_lineItems1;
+            const resolved = CommerceModel.resolveFulfillmentLines(order, (_request_lineItems1 = request.lineItems) != null ? _request_lineItems1 : []);
+            if (!('lines' in resolved)) {
+                return {
+                    outcome: 'invalid_lines',
+                    problem: resolved,
+                    message: CommerceModel.describeFulfillmentLinesProblem(resolved)
+                };
+            }
+            lines = resolved.lines;
+        } else {
+            lines = CommerceModel.remainingFulfillmentLines(order);
+            // Nothing physical left: a fulfil closes the digital and service
+            // lines instead, which is what it did before quantities existed.
+            if (lines.length === 0) {
+                lines = CommerceModel.orderLineFulfillmentStates(order).filter((state)=>state.remainingQuantity > 0).map((state)=>({
+                        lineItemId: state.lineItemId,
+                        quantity: state.remainingQuantity
+                    }));
+            }
+        }
+        const fulfillment = _extends({
+            id: keyedId != null ? keyedId : createResourceUid(),
+            lineItemIds: lines.map((entry)=>entry.lineItemId),
+            lines
+        }, trackingFields(carrier, trackingNumber, explicitUrl), labelUrl ? {
+            labelUrl
+        } : {}, request.labelRef ? {
+            labelRef: String(request.labelRef).slice(0, 80)
+        } : {}, {
+            status: 'active',
+            notify: request.notify !== false,
+            atMs
+        });
+        const fulfillments = [
+            ...(_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : [],
+            fulfillment
+        ];
+        let status = CommerceModel.statusFromFulfillments({
+            lineItems: order.lineItems,
+            fulfillments
+        });
+        // A fulfil with nothing left to cover still closes the order.
+        if (status === 'paid') status = 'fulfilled';
+        if (status !== order.status && !CommerceModel.canTransitionOrder(order.status, status)) {
             return {
                 outcome: 'blocked',
                 from: order.status
             };
         }
+        const shipped = {
+            status,
+            fulfillments,
+            // What a shipping tool's feed asks (AGL-3613): which orders changed.
+            updatedAtMs: atMs,
+            timeline: CommerceModel.appendOrderEvent(order, status, shipmentDetail(order, lines, status === 'partially_fulfilled', carrier, trackingNumber), atMs)
+        };
+        transaction.update(orderRef, shipped);
+        // Once per shipment (AGL-3611), in the same write, so the event exists
+        // exactly when the shipment does.
+        stageOrderEvent(transaction, ORDER_FULFILLED_EVENT, {
+            hostId,
+            orderId,
+            key: fulfillment.id,
+            order: _extends({}, snapshot.data(), shipped),
+            extra: {
+                fulfillment: fulfillmentEventView(order, fulfillment)
+            }
+        });
+        return {
+            outcome: 'recorded',
+            status,
+            fulfillment
+        };
+    });
+    // The BUYER hears about it (AGL-3610): shipped with the tracking link, or
+    // delivered. Once per shipment, after the write, and never fails the
+    // shipment — see `order-notifications.ts`. A retry returns `already` above
+    // and never reaches here. A merchant who unticked "Notify customer"
+    // (AGL-3611) recorded the shipment with `notify: false`, and nobody is told.
+    // Every shipment recorded, by any door, is announced (AGL-3612), so a
+    // plugin that follows parcels can follow one typed in by hand too.
+    if (result.outcome === 'recorded' && ((_result_fulfillment = result.fulfillment) == null ? void 0 : _result_fulfillment.trackingNumber)) {
+        await announcePluginShipment(_extends({
+            hostId,
+            recordId: orderId,
+            shipmentId: result.fulfillment.id
+        }, result.fulfillment.carrier ? {
+            carrier: result.fulfillment.carrier
+        } : {}, {
+            trackingNumber: result.fulfillment.trackingNumber
+        }, request.labelRef ? {
+            labelRef: request.labelRef
+        } : {}));
+    }
+    if (result.outcome === 'recorded' && ((_result_fulfillment1 = result.fulfillment) == null ? void 0 : _result_fulfillment1.notify) !== false) {
+        await notifyOrderBuyer({
+            hostId,
+            orderId
+        }, to === 'fulfilled' ? 'shipped' : 'delivered', result.fulfillment ? {
+            fulfillmentId: result.fulfillment.id
+        } : {});
+    }
+    return result;
+}
+/**
+ * Corrects the tracking on one fulfillment (AGL-3611): a mistyped number, a
+ * carrier swapped, a label bought after the parcel was recorded. Moves no
+ * status and no stock. A cancelled fulfillment is history and is refused.
+ */ export async function updateFulfillmentTracking(request) {
+    const { carrier, trackingNumber } = boundTracking(request);
+    const explicitUrl = safeHttpsUrl(request.trackingUrl);
+    const orderRef = orderRefFor(request.hostId, request.orderId);
+    return firebaseAdmin.app().firestore().runTransaction(async (transaction)=>{
+        var _snapshot_data, _order_fulfillments, _order_fulfillments1, _current_carrier, _next_carrier, _current_trackingNumber, _next_trackingNumber, _current_trackingUrl, _next_trackingUrl, _order_fulfillments2;
+        const snapshot = await transaction.get(orderRef);
+        if (!snapshot.exists) return {
+            outcome: 'no_such_order'
+        };
+        const order = CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {});
+        const index = ((_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : []).findIndex((entry)=>entry.id === request.fulfillmentId);
+        if (index < 0) return {
+            outcome: 'no_such_fulfillment'
+        };
+        const current = ((_order_fulfillments1 = order.fulfillments) != null ? _order_fulfillments1 : [])[index];
+        if (!CommerceModel.fulfillmentIsActive(current) || ![
+            'paid',
+            'partially_fulfilled',
+            'fulfilled',
+            'delivered'
+        ].includes(order.status)) {
+            return {
+                outcome: 'locked',
+                from: CommerceModel.fulfillmentIsActive(current) ? order.status : 'cancelled'
+            };
+        }
         const atMs = Date.now();
-        const patch = to === 'fulfilled' ? {
-            status: 'fulfilled',
-            fulfillments: [
-                ...(_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : [],
-                _extends({
-                    id: createResourceUid(),
-                    lineItemIds: ((_order_lineItems = order.lineItems) != null ? _order_lineItems : []).map((_line, index)=>index)
-                }, carrier ? {
-                    carrier
-                } : {}, trackingNumber ? {
-                    trackingNumber
-                } : {}, {
-                    atMs
-                })
-            ],
-            timeline: CommerceModel.appendOrderEvent(order, 'fulfilled', trackingNumber ? `${carrier || 'Shipped'} ${trackingNumber}` : 'Fulfilled', atMs)
-        } : {
-            status: 'delivered',
-            timeline: CommerceModel.appendOrderEvent(order, 'delivered', undefined, atMs)
+        const next = _extends({}, current, {
+            updatedAtMs: atMs
+        });
+        delete next.carrier;
+        delete next.trackingNumber;
+        delete next.trackingUrl;
+        Object.assign(next, trackingFields(carrier, trackingNumber, explicitUrl));
+        if (((_current_carrier = current.carrier) != null ? _current_carrier : '') === ((_next_carrier = next.carrier) != null ? _next_carrier : '') && ((_current_trackingNumber = current.trackingNumber) != null ? _current_trackingNumber : '') === ((_next_trackingNumber = next.trackingNumber) != null ? _next_trackingNumber : '') && ((_current_trackingUrl = current.trackingUrl) != null ? _current_trackingUrl : '') === ((_next_trackingUrl = next.trackingUrl) != null ? _next_trackingUrl : '')) {
+            return {
+                outcome: 'already',
+                fulfillment: current
+            };
+        }
+        const fulfillments = [
+            ...(_order_fulfillments2 = order.fulfillments) != null ? _order_fulfillments2 : []
+        ];
+        fulfillments[index] = next;
+        transaction.update(orderRef, {
+            fulfillments,
+            updatedAtMs: atMs,
+            timeline: CommerceModel.appendOrderEvent(order, 'tracking-updated', trackingNumber ? `${carrier || 'Tracking'} ${trackingNumber}` : 'Tracking removed', atMs)
+        });
+        return {
+            outcome: 'updated',
+            status: order.status,
+            fulfillment: next
         };
-        transaction.update(orderRef, patch);
+    });
+}
+/**
+ * Cancels one fulfillment (AGL-3611): the parcel was never handed over, or was
+ * recorded against the wrong items. Its units go back to unfulfilled and the
+ * order's status is recomputed from what remains — `fulfilled` can step back
+ * to `partially_fulfilled` or `paid`.
+ *
+ * That step back is NOT an `ORDER_TRANSITIONS` edge, on purpose: the table
+ * says what may happen to an order going forward, and admitting
+ * `fulfilled → paid` there would open it to every other caller. This is the one writer
+ * that may take it, and only from a status whose fulfillments are still open
+ * (`orderFulfillmentsEditable`): a delivered, refunded or cancelled order's
+ * shipments are what happened and stay that way.
+ */ export async function cancelOrderFulfillment(request) {
+    const orderRef = orderRefFor(request.hostId, request.orderId);
+    return firebaseAdmin.app().firestore().runTransaction(async (transaction)=>{
+        var _snapshot_data, _order_fulfillments, _order_fulfillments1, _order_fulfillments2;
+        const snapshot = await transaction.get(orderRef);
+        if (!snapshot.exists) return {
+            outcome: 'no_such_order'
+        };
+        const order = CommerceModel.liftLegacyOrder((_snapshot_data = snapshot.data()) != null ? _snapshot_data : {});
+        const index = ((_order_fulfillments = order.fulfillments) != null ? _order_fulfillments : []).findIndex((entry)=>entry.id === request.fulfillmentId);
+        if (index < 0) return {
+            outcome: 'no_such_fulfillment'
+        };
+        const current = ((_order_fulfillments1 = order.fulfillments) != null ? _order_fulfillments1 : [])[index];
+        if (!CommerceModel.fulfillmentIsActive(current)) return {
+            outcome: 'already',
+            fulfillment: current
+        };
+        if (!CommerceModel.orderFulfillmentsEditable(order)) {
+            return {
+                outcome: 'locked',
+                from: order.status
+            };
+        }
+        const atMs = Date.now();
+        const next = _extends({}, current, {
+            status: 'cancelled',
+            cancelledAtMs: atMs,
+            updatedAtMs: atMs
+        });
+        const fulfillments = [
+            ...(_order_fulfillments2 = order.fulfillments) != null ? _order_fulfillments2 : []
+        ];
+        fulfillments[index] = next;
+        const status = CommerceModel.statusFromFulfillments({
+            lineItems: order.lineItems,
+            fulfillments
+        });
+        transaction.update(orderRef, {
+            status,
+            fulfillments,
+            updatedAtMs: atMs,
+            timeline: CommerceModel.appendOrderEvent(order, 'fulfillment-cancelled', CommerceModel.describeFulfillmentLines(order, CommerceModel.fulfillmentLineQuantities(order, current)) + ' back to unfulfilled', atMs)
+        });
         return {
-            outcome: 'recorded'
+            outcome: 'updated',
+            status,
+            fulfillment: next
         };
     });
 }
@@ -120,10 +432,11 @@ import { firebaseAdmin } from "@aglyn/tenant-data-admin";
  * is an `update()` naming only status, fulfillments and timeline, and the
  * question is still the merchant's to answer.
  *
- * NO NOTIFICATION EITHER, matching the client write this replaces: the
+ * NO MANAGER NOTIFICATION, matching the client write this replaces: the
  * merchant fulfilled the order themselves, and `notifyHostManagers` would
  * tell them what they just did. (`supplier-update.ts` notifies because there
- * the SUPPLIER acted and the merchant is the one who needs to hear it.)
+ * the SUPPLIER acted and the merchant is the one who needs to hear it.) The
+ * BUYER is told, through `recordOrderShipment` (AGL-3610).
  *
  * ONCE. A retried request — a lost response, a second click — finds the order
  * already in the target status and returns success WITHOUT writing: appending
@@ -140,7 +453,7 @@ import { firebaseAdmin } from "@aglyn/tenant-data-admin";
  * Role gate: `admin` and `editor`, the role the client write already had
  * under the rules' host catch-all — same reasoning as `cancel-order.ts`.
  */ export const fulfillOrderHandler = async (req, res)=>{
-    var _req_headers_authorization, _req_body, _body_hostId, _body_orderId, _body_to, _body_carrier, _body_trackingNumber;
+    var _req_headers_authorization, _req_body, _body_hostId, _body_orderId, _body_action, _body_fulfillmentId, _body_to, _ref, _req_headers_idempotencykey;
     if (req.method !== 'POST') {
         return res.status(405).json({
             error: 'Method not allowed'
@@ -166,15 +479,33 @@ import { firebaseAdmin } from "@aglyn/tenant-data-admin";
             error: 'Missing hostId or orderId'
         });
     }
+    // Two more acts on one fulfillment (AGL-3611): correct its tracking, or
+    // cancel it. Same route, same role gate; neither moves stock or money.
+    const action = String((_body_action = body.action) != null ? _body_action : '');
+    const fulfillmentId = String((_body_fulfillmentId = body.fulfillmentId) != null ? _body_fulfillmentId : '').slice(0, 100);
+    if ((action === 'update-tracking' || action === 'cancel-fulfillment') && !fulfillmentId) {
+        return res.status(400).json({
+            error: 'Missing fulfillmentId'
+        });
+    }
     const to = String((_body_to = body.to) != null ? _body_to : '');
-    if (to !== 'fulfilled' && to !== 'delivered') {
+    if (!action && to !== 'fulfilled' && to !== 'delivered') {
         // Deliberately NOT a generic transition endpoint — see the header.
         return res.status(400).json({
             error: 'to must be fulfilled or delivered'
         });
     }
-    const carrier = String((_body_carrier = body.carrier) != null ? _body_carrier : '').slice(0, 40);
-    const trackingNumber = String((_body_trackingNumber = body.trackingNumber) != null ? _body_trackingNumber : '').slice(0, 60);
+    if (action && action !== 'update-tracking' && action !== 'cancel-fulfillment') {
+        return res.status(400).json({
+            error: 'Unknown action'
+        });
+    }
+    const { carrier, trackingNumber } = boundTracking(body);
+    const lineItems = Array.isArray(body.lineItems) ? body.lineItems.slice(0, 500).map((entry)=>({
+            lineItemId: Number(entry == null ? void 0 : entry.lineItemId),
+            quantity: Number(entry == null ? void 0 : entry.quantity)
+        })) : undefined;
+    const idempotencyKey = String((_ref = (_req_headers_idempotencykey = req.headers['idempotency-key']) != null ? _req_headers_idempotencykey : body.idempotencyKey) != null ? _ref : '').slice(0, 200);
     try {
         var _hostSnapshot_get;
         const decoded = await firebaseAdmin.app().auth().verifyIdToken(idToken);
@@ -192,33 +523,104 @@ import { firebaseAdmin } from "@aglyn/tenant-data-admin";
                 error: 'Not permitted'
             });
         }
+        if (action) {
+            const change = action === 'update-tracking' ? await updateFulfillmentTracking({
+                hostId,
+                orderId,
+                fulfillmentId,
+                carrier,
+                trackingNumber,
+                trackingUrl: body.trackingUrl
+            }) : await cancelOrderFulfillment({
+                hostId,
+                orderId,
+                fulfillmentId
+            });
+            // A corrected tracking number is a parcel to follow (AGL-3612).
+            if (change.outcome === 'updated' && action === 'update-tracking' && change.fulfillment.trackingNumber) {
+                await announcePluginShipment(_extends({
+                    hostId,
+                    recordId: orderId,
+                    shipmentId: change.fulfillment.id
+                }, change.fulfillment.carrier ? {
+                    carrier: change.fulfillment.carrier
+                } : {}, {
+                    trackingNumber: change.fulfillment.trackingNumber
+                }));
+            }
+            if (change.outcome === 'no_such_order') return res.status(404).json({
+                error: 'Unknown order'
+            });
+            if (change.outcome === 'no_such_fulfillment') {
+                return res.status(404).json({
+                    error: 'That shipment is no longer on this order'
+                });
+            }
+            if (change.outcome === 'locked') {
+                return res.status(409).json({
+                    error: change.from === 'cancelled' ? 'That shipment was canceled and can no longer be edited' : `Shipments on an order in "${change.from}" can no longer be changed`
+                });
+            }
+            return res.status(200).json(_extends({
+                ok: true
+            }, change.outcome === 'already' ? {
+                already: true
+            } : {
+                status: change.status
+            }, {
+                fulfillment: change.fulfillment
+            }));
+        }
         // Authorized above; the shipment itself is the shared transaction. The
-        // wire shape below is unchanged — the console dialog branches on `ok`,
-        // `already` and the 409's `error` string, and this route's contract is
-        // with that dialog, not with the registry's vocabulary.
-        const outcome = await recordOrderShipment({
+        // console dialog branches on `ok`, `already` and the 409's `error`
+        // string, and this route's contract is with that dialog, not with the
+        // registry's vocabulary.
+        const outcome = await recordOrderShipment(_extends({
             hostId,
             orderId,
             to,
             carrier,
             trackingNumber
-        });
+        }, lineItems ? {
+            lineItems
+        } : {}, body.trackingUrl ? {
+            trackingUrl: String(body.trackingUrl)
+        } : {}, body.labelUrl ? {
+            labelUrl: String(body.labelUrl)
+        } : {}, body.notify === false ? {
+            notify: false
+        } : {}, idempotencyKey ? {
+            idempotencyKey
+        } : {}));
         if (outcome.outcome === 'no_such_order') {
             return res.status(404).json({
                 error: 'Unknown order'
             });
         }
+        if (outcome.outcome === 'invalid_lines') {
+            return res.status(outcome.problem.problem === 'over_fulfilled' ? 409 : 400).json({
+                error: outcome.message
+            });
+        }
         if (outcome.outcome === 'blocked') {
             return res.status(409).json({
                 error: to === 'delivered' ? `Orders in "${outcome.from}" cannot be marked delivered` : `Orders in "${outcome.from}" cannot be fulfilled`
             });
         }
-        return res.status(200).json(outcome.outcome === 'already' ? {
+        if (outcome.outcome === 'already') {
+            return res.status(200).json(_extends({
+                ok: true,
+                already: true
+            }, outcome.fulfillment ? {
+                fulfillment: outcome.fulfillment
+            } : {}));
+        }
+        return res.status(200).json(_extends({
             ok: true,
-            already: true
-        } : {
-            ok: true
-        });
+            status: outcome.status
+        }, outcome.fulfillment ? {
+            fulfillment: outcome.fulfillment
+        } : {}));
     } catch (error) {
         // Nothing landed — the transaction is all-or-nothing — so the order is
         // still where it was and the merchant can try again.