@wocart/storefront 1.8.0 → 1.10.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ follows [semantic versioning](https://semver.org/): breaking changes ship only
 in a new major version, and an export is marked `@deprecated` for at least one
 minor release before a major removes it.
 
+## 1.10.0 — 2026-10-17
+
+### Added
+
+- **Quantity pricing.** `ProductDetail.quantityPricing` (`QuantityPricing`,
+  `QuantityPricingSchema`): a product's price tiers by quantity, each with an
+  optional free delivery — null or absent when it has none.
+  `getQuantityTierViews(pricing, unitPrice)` projects them for tiles (price,
+  per-unit price, saving); the total is the server's cart quote.
+- `CartValidationLine.offerId`: the quantity-pricing offer that priced the
+  line, whose `lineTotal` is then the tier's price. Optional.
+
+## 1.9.0 — 2026-10-17
+
+### Added
+
+- Page type `collection` at `/collections/:handle`: a collection's page,
+  which a merchant's menu can now link to. `storefrontPath("collection", {
+  handle })` builds it, `matchStorefrontPath` recognises it, and the WhatsApp
+  widget counts it as the catalog surface.
+- `store.collections.get(handle)` → `StoreCollection` (handle, title,
+  description, in the client's language), `null` for an unknown handle, which
+  is not reported as a failure. `StoreCollectionSchema`.
+
 ## 1.8.0 — 2026-10-17
 
 ### Added

package/USAGE.md

@@ -105,6 +105,7 @@ break those links.
 | `home` | `/` | the home page | required |
 | `catalog` | `/products` | every product | required |
 | `category` | `/category/:slug` | one category's products | required when the store has categories |
+| `collection` | `/collections/:handle` | one collection's products, in the merchant's order | required — a menu can link to any collection |
 | `product` | `/products/:handle` | one product (its public handle, never an id) | required |
 | `page` | `/pages/:slug` | a legal or merchant page | required — checkout consent links to the store's legal pages |
 | `landing` | `/lp/:slug` | a landing page | required when the store runs landing pages |
@@ -222,6 +223,7 @@ server directly.
 | `productImageSource` | Which photo represents a product (cover → gallery fallback) |
 | `getProductView`, `getProductListView` | Pure price, discount, default-variant, and stock values for detail and list projections |
 | `getOfferTierView` | Pure offer-tier price, compare-price, savings, and free-shipping projection; display-only, never order authority |
+| `getQuantityTierViews` | A product's quantity-pricing tiers as tiles show them — price, per-unit price, saving against the unit price, free delivery; display-only, the total is the server's cart quote |
 | `META_CURRENCY`, `buildMetaProductPayload`, `buildMetaViewContentPayload`, `buildMetaAddToCartPayload`, `buildMetaInitiateCheckoutPayload` | Browser-safe Meta event payloads with the platform currency and catalog shape |
 | `createMetaPixelTracker` | Injected browser-pixel dispatch; the theme supplies the vendor global and keeps bootstrap/timing |
 | `createBasketStore`, `createLocalStorageAdapter`, `createMemoryStorageAdapter`, `DEFAULT_BASKET_STORAGE_KEY` | The browser basket, its storage, and the key it persists under (`cod_cart_v1`) |
@@ -624,8 +626,26 @@ if (!product) {
 ~~~
 
 Product detail includes the product fields, parsed variant options and tags,
-the category, variants, images, review statistics, and offers. The server
-decides whether a product is publicly available.
+the category, variants, images, review statistics, quantity pricing, and
+offers. The server decides whether a product is publicly available.
+
+**Quantity pricing** (`product.quantityPricing`, null when the product has
+none) prices a product by how many are bought — "1 for 2,000 DA, 2 for 3,500
+DA, 3 for 4,500 DA". The highest tier the quantity reaches prices every unit
+at its per-unit price, and a tier may include free delivery for a basket of
+that product alone. A product has at most one offer per order, so it has
+either quantity pricing or offers in `offers`, never both at once.
+
+~~~ts
+const tiles = product.quantityPricing ? getQuantityTierViews(product.quantityPricing, product.price) : [];
+// tiles: [{ quantity, price, perUnit, savingsAmount, savePct, freeShipping }]
+~~~
+
+Show the tiers as choices; never compute the total yourself. The cart quote
+(`POST /api/cart/validate`) answers what the shopper pays — each line's
+`lineTotal` already priced by its tier (`offerId` names the offer), and the
+delivery — and the order charges exactly that. A tier locked to one variant
+(`triggerVariantId`) counts and prices only that variant.
 
 ### Product lists
 
@@ -651,6 +671,11 @@ const onSale = await store.products.list({ onSale: true, limit: 8 });
 - An empty or unknown collection lists nothing — show nothing, never the
   whole catalog instead: "Best sellers" means the merchant's picks.
 - `onSale` is computed: a product priced below its compare-at price.
+- A collection has a page of its own (page type `collection`,
+  `/collections/:handle`) that a merchant's menu can link to. Name it with
+  `store.collections.get(handle)` — title and description in the client's
+  language, `null` for an unknown handle (answer a real 404) — and list it
+  with `products.list({ collection: handle })`.
 - `featured: true` and `ProductList.storeFeatured` are deprecated: they mean
   the `featured` collection.
 

package/dist/client/collections.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Collections Namespace - the merchant's curated product lists
+ *
+ * A collection has a page of its own (`/collections/:handle`, page type
+ * `collection`): `get(handle)` names it — title and description in the
+ * client's language — and `products.list({ collection })` lists its products
+ * in the merchant's order.
+ *
+ * Failure contract: `get(handle)` → null means "no such collection" or a
+ * failed read — the page answers a real 404.
+ */
+import { type ClientCore } from "./core.js";
+import type { StoreCollection } from "../types.js";
+export interface CollectionsNamespace {
+    /** A collection by handle (`best-sellers`). Resolves to `null` for an unknown handle or a failed read. */
+    get(handle: string): Promise<StoreCollection | null>;
+}
+export declare function createCollectionsNamespace(core: ClientCore): CollectionsNamespace;

package/dist/client/collections.js

@@ -0,0 +1,29 @@
+/**
+ * Collections Namespace - the merchant's curated product lists
+ *
+ * A collection has a page of its own (`/collections/:handle`, page type
+ * `collection`): `get(handle)` names it — title and description in the
+ * client's language — and `products.list({ collection })` lists its products
+ * in the merchant's order.
+ *
+ * Failure contract: `get(handle)` → null means "no such collection" or a
+ * failed read — the page answers a real 404.
+ */
+import { StoreCollectionSchema } from "../schemas.js";
+import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { localizedPath } from "./paths.js";
+import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
+export function createCollectionsNamespace(core) {
+    return {
+        async get(handle) {
+            try {
+                return await core.get(localizedPath(core.config, `/store/collections/${encodeURIComponent(handle)}`), StoreCollectionSchema, { operation: STOREFRONT_OPERATIONS.collectionsGet });
+            }
+            catch (error) {
+                if (!isNotFoundAnswer(error))
+                    reportDegradedRead(core.config, error, "collections.get");
+                return null;
+            }
+        },
+    };
+}

package/dist/client/index.d.ts

@@ -2,7 +2,8 @@
  * Store Client Factory — the SDK's front door.
  *
  * One server-side call builds the whole read/write surface a theme needs, over one
- * shared core: config, products, categories, pages, menus, shipping, geo, cart,
+ * shared core: config, products, categories, collections, pages, menus,
+ * shipping, geo, cart,
  * orders. The core is internal — consumers see only namespaces.
  *
  * One core means one connection story for every namespace: every read is
@@ -32,6 +33,7 @@ export declare function createStoreClient(config: StoreScope): {
     categories: import("./categories.js").CategoriesNamespace;
     pages: import("./pages.js").PagesNamespace;
     menus: import("./menus.js").MenusNamespace;
+    collections: import("./collections.js").CollectionsNamespace;
     pageData: import("./page-data.js").PageDataNamespace;
     shipping: import("./shipping.js").ShippingNamespace;
     geo: import("./geo.js").GeoNamespace;

package/dist/client/index.js

@@ -2,7 +2,8 @@
  * Store Client Factory — the SDK's front door.
  *
  * One server-side call builds the whole read/write surface a theme needs, over one
- * shared core: config, products, categories, pages, menus, shipping, geo, cart,
+ * shared core: config, products, categories, collections, pages, menus,
+ * shipping, geo, cart,
  * orders. The core is internal — consumers see only namespaces.
  *
  * One core means one connection story for every namespace: every read is
@@ -32,6 +33,7 @@ import { createProductsNamespace } from "./products.js";
 import { createCategoriesNamespace } from "./categories.js";
 import { createPagesNamespace } from "./pages.js";
 import { createMenusNamespace } from "./menus.js";
+import { createCollectionsNamespace } from "./collections.js";
 import { createPageDataNamespace } from "./page-data.js";
 import { createShippingNamespace } from "./shipping.js";
 import { createGeoNamespace } from "./geo.js";
@@ -46,6 +48,7 @@ export function createStoreClient(config) {
         categories: createCategoriesNamespace(core),
         pages: createPagesNamespace(core),
         menus: createMenusNamespace(core),
+        collections: createCollectionsNamespace(core),
         pageData: createPageDataNamespace(core),
         shipping: createShippingNamespace(core),
         geo: createGeoNamespace(core),

package/dist/domain.d.ts

@@ -354,6 +354,7 @@ export declare const STOREFRONT_OPERATIONS: {
     readonly pagesGet: "pages.get";
     readonly pagesLanding: "pages.landing";
     readonly menusGet: "menus.get";
+    readonly collectionsGet: "collections.get";
     readonly shippingRates: "shipping.rates";
     readonly shippingRate: "shipping.rate";
     readonly geoCommunes: "geo.communes";
@@ -392,6 +393,7 @@ export declare const STOREFRONT_RETRY_POLICIES: {
     readonly "pages.get": "safe-read";
     readonly "pages.landing": "safe-read";
     readonly "menus.get": "safe-read";
+    readonly "collections.get": "safe-read";
     readonly "products.get": "safe-read";
     readonly "products.list": "safe-read";
     readonly "products.reviews.list": "safe-read";

package/dist/domain.js

@@ -207,6 +207,7 @@ export const STOREFRONT_OPERATIONS = {
     pagesGet: "pages.get",
     pagesLanding: "pages.landing",
     menusGet: "menus.get",
+    collectionsGet: "collections.get",
     shippingRates: "shipping.rates",
     shippingRate: "shipping.rate",
     geoCommunes: "geo.communes",
@@ -244,6 +245,7 @@ export const STOREFRONT_RETRY_POLICIES = {
     [STOREFRONT_OPERATIONS.pagesGet]: "safe-read",
     [STOREFRONT_OPERATIONS.pagesLanding]: "safe-read",
     [STOREFRONT_OPERATIONS.menusGet]: "safe-read",
+    [STOREFRONT_OPERATIONS.collectionsGet]: "safe-read",
     [STOREFRONT_OPERATIONS.productsGet]: "safe-read",
     [STOREFRONT_OPERATIONS.productsList]: "safe-read",
     [STOREFRONT_OPERATIONS.productsReviewsList]: "safe-read",

package/dist/index.d.ts

@@ -34,8 +34,8 @@ export * from "./types.js";
 export * from "./schemas.js";
 export * from "./domain.js";
 export * from "./product-view.js";
-export { getOfferTierView } from "./offer-view.js";
-export type { OfferTierInput, OfferTierView } from "./offer-view.js";
+export { getOfferTierView, getQuantityTierViews } from "./offer-view.js";
+export type { OfferTierInput, OfferTierView, QuantityTierView } from "./offer-view.js";
 export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
 export type { AbandonedCheckoutPorts, AbandonedCheckoutSnapshot, AbandonedCheckoutStorage, AbandonedCheckoutTracker, } from "./abandoned-checkout.js";
 export { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";

package/dist/index.js

@@ -25,6 +25,6 @@ export * from "./types.js";
 export * from "./schemas.js";
 export * from "./domain.js";
 export * from "./product-view.js";
-export { getOfferTierView } from "./offer-view.js";
+export { getOfferTierView, getQuantityTierViews } from "./offer-view.js";
 export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
 export { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";

package/dist/offer-view.d.ts

@@ -1,4 +1,4 @@
-import type { Offer } from "./types.js";
+import type { Offer, QuantityPricing } from "./types.js";
 export interface OfferTierView {
     isFreeShipping: boolean;
     savePct: number;
@@ -8,3 +8,20 @@ export interface OfferTierView {
 }
 export type OfferTierInput = Pick<Offer, "discountType" | "triggerQuantity" | "rewardQuantity" | "rewardUnitPrice">;
 export declare function getOfferTierView(offer: OfferTierInput, basePrice: number, comparePrice: number | null): OfferTierView;
+export interface QuantityTierView {
+    quantity: number;
+    /** What that many units cost. */
+    price: number;
+    /** What one unit costs within the tier, rounded to the dinar. */
+    perUnit: number;
+    /** What the tier saves against buying that many at `unitPrice`; 0 when it saves nothing. */
+    savingsAmount: number;
+    savePct: number;
+    freeShipping: boolean;
+}
+/**
+ * The tiers of a product's quantity pricing as tiles show them: price, per-unit
+ * price and saving against the product's unit price. Presentation only — the
+ * total for a quantity is the server's cart quote.
+ */
+export declare function getQuantityTierViews(pricing: Pick<QuantityPricing, "tiers">, unitPrice: number): QuantityTierView[];

package/dist/offer-view.js

@@ -15,3 +15,24 @@ export function getOfferTierView(offer, basePrice, comparePrice) {
         comparePrice: comparePrice === null ? null : comparePrice * offer.triggerQuantity,
     };
 }
+/**
+ * The tiers of a product's quantity pricing as tiles show them: price, per-unit
+ * price and saving against the product's unit price. Presentation only — the
+ * total for a quantity is the server's cart quote.
+ */
+export function getQuantityTierViews(pricing, unitPrice) {
+    return [...pricing.tiers]
+        .sort((a, b) => a.quantity - b.quantity)
+        .map((tier) => {
+        const listValue = unitPrice * tier.quantity;
+        const savingsAmount = Math.max(0, listValue - tier.price);
+        return {
+            quantity: tier.quantity,
+            price: tier.price,
+            perUnit: Math.round(tier.price / tier.quantity),
+            savingsAmount,
+            savePct: listValue > 0 ? Math.round((savingsAmount / listValue) * 100) : 0,
+            freeShipping: tier.freeShipping,
+        };
+    });
+}

package/dist/routes.d.ts

@@ -20,6 +20,7 @@ export declare const STOREFRONT_PAGE_PATHS: {
     readonly home: "/";
     readonly catalog: "/products";
     readonly category: "/category/:slug";
+    readonly collection: "/collections/:handle";
     readonly product: "/products/:handle";
     readonly page: "/pages/:slug";
     readonly landing: "/lp/:slug";

package/dist/routes.js

@@ -3,6 +3,7 @@ export const STOREFRONT_PAGE_PATHS = {
     home: "/",
     catalog: "/products",
     category: "/category/:slug",
+    collection: "/collections/:handle",
     product: "/products/:handle",
     page: "/pages/:slug",
     landing: "/lp/:slug",
@@ -58,6 +59,7 @@ const WIDGET_SURFACE = {
     home: "home",
     catalog: "catalog",
     category: "catalog",
+    collection: "catalog",
     product: "product",
     page: "pages",
     landing: "landing",

package/dist/schemas.d.ts

@@ -43,6 +43,21 @@ export declare const OfferSchema: z.ZodObject<{
     rewardVariantLabel: z.ZodNullable<z.ZodString>;
     rewardUnitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
+/**
+ * Quantity pricing — price tiers by quantity ("2 for 3,500 DA"). The highest
+ * tier the quantity reaches prices every unit at its per-unit price; the
+ * server's cart quote is the total.
+ */
+export declare const QuantityPricingSchema: z.ZodObject<{
+    offerId: z.ZodString;
+    name: z.ZodString;
+    triggerVariantId: z.ZodNullable<z.ZodString>;
+    tiers: z.ZodArray<z.ZodObject<{
+        quantity: z.ZodNumber;
+        price: z.ZodNumber;
+        freeShipping: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const CategorySchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -201,6 +216,16 @@ export declare const ProductSchema: z.ZodObject<{
         avgRating: z.ZodNumber;
         reviewCount: z.ZodNumber;
     }, z.core.$strip>>;
+    quantityPricing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        offerId: z.ZodString;
+        name: z.ZodString;
+        triggerVariantId: z.ZodNullable<z.ZodString>;
+        tiers: z.ZodArray<z.ZodObject<{
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            freeShipping: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     offers: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -246,6 +271,12 @@ interface StoreMenuItemShape {
     type: string;
     children: StoreMenuItemShape[];
 }
+/** A collection's page — GET /store/collections/{handle}. Its products come from `products.list({ collection })`. */
+export declare const StoreCollectionSchema: z.ZodObject<{
+    handle: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
 export declare const StoreMenuSchema: z.ZodObject<{
     handle: z.ZodString;
     title: z.ZodString;
@@ -623,6 +654,16 @@ export declare const LandingPageSchema: z.ZodObject<{
             avgRating: z.ZodNumber;
             reviewCount: z.ZodNumber;
         }, z.core.$strip>>;
+        quantityPricing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            offerId: z.ZodString;
+            name: z.ZodString;
+            triggerVariantId: z.ZodNullable<z.ZodString>;
+            tiers: z.ZodArray<z.ZodObject<{
+                quantity: z.ZodNumber;
+                price: z.ZodNumber;
+                freeShipping: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
         offers: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;
@@ -671,6 +712,7 @@ export declare const CartValidationLineSchema: z.ZodObject<{
     quantity: z.ZodNumber;
     unitPrice: z.ZodNumber;
     lineTotal: z.ZodNumber;
+    offerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     maxQuantity: z.ZodNullable<z.ZodNumber>;
     blocker: z.ZodNullable<z.ZodEnum<{
         missing: "missing";
@@ -693,6 +735,7 @@ export declare const CartValidationSchema: z.ZodObject<{
         quantity: z.ZodNumber;
         unitPrice: z.ZodNumber;
         lineTotal: z.ZodNumber;
+        offerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         maxQuantity: z.ZodNullable<z.ZodNumber>;
         blocker: z.ZodNullable<z.ZodEnum<{
             missing: "missing";

package/dist/schemas.js

@@ -42,6 +42,21 @@ export const OfferSchema = z.object({
     // it omits the field, and the product's own price stands in for the gift.
     rewardUnitPrice: z.number().nullish(),
 });
+/**
+ * Quantity pricing — price tiers by quantity ("2 for 3,500 DA"). The highest
+ * tier the quantity reaches prices every unit at its per-unit price; the
+ * server's cart quote is the total.
+ */
+export const QuantityPricingSchema = z.object({
+    offerId: z.string(),
+    name: z.string(),
+    triggerVariantId: z.string().nullable(),
+    tiers: z.array(z.object({
+        quantity: z.number().int(),
+        price: z.number().int(),
+        freeShipping: z.boolean(),
+    })),
+});
 const productCategorySchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -122,6 +137,11 @@ export const ProductSchema = z.object({
     variants: z.array(ProductVariantSchema),
     images: z.array(ProductImageSchema),
     reviewStats: reviewStatsSchema.nullable(),
+    /**
+     * The product's live quantity pricing; null or absent when it has none
+     * (absent from a server that predates it).
+     */
+    quantityPricing: QuantityPricingSchema.nullish(),
     offers: z.array(OfferSchema),
 });
 export const StorePagePublicSchema = z.object({
@@ -145,6 +165,12 @@ export const StoreMenuItemSchema = z.lazy(() => z.object({
     type: z.string(),
     children: z.array(StoreMenuItemSchema),
 }));
+/** A collection's page — GET /store/collections/{handle}. Its products come from `products.list({ collection })`. */
+export const StoreCollectionSchema = z.object({
+    handle: z.string(),
+    title: z.string(),
+    description: z.string().nullable(),
+});
 export const StoreMenuSchema = z.object({
     handle: z.string(),
     title: z.string(),
@@ -325,6 +351,8 @@ export const CartValidationLineSchema = z.object({
     quantity: z.number().int(),
     unitPrice: z.number(),
     lineTotal: z.number(),
+    /** The quantity-pricing offer that set `lineTotal`; absent from a server that predates offers on lines. */
+    offerId: z.string().nullish(),
     maxQuantity: z.number().nullable(),
     blocker: z.enum(["missing", "unlisted", "out_of_stock"]).nullable(),
 });

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ProductSchema, ProductListSchema, CategorySchema, ProductImageSchema, ProductVariantSchema, OfferSchema, PageDocumentPayloadSchema } from "./schemas.js";
+import { ProductSchema, ProductListSchema, CategorySchema, ProductImageSchema, ProductVariantSchema, OfferSchema, QuantityPricingSchema, PageDocumentPayloadSchema } from "./schemas.js";
 export type Product = z.infer<typeof ProductSchema>;
 export type ProductList = z.infer<typeof ProductListSchema>;
 /** Compact catalog projection used in grids, cards and search results. */
@@ -10,6 +10,9 @@ export type Category = z.infer<typeof CategorySchema>;
 export type ProductImage = z.infer<typeof ProductImageSchema>;
 export type ProductVariant = z.infer<typeof ProductVariantSchema>;
 export type Offer = z.infer<typeof OfferSchema>;
+/** A product's quantity pricing — `ProductDetail.quantityPricing`. */
+export type QuantityPricing = z.infer<typeof QuantityPricingSchema>;
+export type QuantityPricingTier = QuantityPricing["tiers"][number];
 /**
  * One store's saved composition document for one surface. Transport shape
  * only — `sections` items are `unknown`; the theme
@@ -212,6 +215,13 @@ export interface StorePagePublic {
     metaTitle: string | null;
     metaDescription: string | null;
 }
+/** A collection as its page names it — GET /store/collections/{handle}. */
+export interface StoreCollection {
+    handle: string;
+    /** In the client's language when the store translated it, else the primary. */
+    title: string;
+    description: string | null;
+}
 /** A navigation menu — GET /store/menus/{handle}. */
 export interface StoreMenu {
     handle: string;
@@ -300,7 +310,10 @@ export interface CartValidationLine {
     quantity: number;
     /** CURRENT catalog price — the cart's optimistic price is display-only. */
     unitPrice: number;
+    /** What the line costs: unit price × quantity, or its quantity-pricing tier's price. */
     lineTotal: number;
+    /** The quantity-pricing offer that set `lineTotal`; null or absent at the catalog price. */
+    offerId?: string | null | undefined;
     /** Units still available; null when the product is not stock-tracked. */
     maxQuantity: number | null;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wocart/storefront",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Typed, validated SDK for Wocart cash-on-delivery storefronts: catalog reads, basket, checkout, OTP and order tracking, with Astro adapters.",
   "keywords": [
     "wocart",