@peabody-soft/mbs-model-ts 1.2.0 → 1.4.0

package/dist/Business.d.ts

@@ -1,3 +1,4 @@
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
 import AttachmentBaseUrl from "./AttachmentBaseUrl";
 import CartEditor from "./CartEditor";
 import Catalog from "./Catalog";
@@ -22,6 +23,8 @@ export default class Business extends Entity implements UpdatableBusiness {
     private set orders(value);
     get cart(): ShoppingList | null;
     private set cart(value);
+    get defaultFulfillmentMode(): proto_FulfillmentMode;
+    private set defaultFulfillmentMode(value);
     get catalog(): Catalog;
     private set catalog(value);
     createCartEditor(): CartEditor;
@@ -31,6 +34,7 @@ export default class Business extends Entity implements UpdatableBusiness {
     private _photos;
     private _orders;
     private _cart;
+    private _defaultFulfillmentMode;
     private _catalog;
     private _attachmentBaseUrl;
 }
@@ -39,6 +43,7 @@ export interface UpdatableBusiness {
     set photos(value: ReadonlyArray<Photo>);
     set orders(value: ReadonlyArray<Order>);
     set cart(value: ShoppingList | null);
+    set defaultFulfillmentMode(value: proto_FulfillmentMode);
     set catalog(value: Catalog);
     set attachmentBaseUrl(value: AttachmentBaseUrl | null);
 }

package/dist/Business.js

@@ -1,3 +1,4 @@
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
 import CartEditor from "./CartEditor";
 import Catalog from "./Catalog";
 import Entity from "./Entity";
@@ -15,6 +16,7 @@ export default class Business extends Entity {
         this._photos = Object.freeze([]);
         this._orders = Object.freeze([]);
         this._cart = null;
+        this._defaultFulfillmentMode = proto_FulfillmentMode.DELIVERY;
         this._catalog = Catalog.EMPTY;
         this._attachmentBaseUrl = null;
     }
@@ -56,13 +58,23 @@ export default class Business extends Entity {
     // cart, and null again once they have ordered what was in it - the message the cart travels in
     // outlives being emptied, but nothing of it is a customer's business, so what is exposed is the
     // list alone. The fulfillment mode is not part of it: that is chosen when an order is placed, and
-    // is a field of the Order.
+    // is a field of the Order - see defaultFulfillmentMode for the one other place it is read.
     get cart() {
         return this._cart;
     }
     set cart(value) {
         this._cart = value;
     }
+    // What to preselect for this customer's next order: whatever the party preferences message
+    // already carries, which createOrder stamps with the mode an order was just placed under - so
+    // this is that order's own choice, not necessarily today's cart's. DELIVERY when there has never
+    // been a party preferences message to read one from.
+    get defaultFulfillmentMode() {
+        return this._defaultFulfillmentMode;
+    }
+    set defaultFulfillmentMode(value) {
+        this._defaultFulfillmentMode = value;
+    }
     // Catalog.EMPTY until the catalog of this business arrives
     get catalog() {
         return this._catalog;

package/dist/Model.d.ts

@@ -24,7 +24,7 @@ export default class Model {
     createOrder(orderId: bigint, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null): Promise<void>;
     private beginSignIn;
     private pushBusinessMessages;
-    private storeCart;
+    private storeCartInCache;
     private requireBusinessBeingBrowsed;
     private requireCustomerOfBusiness;
     private static requireDeliveryAddress;

package/dist/Model.js

@@ -8,6 +8,7 @@ import Ids from "./Ids";
 import LiveData from "./LiveData";
 import * as ProtoMap from "./ProtoMap";
 import { InternalServerException } from "./ServiceExceptions";
+import ShoppingList from "./ShoppingList";
 import SyncCache from "./SyncCache";
 // The root of the object model, and the only thing a UI has to be given. Call initialize once,
 // then always fetch the current instance via getInstance.
@@ -42,12 +43,25 @@ class Model {
     // Signs in with the given credentials and syncs this subject's profile in - for a subject the
     // server already has a profile for; createUser is what a subject with none yet uses instead. Also
     // reads in the business being browsed, if any, now signed in as this customer.
+    //
+    // Idempotent on failure: beginSignIn's own "already signed in" guard aside, anything that throws
+    // after it - a bad credential, a refused push while reading in the business being browsed -
+    // discards this instance via signOut rather than leaving it half signed in. profileSyncIn
+    // publishes a cached profile before it ever reaches the network, so without this, a retry after
+    // such a failure could find _profile already set and trip that same guard despite never having
+    // actually signed in.
     async signIn(authenticationMethod, subjectId, authenticationToken) {
         this.beginSignIn(authenticationMethod, subjectId, authenticationToken);
-        const authTokens = await this.requireProfileAuthTokens();
-        await this.profileSyncIn(ProtoMap.buildProfileSyncOutRequestFromCache(await Model.getCache().readProfile(this.requireProfileContainerName())), authTokens);
-        if (this._businessId !== null)
-            await this.businessSyncIn();
+        try {
+            const authTokens = await this.requireProfileAuthTokens();
+            await this.profileSyncIn(ProtoMap.buildProfileSyncOutRequestFromCache(await Model.getCache().readProfile(this.requireProfileContainerName())), authTokens);
+            if (this._businessId !== null)
+                await this.businessSyncIn();
+        }
+        catch (error) {
+            await this.signOut();
+            throw error;
+        }
     }
     // Signs up with the given credentials, creating userToCreate as this subject's profile - for a
     // subject the server has no profile for yet; signIn is what an already known subject uses instead.
@@ -75,11 +89,16 @@ class Model {
     async signOut() {
         Model._instance = null;
     }
-    // Names the business to browse and reads it in, publishing null first so a stale or
-    // about-to-be-replaced Business is never shown as the one now being browsed.
+    // Names the business to browse and reads it in, publishing null first so a Business being
+    // replaced is never shown as the one now being browsed - but only when it IS being replaced.
+    // This is also how a caller re-reads the shop it is already on, and nulling unconditionally
+    // would blank the UI for the length of the read and undo syncBusinessContainer's own
+    // cache-first publish two lines later.
     async setBusinessId(businessId) {
+        const isDifferentBusiness = this._businessId !== businessId;
         this._businessId = businessId;
-        this.publishBusiness(null);
+        if (isDifferentBusiness)
+            this.publishBusiness(null);
         await this.businessSyncIn();
     }
     // #region What a customer writes
@@ -92,57 +111,50 @@ class Model {
     // of the difference.
     // Both need this customer to be a member of the business being browsed - three separate things
     // to be missing, so three separate failures; see requireCustomerOfBusiness.
-    // Creates or replaces this customer's cart, in the store and on the server both. An empty list
-    // empties the cart - an emptied cart and one never created are the same state here, on the wire
-    // and in what Business.cart answers.
-    // Signed out this is updateCartLocalOnly, there being no cart on the server for a visitor the
-    // server has not been told about. Signed in it is a push, so it costs a request: a caller
-    // editing a cart a tap at a time writes with updateCartLocalOnly and calls this one on whatever
-    // schedule it likes.
-    // Calling it with a cart the server already has costs nothing: it returns without a request. So a
-    // caller is free to call it on every event it cares about - a page hidden, a timer, both at
-    // once - without tracking what it last sent, and what it checks against is the store's own copy
-    // rather than a caller's idea of one. It is not a substitute for reading the business, though: a
-    // push answers with whatever else of this customer's changed, and a call that does not go out
-    // brings none of that back.
+    // Creates or replaces this customer's cart, on the server and in the store both. An empty list
+    // empties the cart - the same state as never having had one.
+    // Signed out, this is just updateCartLocalOnly - there is no server cart yet for a visitor the
+    // server has not heard of. Signed in, it costs a request, so an editor should write every change
+    // with updateCartLocalOnly and call this on its own schedule (debounced, on blur, a timer).
+    // Safe to call often: hasShoppingListChanged checks against the store's own copy rather than
+    // whatever the caller last sent, so a call that matches what is already there returns without a
+    // request. Not a substitute for reading the business, though - a push answers only with whatever
+    // else of this customer's changed, and a call that does not go out brings none of that back.
     async updateCart(shoppingList) {
         if (this._profile.value === null)
             return this.updateCartLocalOnly(shoppingList);
         const target = this.requireCustomerOfBusiness();
-        const stored = await Model.getCache().readCart(target.containerName);
-        const cartMessage = ProtoMap.buildCartMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), stored, target.senderId, shoppingList, BigInt(Date.now()));
-        if (!ProtoMap.isCartWorthPushing(stored, cartMessage))
+        const stored = await Model.getCache().readPartyPreferences(target.containerName);
+        if (!ProtoMap.hasShoppingListChanged(stored, shoppingList))
             return;
-        await this.pushBusinessMessages(target, [cartMessage]);
-    }
-    // The same, stored here and not sent. This is the call to make on every edit: a cart is worth
-    // keeping the moment a customer changes it, and a request per tap of a quantity stepper is not
-    // worth making. updateCart then sends whatever the caller has reached whenever it decides to -
-    // debounced, on the page being hidden, before signing in.
-    //
-    // Little is lost by a cart that is only ever stored. It survives the tab closing, the next
-    // updateCart sends it, and createOrder reads the cart from the store and carries that list in
-    // the order message itself - so an order placed from a cart never sent on its own is still the
-    // right order. What a caller gives up is that the server, and so this customer's other devices,
-    // learn of a change only when the next updateCart goes out.
-    //
-    // The store keeps whichever copy has the greater eTag, and buildCartMessage dates an amendment
-    // past the copy it replaces, so a cart stored here cannot be undone by a sync in bringing the
-    // server's older one back.
+        const partyPreferencesMessage = ProtoMap.buildPartyPreferencesMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), stored, target.senderId, shoppingList, null, BigInt(Date.now()));
+        await this.pushBusinessMessages(target, [partyPreferencesMessage]);
+    }
+    // The same, stored locally and not sent. Call this on every edit - a request per tap of a
+    // quantity stepper is not worth making - then call updateCart on your own schedule (debounced,
+    // on blur, before signing in) to actually send it.
+    // Nothing is lost by leaving it unsent: it survives a closed tab, the next updateCart sends it,
+    // and createOrder reads straight from the store. All a caller gives up is that the server, and so
+    // this customer's other devices, hear about the change late.
+    // It also cannot be undone by a stale sync in bringing an older server copy back: the store keeps
+    // whichever copy has the later eTag, and buildPartyPreferencesMessage always dates an amendment
+    // past what it replaces.
     async updateCartLocalOnly(shoppingList) {
-        // No membership to derive a cart id from while nobody is signed in (see
-        // Ids.getPartyPreferencesMessageId) and none to be had until somebody signs in, so one is
-        // drawn - once, and only once: buildCartMessage amends the cart already stored and keeps its
-        // own id, so a second write cannot leave two behind. The sender is ENTITY_ID_NULL for want of
-        // a User, and the first push after signing in names the real one.
+        // No membership to derive a message id from while signed out, so one is drawn instead - once,
+        // and only once: buildPartyPreferencesMessage keeps amending the same entity by reusing its id,
+        // so a second edit cannot leave two behind. The sender is ENTITY_ID_NULL for want of a User;
+        // the first push after signing in names the real one.
         if (this._profile.value === null)
-            return this.storeCart(ContainerNames.forBusiness(this.requireBusinessBeingBrowsed()), Ids.getNewId(proto_Constants.MESSAGE_ENTITY_TYPE_ID), BigInt(proto_Constants.ENTITY_ID_NULL), shoppingList);
+            return this.storeCartInCache(ContainerNames.forBusiness(this.requireBusinessBeingBrowsed()), Ids.getNewId(proto_Constants.MESSAGE_ENTITY_TYPE_ID), BigInt(proto_Constants.ENTITY_ID_NULL), shoppingList);
         const target = this.requireCustomerOfBusiness();
-        return this.storeCart(target.containerName, Ids.getPartyPreferencesMessageId(target.businessLink.id), target.senderId, shoppingList);
+        return this.storeCartInCache(target.containerName, Ids.getPartyPreferencesMessageId(target.businessLink.id), target.senderId, shoppingList);
     }
     // Places an order for what is in the cart, and empties it - the list is used up becoming the
     // order, as Java SalesOrderViewModel.saveChanges does on MODE_CREATE. Takes no shopping list
     // itself for that reason: the cart is the order.
+    // The emptied party preferences message is also stamped with this fulfillmentMode, so it becomes
+    // this order's rather than whatever the cart last held - see Business.defaultFulfillmentMode,
+    // which is what reads it back.
     // orderId is the caller's to mint, with Ids.getNewId(Constants.MESSAGE_ENTITY_TYPE_ID) - not
     // minted here - so that a caller holds it before the call is made: to find the order once placed
     // without a server-assigned id to wait for, and to retry a call a NetworkConnectionException left
@@ -154,9 +166,11 @@ class Model {
         const target = this.requireCustomerOfBusiness();
         // Read from the store, not the published Business, so the order reflects the cart as the
         // server last confirmed it, not a value some observer may still hold
-        const cartMessage = await Model.getCache().readCart(target.containerName);
-        const shoppingList = cartMessage === null ? null : ProtoMap.buildCart(cartMessage);
-        if (shoppingList === null || shoppingList.existingItems.length === 0)
+        const partyPreferencesMessage = await Model.getCache().readPartyPreferences(target.containerName);
+        const shoppingList = partyPreferencesMessage === null
+            ? ShoppingList.EMPTY
+            : ProtoMap.buildShoppingList(partyPreferencesMessage);
+        if (shoppingList.existingItems.length === 0)
             throw new IllegalOperationException("The cart holds nothing, so there is no order to place");
         Model.requireDeliveryAddress(target.addresses, fulfillmentMode, deliveryAddressId, deliveryAddress);
         // One creation time for both, and it is what the order was placed at
@@ -165,7 +179,10 @@ class Model {
         // but a cart still full, if the second one failed
         await this.pushBusinessMessages(target, [
             ProtoMap.buildOrderMessage(orderId, target.senderId, shoppingList, fulfillmentMode, deliveryAddressId, deliveryAddress, note, now),
-            ProtoMap.buildCartMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), cartMessage, target.senderId, null, now),
+            // fulfillmentMode is the order's, not left as whatever the cart held: placing an order is
+            // this customer's own choice of how it is fulfilled, freshly made, so it is what
+            // defaultFulfillmentMode should offer next time rather than a possibly stale earlier one.
+            ProtoMap.buildPartyPreferencesMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), partyPreferencesMessage, target.senderId, null, fulfillmentMode, now),
         ]);
     }
     // #endregion
@@ -198,16 +215,13 @@ class Model {
         if (changeCount !== 0)
             this.publishBusiness(await cache.readBusiness(target.containerName));
     }
-    // One cart into one container, amending whatever is there already. Both halves of
-    // updateCartLocalOnly end here, differing only in which container, which id and which sender:
-    // the container an anonymous read filled, with a drawn id and no sender, or the membership's,
-    // with the id derived from it and the customer's own.
-    // A visitor's copy goes into the container the anonymous read filled, which is what carries it
-    // across a sign in: the container named for a new membership is seeded from that one - see
-    // syncCustomerBusiness.
-    async storeCart(containerName, cartMessageId, senderId, shoppingList) {
+    // Amends whatever cart containerName already holds and writes the result back to the cache -
+    // nothing is pushed to the server. updateCartLocalOnly's two callers differ only in which
+    // container, which id, and which sender: a visitor's has a freshly drawn id and no sender, a
+    // customer's has the id their membership derives and their own sender id.
+    async storeCartInCache(containerName, messageId, senderId, shoppingList) {
         const cache = Model.getCache();
-        const changeCount = await cache.writeCart(containerName, ProtoMap.buildCartMessage(cartMessageId, await cache.readCart(containerName), senderId, shoppingList, BigInt(Date.now())));
+        const changeCount = await cache.writePartyPreferences(containerName, ProtoMap.buildPartyPreferencesMessage(messageId, await cache.readPartyPreferences(containerName), senderId, shoppingList, null, BigInt(Date.now())));
         // Published on what the store took, the same rule every read and push keeps
         if (changeCount !== 0)
             this.publishBusiness(await cache.readBusiness(containerName));
@@ -279,23 +293,39 @@ class Model {
         const link = await this.requireBusinessLink(businessId, profile);
         const cache = Model.getCache();
         const containerName = Model.getBusinessContainerName(link);
-        // Seeded from the plain businessId container's cache, the one time this customer's own
-        // container does not exist yet - sparing a full redownload of a business already browsed, and
-        // carrying over the cart of the visit before this sign in.
-        if ((await cache.readBusiness(containerName)) === null) {
-            const anonymousName = ContainerNames.forBusiness(businessId);
-            const anonymous = await cache.readBusiness(anonymousName);
-            if (anonymous !== null) {
-                await cache.writeBusiness(containerName, anonymous);
-                // That cart now belongs to this membership, so the copy left behind is dropped. The plain
-                // container is what the next anonymous visitor reads, and what the next customer to sign in
-                // is seeded from, and a cart is one customer's. Deleted after the copy and not before, so a
-                // failed copy leaves the cart where it was rather than losing it.
-                await cache.deleteCart(anonymousName);
-            }
+        const anonymousName = ContainerNames.forBusiness(businessId);
+        // What this device read while nobody was signed in, folded into the container it is read
+        // under now - the same rule the server's own pages take: writeBusiness keeps the later of two
+        // copies per entity by updatedAt. Unconditional, since a returning customer's own container
+        // can easily be the staler of the two.
+        // Not the cart, which is settled below: the two containers hold it under different ids, so a
+        // merge keyed on entity id would file the visitor's as a second cart instead of replacing one.
+        const anonymous = await cache.readBusiness(anonymousName);
+        // Out of the messages just read, rather than a second read of the same container -
+        // partyPreferencesMessageFromMessages picks the same one readPartyPreferences(anonymousName)
+        // would.
+        const anonymousPartyPreferences = anonymous === null ? null : ProtoMap.partyPreferencesMessageFromMessages(anonymous.messages);
+        if (anonymous !== null) {
+            anonymous.messages = anonymous.messages.filter((message) => !ProtoMap.isPartyPreferencesMessage(message));
+            await cache.writeBusiness(containerName, anonymous);
         }
         const authTokens = await this.requireBusinessAuthTokens(containerName, link);
         await this.syncBusinessContainer(containerName, businessId, ProtoMap.buildAuthTokens(authTokens));
+        // THE CART A VISITOR BUILT BEFORE SIGNING IN. Signing in changes which container is being
+        // browsed, so without this it is simply left behind - and a customer has to build it again
+        // having just proved who they are.
+        if (anonymousPartyPreferences === null)
+            return;
+        // Read after the sync, so this is weighed against what the server just settled rather than a
+        // local copy about to be replaced. Last written wins, by updatedAt.
+        const userPartyPreferences = await cache.readPartyPreferences(containerName);
+        if (userPartyPreferences === null ||
+            ProtoMap.getMessageUpdatedAt(anonymousPartyPreferences) >
+                ProtoMap.getMessageUpdatedAt(userPartyPreferences))
+            await this.updateCart(ProtoMap.buildShoppingList(anonymousPartyPreferences));
+        // Dropped either way, carried over or beaten by the customer's own: the anonymous container is
+        // what the next visitor on this device reads, and a settled cart has no business staying there.
+        await cache.deletePartyPreferences(anonymousName);
     }
     // The plain businessId-named container: an anonymous read, before signing in or joining, or to
     // learn a business's entity id while joining - see readJoinBusinessId.
@@ -395,15 +425,14 @@ class Model {
         return ContainerNames.forBusiness(Ids.toStorageHexString(link.id));
     }
     // The credentials that sign a call about a customer's own business container. The authentication
-    // token always comes from memory, never a cache read, for the same reason buildProfileAuthTokens
-    // reads it that way: a stored AuthTokens never persists it.
-    // The user token and link token are read independently off whatever this container has reissued,
-    // rather than as one object - storeIssuedTokens overwrites the whole blob per call, so trusting
-    // only that would lose whichever of the two a call didn't reissue. Each falls back to its own
-    // source instead: the profile container's user token, and this link's own linkToken - exactly
-    // what a fresh membership lacks, and what the write below now gives this container to reissue
-    // over. A link with no linkToken at all could never sign a call, so that is a server
-    // inconsistency, thrown rather than sent unsigned.
+    // token always comes from memory, not a cache read - same as buildProfileAuthTokens, since a
+    // stored AuthTokens never persists it.
+    // The user token and link token are read independently, not as one object: storeIssuedTokens
+    // overwrites the whole blob per call, so trusting only that would lose whichever token the last
+    // call didn't reissue. Each falls back to its own source instead - the profile container's user
+    // token, this link's own linkToken - which is exactly what a fresh membership lacks and what the
+    // write below now gives this container to reissue over.
+    // A link with no linkToken at all is a server inconsistency: thrown rather than sent unsigned.
     async requireBusinessAuthTokens(containerName, link) {
         const authenticationMethod = this._authenticationMethod;
         const authenticationToken = this._authenticationToken;
@@ -484,19 +513,19 @@ class Model {
     // #endregion
     // #region Driving one call
     // A join that was asked for but not answered. Shared by both calls that can carry a
-    // joinBusinessId, since what a join must return doesn't depend on which one asked: the
+    // joinBusinessId, since a join answers the same two things regardless of which one asked: the
     // BusinessLink (the membership) and the Business it names. Both are needed to reach a business -
-    // the link for its token, the Business for the url-friendly id everything else is built from - so
-    // either one missing leaves the caller told it's a customer of something it can't reach.
+    // the link for its token, the Business for the url-friendly id everything else is built from -
+    // so either one missing leaves the caller told it is a customer of something it cannot reach.
     //
     // A ServiceException, not one of Exceptions.ts: nothing the caller passed was wrong - the server
-    // answered 200 and left out what was asked for - so a caller can retry or carry on with what's
+    // answered 200 and left out what was asked for - so a caller can retry or carry on with what is
     // cached. 500 is the closest code, and the one that says retrying is worth it.
     //
-    // Only a joinBusinessId a server could act on is checked (Java Business.isValidBusinessId's test,
-    // which Constants.ENTITY_ID_NULL also fails, so "no join asked" needs no case of its own). An id
-    // that isn't a business entity id isn't a failure here: a server ignores it rather than refusing
-    // it (see THE MOCKS), and sending one is the caller's bug, not the server's.
+    // Only a joinBusinessId a server could act on is checked (Java Business.isValidBusinessId's
+    // test, which Constants.ENTITY_ID_NULL also fails, so "no join asked" needs no case of its own).
+    // An id that is not a business entity id is not a failure here: a server ignores it rather than
+    // refusing it (see THE MOCKS), and sending one is the caller's bug, not the server's.
     static requireJoinedBusiness(joinBusinessId, hasBusinessLink, hasBusiness) {
         if (Ids.getEntityTypeId(joinBusinessId) !== proto_Constants.BUSINESS_ENTITY_TYPE_ID)
             return;

package/dist/ProtoMap.d.ts

@@ -35,11 +35,14 @@ export declare function businessResponseToCacheWrite(response: proto_BusinessSyn
 export declare function profileResponseToCacheWrite(response: proto_ProfileSyncOutResponse): CacheWrite;
 export declare function getBusinessResponseAttachmentBaseUrlExpiry(response: proto_BusinessSyncOutResponse | null): bigint;
 export declare function orderToBlob(order: proto_Message): StoredBlob;
-export declare function cartToBlob(cart: proto_Message): StoredBlob;
+export declare function isPartyPreferencesMessage(message: proto_Message): boolean;
+export declare function getMessageUpdatedAt(message: proto_Message): bigint;
+export declare function partyPreferencesToBlob(partyPreferences: proto_Message): StoredBlob;
 export declare function businessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
 export declare function profileResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_ProfileSyncOutResponse | null;
 export declare function orderMessagesFromBlobs(blobs: ReadonlyArray<StoredBlob>): ReadonlyArray<proto_Message>;
-export declare function cartMessageFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_Message | null;
+export declare function partyPreferencesMessageFromMessages(messages: ReadonlyArray<proto_Message>): proto_Message | null;
+export declare function partyPreferencesMessageFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_Message | null;
 export declare function buildBusinessSyncOutRequest(businessId: string, syncInState: SyncState, attachmentBaseUrlExpiry: bigint): proto_BusinessSyncOutRequest;
 export declare function buildBusinessSyncOutRequestFromCache(businessId: string, cached: proto_BusinessSyncOutResponse | null): proto_BusinessSyncOutRequest;
 export declare function buildBusinessSyncInRequest(messageUpdateNumber: bigint, messages: ReadonlyArray<proto_Message>): proto_BusinessSyncInRequest;
@@ -63,9 +66,9 @@ export declare function nextProfileSyncOutRequest(request: proto_ProfileSyncOutR
 export declare function buildBusiness(response: proto_BusinessSyncOutResponse): Business | null;
 export declare function buildProfile(profileId: string, response: proto_ProfileSyncOutResponse): Profile | null;
 export declare function buildOrder(message: proto_Message): Order | null;
-export declare function buildCart(message: proto_Message): ShoppingList | null;
-export declare function buildCartMessage(cartMessageId: bigint, existing: proto_Message | null, senderId: bigint, shoppingList: ShoppingList | null, now: bigint): proto_Message;
+export declare function buildShoppingList(message: proto_Message): ShoppingList;
+export declare function buildPartyPreferencesMessage(messageId: bigint, existing: proto_Message | null, senderId: bigint, shoppingList: ShoppingList | null, fulfillmentMode: proto_FulfillmentMode | null, now: bigint): proto_Message;
 export declare function buildOrderMessage(orderId: bigint, senderId: bigint, shoppingList: ShoppingList, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null, creationDate: bigint): proto_Message;
 export declare function messagesToCacheWrite(messages: ReadonlyArray<proto_Message>): CacheWrite;
 export declare function highestCachedMessageUpdateNumber(blobs: ReadonlyArray<StoredBlob>): bigint;
-export declare function isCartWorthPushing(stored: proto_Message | null, cartMessage: proto_Message): boolean;
+export declare function hasShoppingListChanged(stored: proto_Message | null, shoppingList: ShoppingList): boolean;

package/dist/ProtoMap.js

@@ -10,6 +10,7 @@ import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./gene
 import { Configuration as proto_Configuration } from "./generated/Configuration";
 import { Constants as proto_Constants } from "./generated/Constants";
 import { Entity as proto_Entity } from "./generated/Entity";
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
 import { Message as proto_Message } from "./generated/Message";
 import { MessageType as proto_MessageType } from "./generated/MessageType";
 import { OrderStatus as proto_OrderStatus } from "./generated/OrderStatus";
@@ -101,7 +102,8 @@ export function getProfileResponseEntities(response) {
 // any entity of it.
 export function businessResponseToCacheWrite(response) {
     const write = toCacheWrite(getBusinessResponseEntities(response));
-    // Its eTag is its expiry, which is exactly its cursor: a client sends back the expiry it holds and is sent a later url only when one exists
+    // Its eTag is its expiry, which is exactly its cursor: a client sends back the expiry it holds
+    // and is sent a later url only when one exists
     const attachmentBaseUrl = response.attachmentBaseUrl;
     if (attachmentBaseUrl !== undefined)
         write.blobs.push({
@@ -115,24 +117,39 @@ export function businessResponseToCacheWrite(response) {
 export function profileResponseToCacheWrite(response) {
     return toCacheWrite(getProfileResponseEntities(response));
 }
-// The expiry of the attachment base url a response carried, and zero when it carried none, which is exactly what the next request sends back.
+// The expiry of the attachment base url a response carried, and zero when it carried none, which
+// is exactly what the next request sends back.
 // Here rather than at a call site, because reading a field of a response is this file's job.
 export function getBusinessResponseAttachmentBaseUrlExpiry(response) {
     return response?.attachmentBaseUrl?.expiry ?? 0n;
 }
-// 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.
+// 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) {
     if (order.payload.oneofKind !== "salesOrder")
         throw new InvalidArgumentException("That message carries no sales order, so it is not an order");
     return messageToBlob(order);
 }
-export function cartToBlob(cart) {
-    if (cart.payload.oneofKind !== "partyPreferences")
-        throw new InvalidArgumentException("That message carries no party preferences, so it is not a cart");
-    return messageToBlob(cart);
-}
-// 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.
-// The entity type in each blob id sorts them, so no stored type tag is needed; one this library does not know is skipped rather than refused, so a newer server cannot break an older client.
+// 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.
+export function getMessageUpdatedAt(message) {
+    return getEntity(message.entity).updatedAt;
+}
+export function partyPreferencesToBlob(partyPreferences) {
+    if (partyPreferences.payload.oneofKind !== "partyPreferences")
+        throw new InvalidArgumentException("That message carries no party preferences");
+    return messageToBlob(partyPreferences);
+}
+// 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.
+// The entity type in each blob id sorts them, so no stored type tag is needed; one this library
+// does not know is skipped rather than refused, so a newer server cannot break an older client.
 export function businessResponseFromBlobs(blobs) {
     const response = proto_BusinessSyncOutResponse.create({});
     let hasContent = false;
@@ -203,7 +220,8 @@ export function profileResponseFromBlobs(blobs) {
     }
     return hasContent ? response : null;
 }
-// The orders a container holds. The payload a message carries is what says whether it is an order or a cart - Message.messageType is not read, because here the payload is typed.
+// The orders a container holds. The payload a message carries is what says whether it is an
+// order or a cart - Message.messageType is not read, because here the payload is typed.
 export function orderMessagesFromBlobs(blobs) {
     const result = [];
     for (const message of messagesFromBlobs(blobs))
@@ -211,11 +229,16 @@ export function orderMessagesFromBlobs(blobs) {
             result.push(message);
     return result;
 }
-// The cart a container holds, or null when the customer has not put anything in one. A customer has one cart per business, so two means two callers' messages are in one container.
-// The most recently updated then wins for want of anything better: nothing in a message says which caller it was sent to - see THE MESSAGES OF A BUSINESS ARE NOT PUBLIC.
-export function cartMessageFromBlobs(blobs) {
+// The party preferences message among messages already in hand, or null when none of them is
+// one. A customer has one per business, so two means two callers' messages are in one container -
+// the most recently updated then wins for want of anything better: nothing in a message says
+// 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.
+export function partyPreferencesMessageFromMessages(messages) {
     let result = null;
-    for (const message of messagesFromBlobs(blobs)) {
+    for (const message of messages) {
         if (message.payload.oneofKind !== "partyPreferences")
             continue;
         if (result === null ||
@@ -224,6 +247,11 @@ export function cartMessageFromBlobs(blobs) {
     }
     return result;
 }
+// The party preferences message a container holds, or null when the customer has not put
+// anything in a cart yet.
+export function partyPreferencesMessageFromBlobs(blobs) {
+    return partyPreferencesMessageFromMessages(messagesFromBlobs(blobs));
+}
 // #endregion
 // #region Requests and credentials
 // The request that asks for everything changed since these cursors.
@@ -363,8 +391,12 @@ export function authTokensFromProto(authTokens) {
 export function buildAuthTokensBytes(authTokens) {
     return proto_AuthTokens.toBinary(authTokens);
 }
-// How a container keeps the credentials it earned: the two tokens this server issued, with a null eTag because a reissued token is not a later version of an earlier one and greater-wins would refuse it.
-// The authentication token is left out however it was passed in: it belongs to the identity provider, so a stored copy could only be staler than the one held in memory and would outlive the sign out that should have ended it.
+// How a container keeps the credentials it earned: the two tokens this server issued, with a
+// null eTag because a reissued token is not a later version of an earlier one and greater-wins
+// would refuse it.
+// The authentication token is left out however it was passed in: it belongs to the identity
+// provider, so a stored copy could only be staler than the one held in memory and would outlive
+// the sign out that should have ended it.
 export function authTokensToBlob(authTokens) {
     const stored = proto_AuthTokens.create({
         authenticationMethod: authTokens.authenticationMethod,
@@ -507,8 +539,10 @@ function profileSyncOutCursors(request) {
 }
 // #endregion
 // #region A response as an object graph
-// The whole of one business as an object graph, regrouping the flat wire entities by owner id so each class can be constructed with its children.
-// An entity whose parent is missing is dropped, since a paged read can hold a child whose parent has yet to arrive; null when the response carries no Business at all.
+// The whole of one business as an object graph, regrouping the flat wire entities by owner id so
+// each class can be constructed with its children.
+// An entity whose parent is missing is dropped, since a paged read can hold a child whose parent
+// has yet to arrive; null when the response carries no Business at all.
 export function buildBusiness(response) {
     const businessProto = response.business;
     if (businessProto === undefined || isDeletedEntity(getEntity(businessProto.entity)))
@@ -618,10 +652,12 @@ export function buildBusiness(response) {
         break;
     }
     updatableBusiness.catalog = new Catalog(productCategories, products, priceList);
-    // The orders of this customer, and their cart. A message of any other payload type is dropped.
+    // 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;
@@ -631,8 +667,8 @@ export function buildBusiness(response) {
                 break;
             }
             case "partyPreferences": {
-                // One customer has one cart, so two means two callers' messages are in one container - see
-                // cartMessageFromBlobs, which breaks the tie the same way
+                // 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;
@@ -641,6 +677,9 @@ export function buildBusiness(response) {
                 // 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
@@ -650,6 +689,7 @@ export function buildBusiness(response) {
         UpdatableEntity.setParent(order, business);
     updatableBusiness.orders = Object.freeze(orders);
     updatableBusiness.cart = cart;
+    updatableBusiness.defaultFulfillmentMode = defaultFulfillmentMode;
     return business;
 }
 // One profile as an object graph: the caller, their links, and the businesses those links name.
@@ -681,13 +721,14 @@ export function buildOrder(message) {
         return null;
     return orderFromProto(message, message.payload.salesOrder);
 }
-// The cart one message holds, for a caller holding a message rather than a whole response. Null for
-// a message that is not a cart, and null for a cart that has been emptied - see the party
-// preferences case of buildBusiness.
-export function buildCart(message) {
+// 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) {
     if (message.payload.oneofKind !== "partyPreferences")
-        return null;
-    return cartShoppingListFromProto(message.payload.partyPreferences);
+        throw new InvalidArgumentException("That message carries no party preferences, so it is not a cart");
+    return cartShoppingListFromProto(message.payload.partyPreferences) ?? ShoppingList.EMPTY;
 }
 // #endregion
 // #region What a customer pushes
@@ -699,16 +740,20 @@ export function buildCart(message) {
 // message the server named could never be found here again. The second is that updatedAt is the
 // client's too and the server keeps it unchanged - so the copy stored here carries the same eTag as
 // the copy a later read would bring back, and neither can look stale to the other.
-// The cart of this customer as a message to push. An existing message is amended rather than
-// rebuilt, because its payload carries fields this protocol does not expose - the fulfillment mode
-// the merchant app keeps there among them - and losing them would be a storefront overwriting
-// merchant data it cannot even read.
+// The party preferences of this customer as a message to push, carrying the cart and (optionally)
+// the fulfillment mode both. An existing message is amended rather than rebuilt, because its
+// payload can carry fields neither param here speaks to, and losing them would be a storefront
+// overwriting data it cannot even read.
 // Its id is used in preference to the derived one for the same reason: that is where the server
-// already holds this cart, and it is only worth deriving an id when there is no cart to amend.
+// already holds this customer's party preferences, and it is only worth deriving an id when there
+// is none to amend.
 // A list holding nothing is pushed as no list at all, the way Java serializeShoppingList answers
 // null below one item - so emptying a cart and never having had one are one state on the wire, and
 // placing an order is what puts a cart into it.
-export function buildCartMessage(cartMessageId, existing, senderId, shoppingList, now) {
+// fulfillmentMode is null to leave whatever is already there alone - the ordinary case, since a
+// storefront otherwise treats it as the merchant app's own data - and a value only where createOrder
+// means to set it, to the mode of the order that just emptied this cart.
+export function buildPartyPreferencesMessage(messageId, existing, senderId, shoppingList, fulfillmentMode, now) {
     const existingEntity = existing === null ? null : getEntity(existing.entity);
     const preferences = existing !== null && existing.payload.oneofKind === "partyPreferences"
         ? existing.payload.partyPreferences
@@ -720,18 +765,18 @@ export function buildCartMessage(cartMessageId, existing, senderId, shoppingList
     // 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.
     const updatedAt = existingEntity === null || existingEntity.updatedAt < now ? now : existingEntity.updatedAt + 1n;
+    const partyPreferences = proto_PartyPreferencesPayload.create({
+        ...preferences,
+        shoppingList: pushedShoppingList(shoppingList, false),
+    });
+    if (fulfillmentMode !== null)
+        partyPreferences.fulfillmentMode = fulfillmentMode;
     return proto_Message.create({
-        entity: pushedEntity(existingEntity?.id ?? cartMessageId, existingEntity?.createdAt ?? updatedAt, updatedAt),
+        entity: pushedEntity(existingEntity?.id ?? messageId, existingEntity?.createdAt ?? updatedAt, updatedAt),
         senderId: senderId,
         messageType: proto_MessageType.PARTY_PREFERENCES,
         status: proto_TaskStatus.NOT_YET_PROCESSED,
-        payload: {
-            oneofKind: "partyPreferences",
-            partyPreferences: proto_PartyPreferencesPayload.create({
-                ...preferences,
-                shoppingList: pushedShoppingList(shoppingList, false),
-            }),
-        },
+        payload: { oneofKind: "partyPreferences", partyPreferences: partyPreferences },
     });
 }
 // One order as a message to push. Its shopping list goes out final whatever was passed in, which is
@@ -792,24 +837,20 @@ export function highestCachedMessageUpdateNumber(blobs) {
 function pushedEntity(id, createdAt, updatedAt) {
     return proto_Entity.create({ id: id, createdAt: createdAt, updatedAt: updatedAt });
 }
-// Whether a cart is worth the request, answered off what the store already holds - so a caller may
-// call updateCart as often as it likes and only a cart the server has not got costs anything.
-// Two ways it is worth sending. The list differs from the stored one, which is the ordinary case.
-// Or the stored copy has never been accepted: a pushed entity goes out with updateNumber zero and
-// comes back carrying the server's, so zero here means this cart was written by
-// Model.updateCartLocalOnly and has not been sent since.
-// The lists are compared rather than the messages, because a message always differs - updatedAt is
-// the clock's reading, and buildCartMessage moves it on every call. Comparing them is sound only
-// because the server keeps a pushed list exactly as it arrived, so what comes back is what went
-// out; a server that normalised the list would make every call differ and push every time, which
-// is what this library did before and so is no worse.
-export function isCartWorthPushing(stored, cartMessage) {
-    // Nothing stored and nothing to send: an emptied cart and one never created are one state
+// Whether shoppingList differs from what stored already holds, so updateCart can check before
+// 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.
+// 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) {
     if (stored === null)
-        return getCartShoppingList(cartMessage) !== undefined;
+        return pushedShoppingList(shoppingList, false) !== undefined;
     if (getEntity(stored.entity).updateNumber === 0n)
         return true;
-    return !proto_ShoppingList.equals(getCartShoppingList(stored), getCartShoppingList(cartMessage));
+    return !proto_ShoppingList.equals(getCartShoppingList(stored), pushedShoppingList(shoppingList, false));
 }
 // The list inside a cart message, or absent for one carrying no list - which is an emptied cart
 function getCartShoppingList(message) {
@@ -817,9 +858,9 @@ function getCartShoppingList(message) {
         ? message.payload.partyPreferences.shoppingList
         : undefined;
 }
-// A shopping list on its way out, or absent when it holds nothing - see buildCartMessage. Emptiness
-// is judged by the items being sent and not by the counts the list carries, for the reason the
-// counts below are.
+// A shopping list on its way out, or absent when it holds nothing - see
+// buildPartyPreferencesMessage. Emptiness is judged by the items being sent and not by the counts
+// the list carries, for the reason the counts below are.
 function pushedShoppingList(shoppingList, isFinal) {
     if (shoppingList === null)
         return undefined;
@@ -1034,7 +1075,8 @@ 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));

package/dist/SyncCache.d.ts

@@ -15,9 +15,9 @@ export default class SyncCache {
     readOrders(containerName: string): Promise<ReadonlyArray<proto_Message>>;
     readMessageUpdateNumber(containerName: string): Promise<bigint>;
     writeOrder(containerName: string, order: proto_Message): Promise<number>;
-    readCart(containerName: string): Promise<proto_Message | null>;
-    writeCart(containerName: string, cart: proto_Message): Promise<number>;
-    deleteCart(containerName: string): Promise<number>;
+    readPartyPreferences(containerName: string): Promise<proto_Message | null>;
+    writePartyPreferences(containerName: string, partyPreferences: proto_Message): Promise<number>;
+    deletePartyPreferences(containerName: string): Promise<number>;
     writeMessages(containerName: string, messages: ReadonlyArray<proto_Message>): Promise<number>;
     private readAll;
     private writeBlobs;

package/dist/SyncCache.js

@@ -53,8 +53,8 @@ export default class SyncCache {
         return ProtoMap.orderMessagesFromBlobs(await this.readAll(containerName));
     }
     // The cursor a push sends: the highest update number among this customer's messages already
-    // cached here, cart and orders alike. Not persisted, like every cursor in this library - read off
-    // the store fresh each time rather than kept anywhere.
+    // cached here, party preferences and orders alike. Not persisted, like every cursor in this
+    // library - read off the store fresh each time rather than kept anywhere.
     async readMessageUpdateNumber(containerName) {
         return ProtoMap.highestCachedMessageUpdateNumber(await this.readAll(containerName));
     }
@@ -62,36 +62,38 @@ export default class SyncCache {
     async writeOrder(containerName, order) {
         return this.writeBlobs(containerName, [ProtoMap.orderToBlob(order)]);
     }
-    // The cart in this container, or null when there is none. Two carts mean two callers, which is the same open question as the orders above.
-    async readCart(containerName) {
-        return ProtoMap.cartMessageFromBlobs(await this.readAll(containerName));
-    }
-    async writeCart(containerName, cart) {
-        return this.writeBlobs(containerName, [ProtoMap.cartToBlob(cart)]);
-    }
-    // Drops the cart this container holds, and answers zero when it holds none. The one delete here
-    // that no tombstone asked for, and the only reason it exists: a cart written before anybody
-    // signed in is handed over to the container named for the membership, and the copy left behind
-    // would otherwise be read by the next anonymous visitor and by the next customer to sign in - see
-    // Model.businessSyncIn. Nothing else about a container is a caller's to remove: everything in one
-    // came off the wire, and what the server has not said is gone stays.
-    async deleteCart(containerName) {
-        const cart = await this.readCart(containerName);
-        if (cart === null)
+    // The party preferences message in this container, or null when there is none. Two mean two
+    // callers, which is the same open question as the orders above.
+    async readPartyPreferences(containerName) {
+        return ProtoMap.partyPreferencesMessageFromBlobs(await this.readAll(containerName));
+    }
+    async writePartyPreferences(containerName, partyPreferences) {
+        return this.writeBlobs(containerName, [ProtoMap.partyPreferencesToBlob(partyPreferences)]);
+    }
+    // Drops the party preferences message this container holds, and answers zero when it holds none.
+    // The one delete here that no tombstone asked for, and the only reason it exists: one written
+    // before anybody signed in is handed over to the container named for the membership, and the
+    // copy left behind would otherwise be read by the next anonymous visitor and by the next customer
+    // to sign in - see Model.businessSyncIn. Nothing else about a container is a caller's to remove:
+    // everything in one came off the wire, and what the server has not said is gone stays.
+    async deletePartyPreferences(containerName) {
+        const partyPreferences = await this.readPartyPreferences(containerName);
+        if (partyPreferences === null)
             return 0;
         return this.write(containerName, {
             blobs: NO_BLOBS,
-            deletedIds: [ProtoMap.cartToBlob(cart).id],
+            deletedIds: [ProtoMap.partyPreferencesToBlob(partyPreferences).id],
         });
     }
-    // The messages a sync in response carried, in a single batch - a pushed order and the cart it
-    // emptied belong in one write, so that this cache cannot come to hold the order without the
-    // emptying. Tombstones included, the same as any other entity array read off the wire: this is
-    // what a push's own messages are stored as once the server has echoed them back with real update
-    // numbers, and it is also how anything else of this customer's that the response carried lands
-    // here. Neither is checked against a payload type, unlike the two writers above - those are for a
-    // caller handing in a message it was given, where storing an order as a cart would be a mistake
-    // worth catching, and this is for messages the response itself is the authority on.
+    // The messages a sync in response carried, in a single batch - a pushed order and the party
+    // preferences message it emptied belong in one write, so that this cache cannot come to hold the
+    // order without the emptying. Tombstones included, the same as any other entity array read off
+    // the wire: this is what a push's own messages are stored as once the server has echoed them back
+    // with real update numbers, and it is also how anything else of this customer's that the response
+    // carried lands here. Neither is checked against a payload type, unlike the two writers above -
+    // those are for a caller handing in a message it was given, where storing an order as party
+    // preferences would be a mistake worth catching, and this is for messages the response itself is
+    // the authority on.
     async writeMessages(containerName, messages) {
         return this.write(containerName, ProtoMap.messagesToCacheWrite(messages));
     }

package/dist/WorkingDays.d.ts

@@ -1,14 +1,15 @@
 export default class WorkingDays {
     private readonly _days;
+    private readonly _timeZone;
     private readonly _workingHours;
-    constructor(_days: ReadonlyArray<boolean>, _workingHours: ReadonlyArray<WorkingHours>);
+    constructor(_days: ReadonlyArray<boolean>, _timeZone: string | null, _workingHours: ReadonlyArray<WorkingHours>);
     get days(): ReadonlyArray<boolean>;
+    get timeZone(): string | null;
     get workingHours(): ReadonlyArray<WorkingHours>;
     get includesAllDaysOfWeek(): boolean;
     isWorkingDay(dayOfWeek: number): boolean;
     getWorkingHours(dayOfWeek: number): WorkingHours | null;
     isOpenAllDay(dayOfWeek: number): boolean;
-    isOpenAt(dayOfWeek: number, minuteOfDay: number): boolean;
     private static checkDayOfWeek;
     static readonly ALL_DAYS: WorkingDays;
 }

package/dist/WorkingDays.js

@@ -2,11 +2,12 @@ import { Constants as proto_Constants } from "./generated/Constants";
 import { InvalidArgumentException } from "./Exceptions";
 // Days and hours a business works. Absence is the permissive value throughout: no WorkingDays
 // means every day (ALL_DAYS); a day with no hours/ranges means worked all day.
-// No time zone here (the protocol carries none) - only a caller that knows the business's zone
-// can turn a moment into these day/minute values.
+// The hours are minutes after local midnight in timeZone, so a caller asking about a moment reads
+// it in that zone first, as a day and a minute.
 class WorkingDays {
-    constructor(_days, _workingHours) {
+    constructor(_days, _timeZone, _workingHours) {
         this._days = _days;
+        this._timeZone = _timeZone;
         this._workingHours = _workingHours;
     }
     // Index 0 is Sunday and index 6 is Saturday, the same numbering as Date.getDay. Shorter than
@@ -14,6 +15,13 @@ class WorkingDays {
     get days() {
         return this._days;
     }
+    // The IANA ID of the zone the hours are in, for example "Asia/Kolkata" - never an abbreviation
+    // like "IST". Null when none was specified: settings saved before the protocol carried one, and
+    // ALL_DAYS. Then the hours cannot be placed on a clock, and only a caller that knows the
+    // business's zone can read a moment into them.
+    get timeZone() {
+        return this._timeZone;
+    }
     // Indexed exactly as days above. Shorter than days, or empty, is normal: see the comment on
     // this class for what a missing entry means.
     get workingHours() {
@@ -41,20 +49,14 @@ class WorkingDays {
     isOpenAllDay(dayOfWeek) {
         return this.isWorkingDay(dayOfWeek) && this.getWorkingHours(dayOfWeek) === null;
     }
-    // minuteOfDay is minutes after local midnight, from 0 to Constants.MINUTES_PER_DAY - 1
-    isOpenAt(dayOfWeek, minuteOfDay) {
-        if (!this.isWorkingDay(dayOfWeek))
-            return false;
-        const workingHours = this.getWorkingHours(dayOfWeek);
-        return workingHours === null || workingHours.contains(minuteOfDay);
-    }
     static checkDayOfWeek(dayOfWeek) {
         if (!Number.isInteger(dayOfWeek) || dayOfWeek < 0 || dayOfWeek >= proto_Constants.DAYS_IN_WEEK)
             throw new InvalidArgumentException(`Not a day of the week: ${dayOfWeek}`);
     }
 }
-// What an absent WorkingDays means: the business works every day, all day long
-WorkingDays.ALL_DAYS = new WorkingDays(Object.freeze([true, true, true, true, true, true, true]), Object.freeze([]));
+// What an absent WorkingDays means: the business works every day, all day long. With no hours
+// there is nothing for a zone to place, so it has none.
+WorkingDays.ALL_DAYS = new WorkingDays(Object.freeze([true, true, true, true, true, true, true]), null, Object.freeze([]));
 export default WorkingDays;
 // The hours of a single day that are worked, as the stretches of it that are.
 export class WorkingHours {
@@ -73,6 +75,8 @@ export class WorkingHours {
     get isAllDay() {
         return (this._ranges.length === 0 || (this._ranges.length === 1 && this._ranges[0].isAllDay));
     }
+    // minuteOfDay is minutes after local midnight in the zone of the WorkingDays these hours belong
+    // to, from 0 to Constants.MINUTES_PER_DAY - 1
     contains(minuteOfDay) {
         if (this.isAllDay)
             return true;

package/dist/generated/WorkingDays.d.ts

@@ -20,12 +20,20 @@ export interface WorkingDays {
      * @generated from protobuf field: repeated bool days = 1
      */
     days: boolean[];
+    /**
+     * The IANA ID of the time zone the working hours are specified in, for example "Asia/Kolkata";
+     * never an abbreviation like "IST", which is ambiguous. At most 64 characters. Empty means it
+     * was never specified, as in settings saved before this field existed.
+     *
+     * @generated from protobuf field: string timeZone = 2
+     */
+    timeZone: string;
     /**
      * Working hours of each day, indexed as days above (entry 0 = Sunday); up to
      * Constants.DAYS_IN_WEEK entries, fewer is normal. A missing entry, or one with no ranges, means
      * work all day; only meaningful on a day whose days entry is true.
      *
-     * @generated from protobuf field: repeated com.merabills.storefront.WorkingHours workingHours = 2
+     * @generated from protobuf field: repeated com.merabills.storefront.WorkingHours workingHours = 3
      */
     workingHours: WorkingHours[];
 }

package/dist/generated/WorkingDays.js

@@ -8,12 +8,14 @@ class WorkingDays$Type extends MessageType {
     constructor() {
         super("com.merabills.storefront.WorkingDays", [
             { no: 1, name: "days", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 8 /*ScalarType.BOOL*/ },
-            { no: 2, name: "workingHours", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => WorkingHours }
+            { no: 2, name: "timeZone", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "workingHours", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => WorkingHours }
         ]);
     }
     create(value) {
         const message = globalThis.Object.create((this.messagePrototype));
         message.days = [];
+        message.timeZone = "";
         message.workingHours = [];
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
@@ -31,7 +33,10 @@ class WorkingDays$Type extends MessageType {
                     else
                         message.days.push(reader.bool());
                     break;
-                case /* repeated com.merabills.storefront.WorkingHours workingHours */ 2:
+                case /* string timeZone */ 2:
+                    message.timeZone = reader.string();
+                    break;
+                case /* repeated com.merabills.storefront.WorkingHours workingHours */ 3:
                     message.workingHours.push(WorkingHours.internalBinaryRead(reader, reader.uint32(), options));
                     break;
                 default:
@@ -53,9 +58,12 @@ class WorkingDays$Type extends MessageType {
                 writer.bool(message.days[i]);
             writer.join();
         }
-        /* repeated com.merabills.storefront.WorkingHours workingHours = 2; */
+        /* string timeZone = 2; */
+        if (message.timeZone !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.timeZone);
+        /* repeated com.merabills.storefront.WorkingHours workingHours = 3; */
         for (let i = 0; i < message.workingHours.length; i++)
-            WorkingHours.internalBinaryWrite(message.workingHours[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+            WorkingHours.internalBinaryWrite(message.workingHours[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peabody-soft/mbs-model-ts",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "MeraBills storefront client-side model (TypeScript)",
   "author": "Peabody Soft",
   "license": "AGPL-3.0-or-later",
@@ -49,7 +49,7 @@
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@peabody-soft/mbs-protos": "^1.9.0",
+    "@peabody-soft/mbs-protos": "^1.10.0",
     "@protobuf-ts/runtime": "^2.11.1"
   }
 }