@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.232 → 1.0.0-alpha.233

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.233 (2026-09-07)
+
+### Bug Fixes
+
+* **example:** ordering names catalog's image store instead of minting its own ([c155060](https://github.com/ReventlessDev/reventless-core/commit/c1550609ed861367107327d1edf84f40018f4773))
+* feat(dcb)!: a record inside an array is still a reference and a key ([bcb9b13](https://github.com/ReventlessDev/reventless-core/commit/bcb9b13958323d8319d7fcf25c055800e84150f3))
+* refactor(traits)!: consumed facts are grouped, not suffixed ([a844b7a](https://github.com/ReventlessDev/reventless-core/commit/a844b7a99349ca20633d68cf32b95cb7677d02a4))
+### Features
+
+* **catalog:** the set says which member now stands, and orders freeze it ([79d882d](https://github.com/ReventlessDev/reventless-core/commit/79d882d094c11b35a1cb42958a89fc63561e43ab))
+* **core:** a command's lifecycle edge comes from its scenarios, not its claim ([1879d05](https://github.com/ReventlessDev/reventless-core/commit/1879d0570a981e7fae5bcd3808f8a36e898bd0fd))
+
+### BREAKING CHANGES
+
+* an `int` field is now `Int` in the generated SDL and
+`"integer"` in JSON Schema, where it was `Float`/`"number"`. A client
+declaring `$retryCount: Float!` against one of these fields must move to
+`Int!`.
+* a graft's `Binding` must expose `Consumed` instead of the
+`*C` bindings. The scaffolds emit the new shape, so a regenerated graft is
+already correct; a hand-written one moves its consumed builders into a module.
+
+
+
 # 1.0.0-alpha.232 (2026-09-04)
 
 **Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/online-shop-hybrid-ordering",
-  "version": "1.0.0-alpha.232",
+  "version": "1.0.0-alpha.233",
   "description": "Online Shop Hybrid example — Ordering plugin (Customer aggregate + Order/CatalogProduct DCB)",
   "license": "Apache-2.0",
   "jest": {
@@ -21,20 +21,20 @@
   },
   "dependencies": {
     "sury": "11.0.0-rc.2",
-    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.125",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.126",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.125",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.203",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.157",
-    "@reventlessdev/reventless-local": "3.0.0-alpha.245",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.129",
-    "@reventlessdev/trait-notification": "1.0.0-alpha.5",
-    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.5"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.158",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.204",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.126",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.246",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.130",
+    "@reventlessdev/trait-address-geocoding": "1.0.0-alpha.6",
+    "@reventlessdev/trait-notification": "1.0.0-alpha.6"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.77"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.78"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res

@@ -9,6 +9,7 @@ type consumedEvent =
   | CatalogProductPriceChanged({price: Reventless.Money.t})
   | CatalogProductWithdrawn
   | CatalogProductRelisted
+  | CatalogProductImageChanged({productImage?: Reventless.UploadableImage.t})
 
 @schema
 type command =
@@ -20,6 +21,14 @@ type command =
   // Ordering owns rather than asking Catalog to re-send facts it already has.
   | WithdrawSyncedProduct({productId: string})
   | RelistSyncedProduct({productId: string})
+  // The picture Catalog says to show. Carried as the ref Catalog's store minted,
+  // so Ordering stores a path it can hand to a reader without knowing where the
+  // bytes live or being able to write there — which is why the store is named
+  // rather than derived: the field's own name would declare an Ordering store.
+  | ChangeSyncedProductImage({
+      productId: string,
+      @storageRef("Catalog.productImages") productImage?: Reventless.UploadableImage.t,
+    })
 
 @schema
 type error = unit // always succeeds — sync is idempotent
@@ -45,3 +54,7 @@ type event =
       name: string,
       price: Reventless.Money.t,
     })
+  | CatalogProductImageChanged({
+      productId: string,
+      @storageRef("Catalog.productImages") productImage?: Reventless.UploadableImage.t,
+    })

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res.mjs

@@ -3,6 +3,7 @@
 import * as Sury from "sury";
 import * as Money$Reventless from "@reventlessdev/reventless-spec/src/semantic/Money.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as UploadableImage$Reventless from "@reventlessdev/reventless-spec/src/semantic/UploadableImage.res.mjs";
 
 let consumedEventSchema = Sury.union([
   Sury.$schema(s => ({
@@ -15,7 +16,11 @@ let consumedEventSchema = Sury.union([
     price: s.m(Money$Reventless.schema)
   })),
   Sury.literal("CatalogProductWithdrawn"),
-  Sury.literal("CatalogProductRelisted")
+  Sury.literal("CatalogProductRelisted"),
+  Sury.$schema(s => ({
+    TAG: "CatalogProductImageChanged",
+    productImage: s.m(Sury.$option(UploadableImage$Reventless.forField(undefined, "productImages")))
+  }))
 ]);
 
 let commandSchema = Sury.union([
@@ -37,6 +42,11 @@ let commandSchema = Sury.union([
   Sury.$schema(s => ({
     TAG: "RelistSyncedProduct",
     productId: s.m(DcbTag$Reventless.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "ChangeSyncedProductImage",
+    productId: s.m(DcbTag$Reventless.string),
+    productImage: s.m(Sury.$option(UploadableImage$Reventless.forField("Catalog", "productImages")))
   }))
 ]);
 
@@ -63,6 +73,11 @@ let eventSchema = Sury.union([
     productId: s.m(DcbTag$Reventless.string),
     name: s.m(Sury.string),
     price: s.m(Money$Reventless.schema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "CatalogProductImageChanged",
+    productId: s.m(DcbTag$Reventless.string),
+    productImage: s.m(Sury.$option(UploadableImage$Reventless.forField("Catalog", "productImages")))
   }))
 ]);
 
@@ -71,7 +86,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res

@@ -6,15 +6,25 @@
 // `withdrawn` sits beside the shadow rather than replacing it: a withdrawn
 // product's name and price are exactly what a relist needs, and dropping them
 // here would force Catalog to re-send facts Ordering already holds.
-type state = {name: string, price: option<Reventless.Money.t>, withdrawn: bool}
-let initialState = {name: "", price: None, withdrawn: false}
+type state = {
+  name: string,
+  price: option<Reventless.Money.t>,
+  withdrawn: bool,
+  // The picture last announced, kept for the same reason `name` is: so a repeat
+  // of the same announcement can be recognised and dropped.
+  productImage: option<Reventless.UploadableImage.t>,
+}
+let initialState = {name: "", price: None, withdrawn: false, productImage: None}
 
 let evolve = (state, event) =>
   switch event {
-  | CatalogProductSynced({name, price}) => {name, price: Some(price), withdrawn: false}
+  // Spread rather than rebuilt: the picture is announced on its own event, so a
+  // re-sync of name and price must not quietly drop it.
+  | CatalogProductSynced({name, price}) => {...state, name, price: Some(price), withdrawn: false}
   | CatalogProductPriceChanged({price}) => {...state, price: Some(price)}
   | CatalogProductWithdrawn => {...state, withdrawn: true}
   | CatalogProductRelisted => {...state, withdrawn: false}
+  | CatalogProductImageChanged({productImage: ?productImage}) => {...state, productImage}
   }
 
 let decide = (state, command) =>
@@ -48,4 +58,14 @@ let decide = (state, command) =>
     | (true, Some(price)) =>
       Ok([CatalogProductRelisted({productId: theId, name: state.name, price})])
     }
+  // Idempotent like the rest: Catalog re-announcing the same picture is the
+  // ordinary shape of at-least-once delivery, not a change.
+  // Compared as options, so "the picture is gone" is recognised as a change and
+  // re-announcing the same absence is not.
+  | ChangeSyncedProductImage({productId, productImage: ?productImage}) =>
+    if state.productImage == productImage {
+      Ok([])
+    } else {
+      Ok([CatalogProductImageChanged({productId, productImage: ?productImage})])
+    }
   }

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res.mjs

@@ -8,27 +8,40 @@ function evolve(state, event) {
       return {
         name: state.name,
         price: state.price,
-        withdrawn: true
+        withdrawn: true,
+        productImage: state.productImage
       };
     } else {
       return {
         name: state.name,
         price: state.price,
-        withdrawn: false
+        withdrawn: false,
+        productImage: state.productImage
       };
     }
-  } else if (event.TAG === "CatalogProductSynced") {
-    return {
-      name: event.name,
-      price: event.price,
-      withdrawn: false
-    };
-  } else {
-    return {
-      name: state.name,
-      price: event.price,
-      withdrawn: state.withdrawn
-    };
+  }
+  switch (event.TAG) {
+    case "CatalogProductSynced" :
+      return {
+        name: event.name,
+        price: event.price,
+        withdrawn: false,
+        productImage: state.productImage
+      };
+    case "CatalogProductPriceChanged" :
+      return {
+        name: state.name,
+        price: event.price,
+        withdrawn: state.withdrawn,
+        productImage: state.productImage
+      };
+    case "CatalogProductImageChanged" :
+      return {
+        name: state.name,
+        price: state.price,
+        withdrawn: state.withdrawn,
+        productImage: event.productImage
+      };
   }
 }
 
@@ -111,6 +124,23 @@ function decide(state, command) {
           _0: []
         };
       }
+    case "ChangeSyncedProductImage" :
+      let productImage = command.productImage;
+      if (Primitive_object.equal(state.productImage, productImage)) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "CatalogProductImageChanged",
+              productId: command.productId,
+              productImage: productImage
+            }]
+        };
+      }
   }
 }
 
@@ -119,7 +149,8 @@ let Spec;
 let initialState = {
   name: "",
   price: undefined,
-  withdrawn: false
+  withdrawn: false,
+  productImage: undefined
 };
 
 let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res.mjs";

package/src/Customer/Aggregate/Customer.res

@@ -93,9 +93,10 @@ let commandTransition = (command: command): Reventless.Transition.t<lifecycleSta
   open Reventless.Transition
   switch command {
   // Registration brings the row into existence, so there is no state it could
-  // come from — and it names no target either, because the row's status is the
-  // view's to derive.
-  | Register(_) => Unrestricted
+  // come from. `Creates` rather than `Unrestricted`, which would claim it is
+  // legal on an already-registered customer — and the scenarios show it inert
+  // there. The target is the state the view puts a fresh row in.
+  | Register(_) => Creates(Customers.Active)
   // A from-set and no target: legal on an active customer, and it does not move
   // them. Each is `Error(CustomerAlreadyDeactivated)` on a deactivated one, so
   // this says exactly what `decide` already enforces — it only stops a menu

package/src/Customer/Aggregate/Customer.res.mjs

@@ -55,6 +55,10 @@ function commandTransition(command) {
   }
   switch (command.TAG) {
     case "Register" :
+      return {
+        TAG: "Creates",
+        _0: "Active"
+      };
     case "SetLocation" :
     case "MarkAddressUnresolvable" :
       return "Unrestricted";

package/src/Extension/Products_Extension.res

@@ -25,6 +25,11 @@ module Mapping = {
     | ProductRelisted({productId: theId}) => [
         PublishStateChangeSliceCommand(RelistSyncedProduct({productId: theId})),
       ]
+    | ProductImageChanged({productId, productImage: ?productImage}) => [
+        PublishStateChangeSliceCommand(
+          ChangeSyncedProductImage({productId, productImage: ?productImage}),
+        ),
+      ]
     }
 
   let mapOutgoingEvent = None

package/src/Extension/Products_Extension.res.mjs

@@ -39,6 +39,15 @@ function mapIncomingEvent(_id, event, _meta, _pluginDef, _queryEngine) {
             productId: event.productId
           }
         }];
+    case "ProductImageChanged" :
+      return [{
+          TAG: "PublishStateChangeSliceCommand",
+          _0: {
+            TAG: "ChangeSyncedProductImage",
+            productId: event.productId,
+            productImage: event.productImage
+          }
+        }];
   }
 }
 
@@ -58,6 +67,10 @@ let handledEvents = [
   {
     name: "ProductRelisted",
     toCommandTypes: ["RelistSyncedProduct"]
+  },
+  {
+    name: "ProductImageChanged",
+    toCommandTypes: ["ChangeSyncedProductImage"]
   }
 ];
 

package/src/ExtensionPoint/Orders_ExtensionPointMapping.res.mjs

@@ -26,7 +26,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/src/LifecycleModel.res

@@ -0,0 +1,20 @@
+// AUTO-GENERATED — do not edit. Run `pnpm run check:lifecycle:update` to update.
+//
+// What ordering's own given/when/then scenarios say about each command: the
+// states one shows it taking effect from, the states those land in, and whether
+// it brings a row into existence. `Plugin_Structure` prefers this to the
+// `@transition` annotation where it says anything, and falls back to the
+// annotation where it is silent.
+
+let model: array<Reventless.Plugin.derivedEdge> = [
+  {component: "CancelOrder", command: "CancelOrder", level: Reventless.Plugin.Instance, allowedStates: ["Placed"], targets: ["Cancelled"]},
+  {component: "CancelOrder", command: "ReopenOrder", level: Reventless.Plugin.Instance, allowedStates: ["Cancelled"], targets: ["Placed"]},
+  {component: "Customer", command: "Deactivate", level: Reventless.Plugin.Instance, allowedStates: ["Active"], targets: ["Deactivated"]},
+  {component: "Customer", command: "Reactivate", level: Reventless.Plugin.Instance, allowedStates: ["Deactivated"], targets: ["Active"]},
+  {component: "Customer", command: "Register", level: Reventless.Plugin.Collection, allowedStates: [], targets: ["Active"]},
+  {component: "Customer", command: "SetAddressLocation", level: Reventless.Plugin.Instance, allowedStates: ["Active"], targets: []},
+  {component: "Customer", command: "UpdateAddress", level: Reventless.Plugin.Instance, allowedStates: ["Active"], targets: []},
+  {component: "Customer", command: "UpdateEmail", level: Reventless.Plugin.Instance, allowedStates: ["Active"], targets: []},
+  {component: "PlaceOrder", command: "PlaceOrder", level: Reventless.Plugin.Collection, allowedStates: [], targets: ["Placed"]},
+  {component: "ShipOrder", command: "ShipOrder", level: Reventless.Plugin.Instance, allowedStates: ["Placed"], targets: ["Shipped"]},
+]

package/src/LifecycleModel.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let model = [
+  {
+    component: "CancelOrder",
+    command: "CancelOrder",
+    level: "Instance",
+    allowedStates: ["Placed"],
+    targets: ["Cancelled"]
+  },
+  {
+    component: "CancelOrder",
+    command: "ReopenOrder",
+    level: "Instance",
+    allowedStates: ["Cancelled"],
+    targets: ["Placed"]
+  },
+  {
+    component: "Customer",
+    command: "Deactivate",
+    level: "Instance",
+    allowedStates: ["Active"],
+    targets: ["Deactivated"]
+  },
+  {
+    component: "Customer",
+    command: "Reactivate",
+    level: "Instance",
+    allowedStates: ["Deactivated"],
+    targets: ["Active"]
+  },
+  {
+    component: "Customer",
+    command: "Register",
+    level: "Collection",
+    allowedStates: [],
+    targets: ["Active"]
+  },
+  {
+    component: "Customer",
+    command: "SetAddressLocation",
+    level: "Instance",
+    allowedStates: ["Active"],
+    targets: []
+  },
+  {
+    component: "Customer",
+    command: "UpdateAddress",
+    level: "Instance",
+    allowedStates: ["Active"],
+    targets: []
+  },
+  {
+    component: "Customer",
+    command: "UpdateEmail",
+    level: "Instance",
+    allowedStates: ["Active"],
+    targets: []
+  },
+  {
+    component: "PlaceOrder",
+    command: "PlaceOrder",
+    level: "Collection",
+    allowedStates: [],
+    targets: ["Placed"]
+  },
+  {
+    component: "ShipOrder",
+    command: "ShipOrder",
+    level: "Instance",
+    allowedStates: ["Placed"],
+    targets: ["Shipped"]
+  }
+];
+
+export {
+  model,
+}
+/* No side effect */

package/src/Notification/AutomationSlice/NotificationIntake.res.mjs

@@ -28,7 +28,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/src/Notification/StateChangeSlice/NotificationPreferences.res.mjs

@@ -185,7 +185,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let name = "NotificationPreferences";

package/src/Notification/StateChangeSlice/NotificationSourceClaims.res.mjs

@@ -55,7 +55,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let name = "NotificationSourceClaims";

package/src/Order/AutomationSlice/AutoShipOrder.res.mjs

@@ -17,7 +17,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/src/Order/StateChangeSlice/PlaceOrder.res

@@ -9,12 +9,25 @@
 // pulled from the catalog would stay orderable forever — the read side deletes
 // the row while the write side keeps saying yes. Both the withdrawal and the way
 // back are consumed, so availability follows the shelf in both directions.
+//
+// The price is read for the same reason the name is, and it is why pricing an
+// order costs nothing here: Ordering already shadows what a placement needs to
+// decide, so the total is computed from this fold rather than from a cross-plugin
+// read or a read-model query issued out of a behaviour.
 @schema
 type consumedEvent =
   | OrderPlaced({orderId: string})
-  | CatalogProductSynced({productId: string})
+  // `name` is read as well as `productId`, so the order can record what the
+  // product was called at the moment it was placed. The catalog publishes it on
+  // both arms already; this slice simply stopped ignoring it.
+  | CatalogProductSynced({productId: string, name: string, price: Reventless.Money.t})
+  | CatalogProductPriceChanged({productId: string, price: Reventless.Money.t})
   | CatalogProductWithdrawn({productId: string})
-  | CatalogProductRelisted({productId: string})
+  | CatalogProductRelisted({productId: string, name: string, price: Reventless.Money.t})
+  // The picture the shelf currently shows, folded for the same reason the name
+  // is: so a placement can copy it onto the order rather than the order having
+  // to ask the catalog later.
+  | CatalogProductImageChanged({productId: string, productImage?: Reventless.UploadableImage.t})
 
 // Declared in the order the UI should present them: the batched default first,
 // then the expedited option, then in-store collection.
@@ -24,6 +37,19 @@ type shippingMethod =
   | Express
   | Pickup
 
+// One thing ordered, and how many of it. A **named** record rather than an inline
+// one: the ppx walks a record type declaration, which is what puts the `@ref` (and
+// with it the DCB tag) on `productId` where an inline record would carry neither.
+//
+// The framework finds the marker at this depth — the reference walk names it
+// `lineItems[].productId`, and the tag walk gives it the key `productId`, which is
+// the same tag the catalog's own events write.
+@schema
+type lineItem = {
+  @ref("AvailableProducts") productId: string,
+  quantity: int,
+}
+
 @schema
 type command =
   PlaceOrder({
@@ -34,7 +60,7 @@ type command =
     // client sends here is ignored rather than trusted. An operator placing an
     // order on someone's behalf is exempt and keeps the value they sent.
     @noDcbTag @owner customerId: string,
-    @ref("AvailableProducts") productIds: array<string>,
+    lineItems: array<lineItem>,
     shippingMethod: shippingMethod,
     // A requested delivery slot, chosen at checkout. An optional field — a
     // Pickup order (or a caller that names no preference) simply omits it, and
@@ -48,13 +74,59 @@ type command =
 type error =
   | OrderAlreadyPlaced
   | ProductsNotAvailable({missing: array<string>})
+  // An order for nothing is the one validation a shopper could trip before line
+  // items existed: an empty product list placed an order and produced no lines.
+  | OrderIsEmpty
+  | InvalidQuantity({productId: string, quantity: int})
+  // Refused rather than silently summed. `Money.add` returns a `result` for
+  // exactly this case, and unwrapping it here would invent a total in whichever
+  // currency happened to come first. Naming the codes says which shelf entries
+  // disagree, the way `ProductsNotAvailable` names the products.
+  | MixedCurrencies({currencies: array<string>})
+
+// One priced line of a placed order, frozen at placement.
+//
+// **The price is the one the decision model held.** A later
+// `CatalogProductPriceChanged` does not rewrite a placed order, which is why the
+// total belongs on the event rather than in the projection.
+@schema
+type orderLine = {
+  productId: string,
+  name: string,
+  quantity: int,
+  unitPrice: Reventless.Money.t,
+  lineTotal: Reventless.Money.t,
+}
 
 @schema
 type event =
   OrderPlaced({
     @partitionTag orderId: string,
     customerId: string,
+    // Redundant against `lines`, and deliberately so. The extension point
+    // decomposes this into one published `ItemOrdered` per product and
+    // `CancelOrder` folds it, so both keep working untouched — and the public
+    // contract in `ordering-spec` does not move, which is what lets the shop
+    // show quantities without redeploying Catalog in lockstep.
     productIds: array<string>,
+    lines: array<orderLine>,
+    total: Reventless.Money.t,
     shippingMethod: shippingMethod,
     deliveryWindow?: Reventless.DateRange.t,
+    // What the first product was called when this order was placed.
+    //
+    // **Captured, not looked up.** An order is a record of what somebody bought,
+    // and the catalog goes on changing afterwards — a rename, a withdrawal, a
+    // reshoot. Reading the name live would rewrite history every time the shop
+    // tidied its shelves, and would leave an order for a withdrawn product with
+    // nothing to show at all.
+    //
+    // Optional because every order placed before this field existed carries no
+    // key, which is what makes adding it cost the log nothing. A reader treats
+    // absent as "not recorded" rather than as a name.
+    firstProductName?: string,
+    // The picture as it was when the order was placed, frozen for the reason the
+    // name is. A reshoot, a withdrawal or a deletion afterwards leaves this
+    // order showing what the shopper actually bought.
+    @storageRef("Catalog.productImages") firstProductImage?: Reventless.UploadableImage.t,
   })