@peabody-soft/mbs-model-ts 1.3.0 → 1.5.0

package/dist/ProtoMap.js

@@ -126,25 +126,31 @@ export function getBusinessResponseAttachmentBaseUrlExpiry(response) {
 // One order as its own blob, for a caller holding a message rather than a whole response. The
 // payload is the only thing that says which a message is, so one carrying the other is refused
 // here rather than stored where a read would never find it.
-export function orderToBlob(order) {
+// heldETag is what the container holds that order at, and null when it holds none - see messageToBlob.
+export function orderToBlob(order, heldETag) {
     if (order.payload.oneofKind !== "salesOrder")
         throw new InvalidArgumentException("That message carries no sales order, so it is not an order");
-    return messageToBlob(order);
+    return messageToBlob(order, heldETag);
 }
 // Whether a message carries party preferences. Here rather than at a call site, because reading a
 // field of a message is this file's job.
 export function isPartyPreferencesMessage(message) {
     return message.payload.oneofKind === "partyPreferences";
 }
-// When a message was last written, which is what the store versions a blob by and so the field
-// to compare two copies of one thing on.
+// When a message was last written: the field to compare two copies of one thing on when they are
+// held at different ids, and so have no version to be compared by.
 export function getMessageUpdatedAt(message) {
     return getEntity(message.entity).updatedAt;
 }
-export function partyPreferencesToBlob(partyPreferences) {
+// Here rather than at a call site, because reading a field of a message is this file's job.
+export function getMessageId(message) {
+    return getEntity(message.entity).id;
+}
+// heldETag as for orderToBlob
+export function partyPreferencesToBlob(partyPreferences, heldETag) {
     if (partyPreferences.payload.oneofKind !== "partyPreferences")
         throw new InvalidArgumentException("That message carries no party preferences");
-    return messageToBlob(partyPreferences);
+    return messageToBlob(partyPreferences, heldETag);
 }
 // The response the blobs of a business container make up: everything cached for that business, in
 // the shape the call that brought it returned, and null when they hold nothing of it yet.
@@ -235,10 +241,13 @@ export function orderMessagesFromBlobs(blobs) {
 // which caller it was sent to - see THE MESSAGES OF A BUSINESS ARE NOT PUBLIC.
 // Split out of partyPreferencesMessageFromBlobs so a caller already holding a response's messages
 // - such as Model.businessSyncIn folding the anonymous container in - can settle its cart without
-// asking the store for the same blobs again.
+// asking the store for the same blobs again. buildBusiness takes the cart it shows from here too, so
+// that the cart shown, the cart amended and the cart carried over a sign in are always one message.
 export function partyPreferencesMessageFromMessages(messages) {
     let result = null;
     for (const message of messages) {
+        if (isDeletedEntity(getEntity(message.entity)))
+            continue; // A tombstone is not a cart, whatever it carries
         if (message.payload.oneofKind !== "partyPreferences")
             continue;
         if (result === null ||
@@ -254,11 +263,20 @@ export function partyPreferencesMessageFromBlobs(blobs) {
 }
 // #endregion
 // #region Requests and credentials
-// The request that asks for everything changed since these cursors.
+// The request that asks for everything changed since these cursors, about the business it is given: a bigint
+// is the entity id of the Business, which a caller that has read it before has, and a string is its
+// url friendly businessId, which is all that one reading it for the first time has.
 // attachmentBaseUrlExpiry is not a cursor, just the expiry of the url already held, sent back unchanged (zero when none is held).
-export function buildBusinessSyncOutRequest(businessId, syncInState, attachmentBaseUrlExpiry) {
+export function buildBusinessSyncOutRequest(business, syncInState, attachmentBaseUrlExpiry) {
+    return createBusinessSyncOutRequest(typeof business === "bigint"
+        ? { oneofKind: "businessEntityId", businessEntityId: business }
+        : { oneofKind: "businessId", businessId: business }, syncInState, attachmentBaseUrlExpiry);
+}
+// Takes the business as the request holds it, so that the request after a page can name it exactly as
+// the one before did, whichever way that was
+function createBusinessSyncOutRequest(business, syncInState, attachmentBaseUrlExpiry) {
     return proto_BusinessSyncOutRequest.create({
-        businessId: businessId,
+        business: business,
         businessUpdateNumber: syncInState.getUpdateNumber(proto_Constants.BUSINESS_ENTITY_TYPE_ID),
         attachmentUpdateNumber: syncInState.getUpdateNumber(proto_Constants.ATTACHMENT_ENTITY_TYPE_ID),
         attachmentBaseUrlExpiry: attachmentBaseUrlExpiry,
@@ -267,22 +285,45 @@ export function buildBusinessSyncOutRequest(businessId, syncInState, attachmentB
         itemUpdateNumber: syncInState.getUpdateNumber(proto_Constants.ITEM_ENTITY_TYPE_ID),
     });
 }
-// The first request of a business sync in, with cursors raised from what is already cached rather
-// than sent from zero - the same way nextBusinessSyncOutRequest raises them from a page just
-// arrived, but from a response already held.
-export function buildBusinessSyncOutRequestFromCache(businessId, cached) {
-    const cursors = new SyncState(SyncKeys.BUSINESS_SYNC_IN);
-    if (cached !== null)
-        for (const entity of getBusinessResponseEntities(cached))
-            cursors.raiseUpdateNumber(entity.entityTypeId, entity.updateNumber);
-    return buildBusinessSyncOutRequest(businessId, cursors, getBusinessResponseAttachmentBaseUrlExpiry(cached));
+// How far a container has been read, as the blobs that keep it: one for each key that a page has
+// moved, at an id of its own - see Ids.getSyncCursorBlobId. The cursor is the eTag and there is
+// nothing else to keep, so there are no bytes. A cursor is therefore only ever raised: the store
+// refuses a blob that is not the greater, so a cursor is not lowered by a page that is stale or sent
+// again, nor by another tab that wrote at the same time.
+export function cursorsToBlobs(cursors, movedKeys) {
+    const blobs = [];
+    for (const key of movedKeys)
+        blobs.push({
+            id: Ids.getSyncCursorBlobId(key),
+            eTag: cursors.getUpdateNumber(key),
+            bytes: NO_BYTES,
+        });
+    return blobs;
+}
+// The cursors a container holds, from the blobs it holds at the cursor ids of keys, in the order of
+// keys and null where it holds none: a state at zero for one that was never read, or was filled by a
+// version that did not keep them, which asks for everything again and is sent it again, a cost in
+// bandwidth and no more: the store keeps a blob only when its eTag is greater.
+export function cursorsFromBlobs(keys, blobs) {
+    const cursors = new SyncState(keys);
+    for (const [index, key] of keys.entries()) {
+        const eTag = blobs[index]?.eTag ?? null;
+        if (eTag !== null)
+            cursors.raiseUpdateNumber(key, eTag);
+    }
+    return cursors;
+}
+// Raises these cursors to what a page of a business read brought, tombstones included, and answers
+// the keys that moved. The only thing that moves them: what this client pushed does not.
+export function raiseBusinessCursors(cursors, response) {
+    return raiseCursorsFrom(cursors, getBusinessResponseEntities(response));
 }
 // The request that pushes back what this customer has changed. Messages are the only entity type a
 // storefront may push, and one request is one batch: an order and the cart it emptied go together,
 // so that a customer can never be left holding an order and a cart still full of the same items.
-// messageUpdateNumber is the cursor of what this customer already holds cached, so the response
-// brings back only what has changed since - this push's own messages, under the update numbers the
-// server assigns them, and anything else of theirs a later sync out would also pick up.
+// messageUpdateNumber is how far the reads of this customer's container have got with messages, and
+// not what a push has since stored: the response is this push's own messages, under the update
+// numbers the server assigns them, and nothing else.
 export function buildBusinessSyncInRequest(messageUpdateNumber, messages) {
     return proto_BusinessSyncInRequest.create({
         messageUpdateNumber: messageUpdateNumber,
@@ -290,7 +331,7 @@ export function buildBusinessSyncInRequest(messageUpdateNumber, messages) {
     });
 }
 // The messages a sync in response carried - this push's own, now bearing the update numbers the
-// server assigned them, and anything else of this customer's that changed since the cursor sent.
+// server assigned them, and no others. Nothing is to be made of those numbers: they are not how far a read has got.
 export function getSyncInResponseMessages(response) {
     return response.messages;
 }
@@ -309,14 +350,9 @@ export function buildProfileSyncOutRequest(syncInState, joinBusinessId = BigInt(
         joinBusinessId: joinBusinessId,
     });
 }
-// The same, seeded from what the profile container already holds cached rather than from a fresh
-// SyncState - see buildBusinessSyncOutRequestFromCache, which this mirrors.
-export function buildProfileSyncOutRequestFromCache(cached, joinBusinessId = BigInt(proto_Constants.ENTITY_ID_NULL)) {
-    const cursors = new SyncState(SyncKeys.PROFILE_SYNC_IN);
-    if (cached !== null)
-        for (const entity of getProfileResponseEntities(cached))
-            cursors.raiseUpdateNumber(entity.entityTypeId, entity.updateNumber);
-    return buildProfileSyncOutRequest(cursors, joinBusinessId);
+// The same for a profile read
+export function raiseProfileCursors(cursors, response) {
+    return raiseCursorsFrom(cursors, getProfileResponseEntities(response));
 }
 // The user a sign up asks the server to create, as CreateUserRequest.user. Built from the domain
 // object rather than carrying one of its own: this user has no entity yet - the server assigns id,
@@ -362,11 +398,63 @@ export function hasJoinedBusinessLink(joinBusinessId, response) {
 export function hasJoinedBusiness(joinBusinessId, response) {
     if (joinBusinessId === BigInt(proto_Constants.ENTITY_ID_NULL))
         return false;
+    // A tombstone of the business is not the business, which is the whole of what a join is answered with it for
     for (const business of response.businesses)
-        if (getEntity(business.entity).id === joinBusinessId)
+        if (getEntity(business.entity).id === joinBusinessId &&
+            !isDeletedEntity(getEntity(business.entity)))
             return true;
     return false;
 }
+// The country of the business a response holds, ISO 3166-1 numeric, or undefined when it holds none. A
+// tombstone is not a business and has no country: it is only its header, so the zero it carries must
+// not be taken for one - a cart's taxes are raw codes, which mean something only within a country.
+export function getBusinessResponseCountryCode(response) {
+    const business = response?.business;
+    if (business === undefined || isDeletedEntity(getEntity(business.entity)))
+        return undefined;
+    return business.countryCode;
+}
+// The entity id of the business a response holds, or null when it holds none - which is a response
+// with no business in it, or one with a tombstone, a deleted business being no business to name. Once
+// a business has been read, this is what every later request names it by: its entity id is stable
+// and a url friendly id is only how it was first found.
+export function getBusinessResponseBusinessEntityId(response) {
+    const entity = response?.business?.entity;
+    if (entity === undefined || isDeletedEntity(entity))
+        return null;
+    return entity.id;
+}
+// The url friendly id of the business a response holds - the one that a business is found by, which is not its entity id
+// - or null when it holds none, or only a tombstone, which is only a header and has no business id to tell.
+export function getBusinessResponseBusinessId(response) {
+    const business = response?.business;
+    if (business === undefined || isDeletedEntity(getEntity(business.entity)))
+        return null;
+    return business.businessId;
+}
+// Whether the general settings that a response holds say that the business has turned online shopping on. Settings that
+// are not there - the business has made none, or has deleted them, or this has not read them yet - say that it has not, as
+// settings that say so do. That is what a storefront is told by a business that has not turned it on: the server sends it
+// whatever it says, and a client decides, from what it holds once it has read everything it was sent.
+export function isBusinessResponseOnlineShoppingOn(response) {
+    if (response === null)
+        return false;
+    return getGeneralSettingsOf(response)?.onlineShoppingEnabled ?? false;
+}
+// The general settings that a response holds, as the wire carries them, or undefined when it holds none: the one public
+// configuration that carries them, unless it has been deleted, which is only its header. What is read of the settings - the
+// business that is built from them, and whether it is open - is read from here, so that the two cannot be about different ones.
+function getGeneralSettingsOf(response) {
+    let settings;
+    for (const configuration of response.configurations) {
+        if (isDeletedEntity(getEntity(configuration.entity)))
+            continue;
+        if (configuration.data.oneofKind !== "generalSettings")
+            continue; // Not a configuration this library understands
+        settings = configuration.data.generalSettings;
+    }
+    return settings;
+}
 // The credentials of one call, as the wire carries them. An absent token is left off the message
 // rather than sent empty, because the protocol tells the two apart.
 export function buildAuthTokens(authTokens) {
@@ -470,7 +558,7 @@ export function nextBusinessSyncOutRequest(request, response) {
         return null;
     // A page that renewed the url means a later one is now held; otherwise what was sent still stands
     const renewedExpiry = getBusinessResponseAttachmentBaseUrlExpiry(response);
-    return buildBusinessSyncOutRequest(request.businessId, cursors, renewedExpiry === 0n ? request.attachmentBaseUrlExpiry : renewedExpiry);
+    return createBusinessSyncOutRequest(request.business, cursors, renewedExpiry === 0n ? request.attachmentBaseUrlExpiry : renewedExpiry);
 }
 // The same for a profile read. Any joinBusinessId the first request carried is deliberately left
 // off the ones that follow: a join is done once, by the call that asked for it.
@@ -512,6 +600,16 @@ function profileResponseEntityCount(response) {
         response.businessLinks.length +
         response.businesses.length);
 }
+// Raises the cursors the entities of one page advance, and answers the keys that moved - one for
+// all the entities of a table, however many of them raised it. A tombstone counts exactly as a value
+// does, as it does for raiseCursor.
+function raiseCursorsFrom(cursors, entities) {
+    const movedKeys = new Set();
+    for (const entity of entities)
+        if (cursors.raiseUpdateNumber(entity.entityTypeId, entity.updateNumber))
+            movedKeys.add(SyncKeys.keyOf(entity.entityTypeId));
+    return movedKeys;
+}
 // Raises the cursor one entity advances, and answers whether it moved. A tombstone counts exactly
 // as a value does - skipping one would have the server send it again for ever.
 function raiseCursor(cursors, entity) {
@@ -549,6 +647,9 @@ export function buildBusiness(response) {
         return null;
     const business = businessFromProto(businessProto);
     const updatableBusiness = business;
+    // A tax travels as its raw code, which means something only within the business's country - so
+    // every tax below is read against this one
+    const countryCode = businessProto.countryCode;
     // Resolved once here and handed to every Photo built below, since a photo takes the base url in
     // effect when it is built rather than looking one up later - see the comment on Photo's constructor.
     const attachmentBaseUrlProto = response.attachmentBaseUrl;
@@ -567,13 +668,9 @@ export function buildBusiness(response) {
             owned.push(attachment);
     }
     // The settings, unwrapped from the one public configuration that carries them
-    for (const configuration of response.configurations) {
-        if (isDeletedEntity(getEntity(configuration.entity)))
-            continue;
-        if (configuration.data.oneofKind !== "generalSettings")
-            continue; // Not a configuration this library understands
-        updatableBusiness.settings = generalSettingsFromProto(configuration.data.generalSettings);
-    }
+    const generalSettings = getGeneralSettingsOf(response);
+    if (generalSettings !== undefined)
+        updatableBusiness.settings = generalSettingsFromProto(generalSettings, countryCode);
     // The photos of the store itself
     updatableBusiness.photos = takePhotos(attachmentsByOwner, business.id, attachmentBaseUrl);
     // Prices, by the package each applies to. Only the MeraBills Online list is this storefront's -
@@ -613,8 +710,9 @@ export function buildBusiness(response) {
             siblings.push(pkg);
     }
     // Products, built with their photos and their buyable packages, and parented to the business
-    // (not their category, which only groups them). A product that is not buyable - disabled, or
-    // left with no buyable package by the filtering above - is left out for the same reason.
+    // (not their category, which only groups them). A product that is not buyable - disabled, sold
+    // only offline (the server sends those, flagged), or left with no buyable package by the filtering
+    // above - is left out for the same reason.
     const products = [];
     for (const productProto of response.products) {
         if (isDeletedItem(productProto.item))
@@ -622,11 +720,11 @@ export function buildBusiness(response) {
         const productId = getItemId(productProto.item);
         const packages = packagesByProduct.get(productId) ?? [];
         const productPhotos = takePhotos(attachmentsByOwner, productId, attachmentBaseUrl);
-        const product = productFromProto(productProto, productPhotos, Object.freeze([...packages]));
+        const product = productFromProto(productProto, productPhotos, Object.freeze([...packages]), countryCode);
         if (!product.isBuyable)
             continue;
         UpdatableEntity.setParent(product, business);
-        for (const pkg of packages)
+        for (const pkg of product.packages)
             UpdatableEntity.setParent(pkg, product);
         products.push(product);
     }
@@ -655,35 +753,28 @@ export function buildBusiness(response) {
     // The orders of this customer, and their party preferences: the cart, and the fulfillment mode
     // to default their next order to. A message of any other payload type is dropped.
     const orders = [];
-    let cart = null;
-    let cartUpdateNumber = 0n;
-    let defaultFulfillmentMode = proto_FulfillmentMode.DELIVERY;
     for (const message of response.messages) {
         if (isDeletedEntity(getEntity(message.entity)))
             continue;
-        switch (message.payload.oneofKind) {
-            case "salesOrder": {
-                orders.push(orderFromProto(message, message.payload.salesOrder));
-                break;
-            }
-            case "partyPreferences": {
-                // One customer has one party preferences message, so two means two callers' messages are
-                // in one container - see partyPreferencesMessageFromBlobs, which breaks the tie the same way
-                const updateNumber = getEntity(message.entity).updateNumber;
-                if (cart !== null && updateNumber <= cartUpdateNumber)
-                    break;
-                // An emptied cart is a message whose payload carries no shopping list, which is what
-                // placing an order leaves behind - so it answers null and not an empty list, the same as
-                // never having had a cart at all
-                cart = cartShoppingListFromProto(message.payload.partyPreferences);
-                cartUpdateNumber = updateNumber;
-                // Whatever this same message carries, DELIVERY only ever coming from the fallback above -
-                // not from a message that happens to hold UNSPECIFIED_FULFILLMENT_MODE itself
-                defaultFulfillmentMode = message.payload.partyPreferences.fulfillmentMode;
-                break;
-            }
-            // No default: MONEY_TRANSFER has no payload in this protocol, and OTHER is not ours
-        }
+        // The party preferences are one message out of however many there are, so they are settled below
+        if (message.payload.oneofKind === "salesOrder")
+            orders.push(orderFromProto(message, message.payload.salesOrder, countryCode));
+    }
+    // One customer has one party preferences message, so two means two callers' messages are in one container. The one that is
+    // taken is the one that partyPreferencesMessageFromMessages picks, which is what a cart that is amended or sent again is
+    // read from as well: a rule of its own here would show one cart and amend another. It is the newer of the two even when it
+    // is the emptied one, and the older one's list is not shown for want of it.
+    const partyPreferences = partyPreferencesMessageFromMessages(response.messages);
+    let cart = null;
+    let defaultFulfillmentMode = proto_FulfillmentMode.DELIVERY;
+    if (partyPreferences !== null && partyPreferences.payload.oneofKind === "partyPreferences") {
+        // An emptied cart is a message whose payload carries no shopping list, which is what
+        // placing an order leaves behind - so it answers null and not an empty list, the same as
+        // never having had a cart at all
+        cart = cartShoppingListFromProto(partyPreferences.payload.partyPreferences, countryCode);
+        // Whatever this same message carries, DELIVERY only ever coming from the fallback above -
+        // not from a message that happens to hold UNSPECIFIED_FULFILLMENT_MODE itself
+        defaultFulfillmentMode = partyPreferences.payload.partyPreferences.fulfillmentMode;
     }
     for (const order of orders)
         UpdatableEntity.setParent(order, business);
@@ -715,20 +806,22 @@ export function buildProfile(profileId, response) {
         return null;
     return new Profile(profileId, user, businessLinks, businesses);
 }
-// One order on its own, for a caller holding a message rather than a whole response
-export function buildOrder(message) {
+// One order on its own, for a caller holding a message rather than a whole response. The country of
+// the business it was placed with is the caller's to give, since a tax travels as a raw code.
+export function buildOrder(message, countryCode) {
     if (message.payload.oneofKind !== "salesOrder")
         return null;
-    return orderFromProto(message, message.payload.salesOrder);
+    return orderFromProto(message, message.payload.salesOrder, countryCode);
 }
 // The shopping list a cart message carries, empty rather than absent when the cart has been
 // emptied. Unlike Business.cart (see the party preferences case of buildBusiness, which answers
 // null so "emptied" and "never had one" look the same to a customer), a caller here - createOrder,
 // the visitor cart carried over on sign in - works with an actual list either way.
-export function buildShoppingList(message) {
+// countryCode is that of the business the cart is for, as for buildOrder.
+export function buildShoppingList(message, countryCode) {
     if (message.payload.oneofKind !== "partyPreferences")
         throw new InvalidArgumentException("That message carries no party preferences, so it is not a cart");
-    return cartShoppingListFromProto(message.payload.partyPreferences) ?? ShoppingList.EMPTY;
+    return (cartShoppingListFromProto(message.payload.partyPreferences, countryCode) ?? ShoppingList.EMPTY);
 }
 // #endregion
 // #region What a customer pushes
@@ -758,12 +851,12 @@ export function buildPartyPreferencesMessage(messageId, existing, senderId, shop
     const preferences = existing !== null && existing.payload.oneofKind === "partyPreferences"
         ? existing.payload.partyPreferences
         : proto_PartyPreferencesPayload.create();
-    // Later than the copy it replaces, whatever this client's clock reads. A store keeps a blob only
-    // where its eTag is the greater, and that eTag is this field - so a client whose clock sits behind
-    // the time on the cart it is amending, which Constants.MAX_CLOCK_SKEW says is a thing that
-    // happens, would push a change the server accepted and then have its own store refuse it, leaving
-    // the two disagreeing about the cart the customer is looking at. One millisecond past the copy
-    // being replaced is enough, and the server keeps whatever is sent, so both sides still agree.
+    // Later than the copy it replaces, whatever this client's clock reads. An amendment written here
+    // without the server is stored at the update number of the copy it amends, where this field is
+    // what decides - so a client whose clock sits behind the time on the cart it is amending, which
+    // Constants.MAX_CLOCK_SKEW says is a thing that happens, would have its own store refuse the
+    // edit, leaving the customer looking at a cart that is not the one it holds. One millisecond past
+    // the copy being replaced is enough, and the server keeps whatever is sent, so both sides still agree.
     const updatedAt = existingEntity === null || existingEntity.updatedAt < now ? now : existingEntity.updatedAt + 1n;
     const partyPreferences = proto_PartyPreferencesPayload.create({
         ...preferences,
@@ -815,25 +908,14 @@ export function buildOrderMessage(orderId, senderId, shoppingList, fulfillmentMo
 export function messagesToCacheWrite(messages) {
     return toCacheWrite(messages.map((message) => toWireEntity(message.entity, proto_Message.toBinary(message))));
 }
-// The highest update number among this customer's messages already cached, cart and orders alike -
-// what a push sends as its cursor. Computed fresh off the store each time rather than kept anywhere:
-// no cursor is persisted in this library, and this is no exception - see THE SYNC STATES in
-// ../Prompt.txt. Zero when none are cached, which is how a first push asks for everything back.
-export function highestCachedMessageUpdateNumber(blobs) {
-    let highest = 0n;
-    for (const message of messagesFromBlobs(blobs)) {
-        const updateNumber = getEntity(message.entity).updateNumber;
-        if (updateNumber > highest)
-            highest = updateNumber;
-    }
-    return highest;
-}
 // The Entity of something this client is pushing. The update number goes out as zero: the protocol
 // replaces a caller's own with the server's and answers what it assigned, so there is nothing to
-// send and nothing to guess. updateInfo goes out as zero too, which is not the same kind of zero -
-// it should be the id of this store, and this store has no id yet, so a read of this business will
-// send these messages back rather than recognising them as its own. That costs bandwidth and
-// nothing else, since the eTag of the copy stored here is the one the server kept.
+// send and nothing to guess. It is also what a message not pushed yet is left holding in the store,
+// where messageToBlob versions it from the copy it amends. updateInfo goes out as zero too: it
+// would be the id of the store that made the change, and this client has no store of its own that
+// the server knows. It needs none: a read of this business sends these messages back, as the
+// server leaves nobody's changes out of a storefront's read, and the eTag of the copy stored here
+// is the one the server kept, so, that changes nothing it holds.
 function pushedEntity(id, createdAt, updatedAt) {
     return proto_Entity.create({ id: id, createdAt: createdAt, updatedAt: updatedAt });
 }
@@ -841,8 +923,12 @@ function pushedEntity(id, createdAt, updatedAt) {
 // building or pushing a cart message rather than after - a caller may call it on every event it
 // cares about and only a cart the server has not got costs a request.
 // Compares raw lists rather than built messages, because a message's updatedAt always differs from
-// call to call; sound because the server echoes a pushed list back unchanged, so what is stored is
-// exactly what was last sent.
+// call to call; sound because the server echoes a pushed list back with the items it was sent, so what
+// is stored is what was last sent - but not in the order it was sent in: the server keeps the items of a
+// list by package id and sends them in that order, and the order of the list is each item's
+// shoppingListOrder, which is compared with the rest of the item. So the items of both lists are put
+// in package id order before they are compared, or a cart that was not picked in package id order would
+// differ from its own echo and be pushed again, which re-stamps its updatedAt for every other device.
 // Also true whenever stored has never been pushed (updateNumber 0, left by updateCartLocalOnly),
 // regardless of content, so an unsent local edit still goes out.
 export function hasShoppingListChanged(stored, shoppingList) {
@@ -850,7 +936,18 @@ export function hasShoppingListChanged(stored, shoppingList) {
         return pushedShoppingList(shoppingList, false) !== undefined;
     if (getEntity(stored.entity).updateNumber === 0n)
         return true;
-    return !proto_ShoppingList.equals(getCartShoppingList(stored), pushedShoppingList(shoppingList, false));
+    return !proto_ShoppingList.equals(inPackageIdOrder(getCartShoppingList(stored)), inPackageIdOrder(pushedShoppingList(shoppingList, false)));
+}
+// The same list with its items by package id, the order in which the server sends them
+function inPackageIdOrder(list) {
+    if (list === undefined)
+        return undefined;
+    const byPackageId = (first, second) => first.packageId < second.packageId ? -1 : first.packageId > second.packageId ? 1 : 0;
+    return proto_ShoppingList.create({
+        ...list,
+        existingItems: [...list.existingItems].sort(byPackageId),
+        deletedItems: [...list.deletedItems].sort(byPackageId),
+    });
 }
 // The list inside a cart message, or absent for one carrying no list - which is an emptied cart
 function getCartShoppingList(message) {
@@ -907,34 +1004,59 @@ function shoppingListItemToProto(item) {
     });
 }
 function taxToProto(tax) {
-    return proto_Tax.create({ type: tax.type, rate: taxRateToScaledValue(tax.rate) });
+    return proto_Tax.create({ taxCode: tax.taxCode, rate: taxRateToScaledValue(tax.rate) });
 }
 // #endregion
 // #region Entity and item bookkeeping
-// One pass over the entities of a response, splitting them into what is stored and what is removed:
-// a live entity becomes a blob, and a tombstone becomes an id to delete. The blob id is the entity
-// id, which is what makes one read of a container enough to sort it by entity type, and the eTag is
-// Entity.updatedAt.
+// One pass over the entities of a response, each becoming a blob at its own id, which is what makes
+// one read of a container enough to sort it by entity type. Every blob is versioned by entityETag, a
+// tombstone's too: a delete is a write of its own, so a tombstone carries a greater update number
+// than any copy of what it deleted and replaces it, and an older copy of it, sent again, is the
+// lesser of the two and is refused. A later write of the same id is the greater again, and is kept.
 // Mutable arrays, so that businessResponseToCacheWrite can add the attachment base url to the blobs.
 function toCacheWrite(entities) {
     const blobs = [];
-    const deletedIds = [];
-    for (const entity of entities) {
-        if (entity.isDeleted)
-            deletedIds.push(entity.id);
-        else
-            blobs.push({ id: entity.id, eTag: entity.updatedAt, bytes: entity.bytes });
-    }
-    return { blobs: blobs, deletedIds: deletedIds };
-}
-function messageToBlob(message) {
+    for (const entity of entities)
+        blobs.push({
+            id: entity.id,
+            eTag: entityETag(entity.updateNumber, entity.updatedAt),
+            bytes: entity.bytes,
+        });
+    return { blobs: blobs, deletedIds: [] };
+}
+// What a store versions the blob of an entity by: its update number, and below it its updatedAt, in
+// one bigint so that the greater wins as the store says. The server assigns an update number to every
+// write, deletes included, so it rises with every change to an entity whatever any clock reads, and
+// decides between two copies that are not the same version. updatedAt decides between those that
+// are: only a copy this client wrote itself, at the update number of the one it amended, is another
+// of the same number. Wider than 64 bits, which a bigint holds exactly and a store must compare as one.
+export function entityETag(updateNumber, updatedAt) {
+    if (updateNumber < 0n || updatedAt < 0n)
+        throw new InvalidArgumentException("An update number and an updatedAt are never negative");
+    return (updateNumber << UPDATED_AT_BITS) | updatedAt;
+}
+// A message this client wrote, which has no update number of its own until a server assigns one, and
+// has none in the store as long as it is not pushed (see pushedEntity). It is versioned at the update
+// number of the copy it amends, which is the one heldETag carries, and so it is the later copy of that
+// version by its updatedAt: a copy of the version it amends, sent again by the server, is not, and a
+// later version of the server's, with a greater update number, replaces it. One that amends nothing
+// is at zero. A message that has an update number of its own is versioned by it, as any entity is.
+function messageToBlob(message, heldETag) {
     const entity = getEntity(message.entity);
+    const updateNumber = entity.updateNumber !== 0n
+        ? entity.updateNumber
+        : heldETag === null
+            ? 0n
+            : heldETag >> UPDATED_AT_BITS;
     return {
         id: entity.id,
-        eTag: entity.updatedAt,
+        eTag: entityETag(updateNumber, entity.updatedAt),
         bytes: proto_Message.toBinary(message),
     };
 }
+// The messages a container holds that are messages: a tombstone is held, and is not one. It is left out
+// whatever it carries, and not by what is found in it - a payload says what a message is, and a
+// tombstone sent by a server that left the payload on it would otherwise be read as a cart or an order.
 function messagesFromBlobs(blobs) {
     const result = [];
     for (const blob of blobs) {
@@ -942,7 +1064,9 @@ function messagesFromBlobs(blobs) {
             continue; // A fixed blob, not an entity
         if (Ids.getEntityTypeId(blob.id) !== proto_Constants.MESSAGE_ENTITY_TYPE_ID)
             continue;
-        result.push(proto_Message.fromBinary(blob.bytes));
+        const message = proto_Message.fromBinary(blob.bytes);
+        if (!isDeletedEntity(getEntity(message.entity)))
+            result.push(message);
     }
     return result;
 }
@@ -956,7 +1080,7 @@ function toWireEntity(entity, bytes) {
         updateNumber: entity.updateNumber,
         updatedAt: entity.updatedAt,
         isDeleted: isDeleted,
-        bytes: isDeleted ? EMPTY_BYTES : bytes,
+        bytes: bytes,
     };
 }
 // A tombstone: the update type is held in the last two bits of the update number
@@ -1000,10 +1124,6 @@ function stringFromProto(value) {
 function stringToProto(value) {
     return value === null || value.length === 0 ? undefined : value;
 }
-// An absent optional bool is null - for Product.isManufacturedByBusiness that means "not said either way"
-function booleanFromProto(value) {
-    return value === undefined ? null : value;
-}
 function attachmentBaseUrlFromProto(urlAndToken) {
     return new AttachmentBaseUrl(urlAndToken.resourceUrl, urlAndToken.sasToken, urlAndToken.expiry);
 }
@@ -1038,8 +1158,10 @@ function addressListFromProto(addressList) {
         return AddressList.EMPTY;
     return new AddressList(addressList.defaultAddressId, Object.freeze(addressList.addresses.map(addressFromProto)));
 }
-function taxFromProto(tax) {
-    return Tax.fromScaledValues(tax.type, tax.rate);
+// The wire carries a tax's raw code, meaningful only within a country - that of the business the tax
+// is on, which every caller therefore has to name
+function taxFromProto(tax, countryCode) {
+    return Tax.fromScaledValues(countryCode, tax.taxCode, tax.rate);
 }
 function latLongFromProto(latLong) {
     if (latLong === undefined)
@@ -1075,18 +1197,19 @@ function workingHoursFromProto(workingHours) {
 function workingDaysFromProto(workingDays) {
     if (workingDays === undefined)
         return WorkingDays.ALL_DAYS;
-    return new WorkingDays(Object.freeze([...workingDays.days]), Object.freeze(workingDays.workingHours.map(workingHoursFromProto)));
+    // Not an optional field, so an unspecified zone arrives as an empty string rather than absent
+    return new WorkingDays(Object.freeze([...workingDays.days]), workingDays.timeZone.length === 0 ? null : workingDays.timeZone, Object.freeze(workingDays.workingHours.map(workingHoursFromProto)));
 }
-function shoppingListItemFromProto(item) {
-    return ShoppingListItem.fromScaledValues(item.packageId, item.quantity, item.unitPrice, item.shoppingListOrder, item.isOriginal, item.isModified, item.isStockKeepingRequired, item.priceDiscount, item.discount, Object.freeze(item.taxes.map(taxFromProto)), item.expiry, stringFromProto(item.description));
+function shoppingListItemFromProto(item, countryCode) {
+    return ShoppingListItem.fromScaledValues(item.packageId, item.quantity, item.unitPrice, item.shoppingListOrder, item.isOriginal, item.isModified, item.isStockKeepingRequired, item.priceDiscount, item.discount, Object.freeze(item.taxes.map((tax) => taxFromProto(tax, countryCode))), item.expiry, stringFromProto(item.description));
 }
-function shoppingListFromProto(shoppingList) {
+function shoppingListFromProto(shoppingList, countryCode) {
     if (shoppingList === undefined)
         return ShoppingList.EMPTY;
-    return ShoppingList.fromScaledValues(shoppingList.isFinal, shoppingList.autoAddDeliveryCharge, shoppingList.autoAddServiceCharge, shoppingList.inventoryLocationId, shoppingList.priceListId, shoppingList.totalAmountBeforeDiscount, shoppingList.discount, shoppingList.existingItemCount, shoppingList.deletedItemCount, Object.freeze(shoppingList.existingItems.map(shoppingListItemFromProto)), Object.freeze(shoppingList.deletedItems.map(shoppingListItemFromProto)));
+    return ShoppingList.fromScaledValues(shoppingList.isFinal, shoppingList.autoAddDeliveryCharge, shoppingList.autoAddServiceCharge, shoppingList.inventoryLocationId, shoppingList.priceListId, shoppingList.totalAmountBeforeDiscount, shoppingList.discount, shoppingList.existingItemCount, shoppingList.deletedItemCount, Object.freeze(shoppingList.existingItems.map((item) => shoppingListItemFromProto(item, countryCode))), Object.freeze(shoppingList.deletedItems.map((item) => shoppingListItemFromProto(item, countryCode))));
 }
-function generalSettingsFromProto(settings) {
-    return GeneralSettings.fromScaledValues(Object.freeze(settings.paymentMethodDetails.map(paymentMethodDetailFromProto)), stringFromProto(settings.customerServicePhone), settings.isWhatsAppSupported, settings.isSmsSupported, addressListFromProto(settings.businessAddresses), Object.freeze(settings.businessIdentifiers.map(businessIdentifierFromProto)), Object.freeze([...settings.fulfillmentModes]), settings.deliveryCharge, Object.freeze(settings.deliveryChargeTaxes.map(taxFromProto)), settings.freeDeliveryTotal, settings.deliveryRadiusKms, stringFromProto(settings.storeTagline), workingDaysFromProto(settings.workingDays), latLongFromProto(settings.primaryStoreLocation), stringFromProto(settings.googleBusinessCategoryId), stringFromProto(settings.googleBusinessCategoryName), stringFromProto(settings.onlineStoreThemeId));
+function generalSettingsFromProto(settings, countryCode) {
+    return GeneralSettings.fromScaledValues(Object.freeze(settings.paymentMethodDetails.map(paymentMethodDetailFromProto)), stringFromProto(settings.customerServicePhone), settings.isWhatsAppSupported, settings.isSmsSupported, addressListFromProto(settings.businessAddresses), Object.freeze(settings.businessIdentifiers.map(businessIdentifierFromProto)), Object.freeze([...settings.fulfillmentModes]), settings.deliveryCharge, Object.freeze(settings.deliveryChargeTaxes.map((tax) => taxFromProto(tax, countryCode))), settings.freeDeliveryTotal, settings.deliveryRadiusKms, stringFromProto(settings.storeTagline), workingDaysFromProto(settings.workingDays), latLongFromProto(settings.primaryStoreLocation), stringFromProto(settings.googleBusinessCategoryId), stringFromProto(settings.googleBusinessCategoryName), stringFromProto(settings.onlineStoreThemeId), settings.onlineShoppingEnabled);
 }
 // #endregion
 // #region Entities
@@ -1131,25 +1254,26 @@ function packageFromProto(packageProto, photos, price) {
     const entity = getEntity(item.entity);
     return new Package(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, packageProto.isSoldLoose, packageProto.itemCode, Object.freeze(packageProto.identifiers.map(packageIdentifierFromProto)), dimensionsFromProto(packageProto.dimensions), weightFromProto(packageProto.weight), photos, price);
 }
-function productFromProto(productProto, photos, packages) {
+function productFromProto(productProto, photos, packages, countryCode) {
     const item = getItem(productProto.item);
     const entity = getEntity(item.entity);
-    return new Product(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, productProto.productType, stringFromProto(productProto.brand), booleanFromProto(productProto.isManufacturedByBusiness), stringFromProto(productProto.manufacturer), productProto.manufacturerAddress === undefined
+    return new Product(toEntityHeader(entity), item.name, stringFromProto(item.description), item.parentItemId, item.isDisabled, productProto.productType, stringFromProto(productProto.brand), productProto.isManufacturedByBusiness ?? true, // Absent means true (Product.proto)
+    stringFromProto(productProto.manufacturer), productProto.manufacturerAddress === undefined
         ? null
-        : addressFromProto(productProto.manufacturerAddress), Object.freeze(productProto.taxes.map(taxFromProto)), Object.freeze([...productProto.features]), photos, packages);
+        : addressFromProto(productProto.manufacturerAddress), Object.freeze(productProto.taxes.map((tax) => taxFromProto(tax, countryCode))), Object.freeze([...productProto.features]), productProto.forOfflineSaleOnly, photos, packages);
 }
-function orderFromProto(message, salesOrder) {
+function orderFromProto(message, salesOrder, countryCode) {
     const entity = getEntity(message.entity);
-    return Order.fromScaledValues(toEntityHeader(entity), message.senderId, message.status, stringFromProto(message.senderName), stringFromProto(message.senderPhone), salesOrder.status, salesOrder.fulfillmentMode, shoppingListFromProto(salesOrder.shoppingList), salesOrder.shoppingListTotal, salesOrder.shoppingListCount, salesOrder.deliveryAddressId, salesOrder.deliveryAddress === undefined ? null : addressFromProto(salesOrder.deliveryAddress), salesOrder.creationDate, stringFromProto(salesOrder.note), salesOrder.paymentReceived);
+    return Order.fromScaledValues(toEntityHeader(entity), message.senderId, message.status, stringFromProto(message.senderName), stringFromProto(message.senderPhone), salesOrder.status, salesOrder.fulfillmentMode, shoppingListFromProto(salesOrder.shoppingList, countryCode), salesOrder.shoppingListTotal, salesOrder.shoppingListCount, salesOrder.deliveryAddressId, salesOrder.deliveryAddress === undefined ? null : addressFromProto(salesOrder.deliveryAddress), salesOrder.creationDate, stringFromProto(salesOrder.note), salesOrder.paymentReceived);
 }
 // The one part of a cart message a customer is shown. Absent rather than empty when the cart holds
 // nothing, so that "emptied by placing an order" and "never had one" are the same answer - which is
 // also what makes createOrder's emptied cart indistinguishable from a cart that was never created.
 // Everything else the message carries is the server's: who sent it, how far the business has got
 // with reading it, and the fulfillment mode Java keeps there, which belongs to an order here.
-function cartShoppingListFromProto(partyPreferences) {
+function cartShoppingListFromProto(partyPreferences, countryCode) {
     const shoppingList = partyPreferences.shoppingList;
-    return shoppingList === undefined ? null : shoppingListFromProto(shoppingList);
+    return shoppingList === undefined ? null : shoppingListFromProto(shoppingList, countryCode);
 }
 // #endregion
 // #region Photos
@@ -1163,5 +1287,8 @@ function takePhotos(attachmentsByOwner, owningEntityId, attachmentBaseUrl) {
     return Object.freeze(attachments.map((attachment) => new Photo(attachment, attachmentBaseUrl)));
 }
 // #endregion
-const EMPTY_BYTES = new Uint8Array(0);
+// The width of the updatedAt an eTag carries below its update number. An int64 is never wider.
+const UPDATED_AT_BITS = 64n;
+// What a blob that is only its eTag holds
+const NO_BYTES = new Uint8Array(0);
 const NO_PHOTOS = Object.freeze([]);