@wocart/storefront 1.18.0 → 1.20.0

package/dist/abandoned-checkout.js

@@ -1,5 +1,10 @@
 import { toLocalAlgerianMobile } from "./phone.js";
-const SESSION_KEY = "cod_session_id";
+/**
+ * Where the browser keeps the checkout's id for the tab (`sessionStorage`):
+ * every capture of one checkout updates one record, and the thank-you page
+ * marks that record converted.
+ */
+export const ABANDONED_CHECKOUT_SESSION_KEY = "cod_session_id";
 const DEBOUNCE_MS = 3000;
 export function createAbandonedCheckoutTracker(ports) {
     let sessionId = readSessionId(ports);
@@ -76,14 +81,87 @@ function readCookie(ports, name) {
 }
 function readSessionId(ports) {
     try {
-        const existing = ports.storage.getItem(SESSION_KEY);
+        const existing = ports.storage.getItem(ABANDONED_CHECKOUT_SESSION_KEY);
         if (existing)
             return existing;
         const created = ports.createId();
-        ports.storage.setItem(SESSION_KEY, created);
+        ports.storage.setItem(ABANDONED_CHECKOUT_SESSION_KEY, created);
         return created;
     }
     catch {
         return ports.createId();
     }
 }
+/**
+ * `createAbandonedCheckoutTracker` wired to the page: the checkout's id in
+ * `sessionStorage`, timers, the Meta cookies, a `keepalive` POST to the
+ * theme's route, and `sendBeacon` when the shopper leaves. A page that blocks
+ * storage still captures; nothing it does can fail the order.
+ */
+export function createBrowserAbandonedCheckoutTracker(options, host = globalThis) {
+    const post = (payload) => (host.fetch ?? globalThis.fetch)(options.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        keepalive: true,
+    });
+    return createAbandonedCheckoutTracker({
+        storage: {
+            getItem: (key) => host.sessionStorage?.getItem(key) ?? null,
+            setItem: (key, value) => host.sessionStorage?.setItem(key, value),
+        },
+        createId: () => uuid(host),
+        schedule: (callback, delayMs) => host.setTimeout(callback, delayMs),
+        cancel: (handle) => host.clearTimeout(handle),
+        readCookie: (name) => cookieValue(host.document?.cookie ?? "", name),
+        send: async (payload) => {
+            await post(payload);
+        },
+        beacon: (payload) => {
+            const sent = host.navigator?.sendBeacon?.(options.endpoint, new Blob([JSON.stringify(payload)], { type: "application/json" })) ?? false;
+            if (!sent)
+                void post(payload).catch(() => undefined);
+        },
+    });
+}
+/**
+ * Marks the tab's checkout converted, from the thank-you page: the merchant
+ * no longer sees the order it became as abandoned. The id is used once and
+ * forgotten. Best-effort — it never throws and never holds the page.
+ */
+export function convertAbandonedCheckout(conversion, host = globalThis) {
+    try {
+        const sessionId = host.sessionStorage?.getItem(ABANDONED_CHECKOUT_SESSION_KEY);
+        if (!sessionId || !conversion.orderId)
+            return;
+        host.sessionStorage?.removeItem(ABANDONED_CHECKOUT_SESSION_KEY);
+        void (host.fetch ?? globalThis.fetch)(conversion.endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sessionId, orderId: conversion.orderId, orderNumber: conversion.orderNumber }),
+            keepalive: true,
+        }).catch(() => undefined);
+    }
+    catch {
+        return;
+    }
+}
+function cookieValue(cookies, name) {
+    for (const part of cookies.split(";")) {
+        const separator = part.indexOf("=");
+        if (separator > 0 && part.slice(0, separator).trim() === name)
+            return part.slice(separator + 1).trim() || undefined;
+    }
+    return undefined;
+}
+/** A version 4 UUID: the platform's `randomUUID`, else one drawn from `getRandomValues`. */
+function uuid(host) {
+    const crypto = host.crypto ?? globalThis.crypto;
+    if (typeof crypto.randomUUID === "function")
+        return crypto.randomUUID();
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/answer-readers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Readers for what this package's server parts hand the browser: the delivery
+ * rates a page carries, a cart quote, and the coupon outcome in it.
+ *
+ * The server built them with `ShippingRatesSchema`, `CartValidationSchema` and
+ * `CouponOutcomeSchema`, so the browser need not run those schemas. A page can still be cached apart
+ * from its scripts, so a value of another version's shape is possible; these
+ * accept exactly what the schemas accept and return what they would — extra
+ * keys left out — without bringing Zod into a shopper's page. A property test
+ * holds each reader to its schema.
+ */
+import type { CartValidation, CouponOutcome, ShippingRates } from "./types.js";
+/**
+ * A cart quote (`CartValidation`) — the `data` of the theme's cart-validate
+ * route — or null when the value is not one. What the quote says is the
+ * server's: lines re-priced from the catalog, rewards, the subtotal, the free
+ * delivery progress, and, when asked, the delivery fee and the coupon's outcome.
+ */
+export declare function readCartQuote(value: unknown): CartValidation | null;
+/** The delivery rates of a value (`ShippingRates`), or null when it is not a rate table. */
+export declare function readShippingRates(value: unknown): ShippingRates | null;
+/** What a coupon did in a quote (`CouponOutcome`), or null when the value is not one. */
+export declare function readCouponOutcome(value: unknown): CouponOutcome | null;

package/dist/answer-readers.js

@@ -0,0 +1,155 @@
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isInteger = (value) => typeof value === "number" && Number.isSafeInteger(value);
+const isNullableString = (value) => value === null || typeof value === "string";
+/** An optional field the schema reads as `.nullish()`: absent stays absent, null and the type are kept, anything else refuses. */
+function nullish(source, key, accepts) {
+    if (!(key in source) || source[key] === undefined)
+        return { ok: true, entry: {} };
+    const value = source[key];
+    return value === null || accepts(value) ? { ok: true, entry: { [key]: value } } : { ok: false, entry: {} };
+}
+const isString = (value) => typeof value === "string";
+const BLOCKERS = ["missing", "unlisted", "out_of_stock"];
+function readQuoteLine(value) {
+    if (!isObject(value))
+        return null;
+    const { productId, variantId, variantLabel, productName, quantity, unitPrice, lineTotal, maxQuantity, blocker } = value;
+    if (typeof productId !== "string" || !isNullableString(variantId) || !isNullableString(variantLabel) || typeof productName !== "string")
+        return null;
+    if (!isInteger(quantity) || !isFiniteNumber(unitPrice) || !isFiniteNumber(lineTotal))
+        return null;
+    if (maxQuantity !== null && !isFiniteNumber(maxQuantity))
+        return null;
+    if (blocker !== null && !(typeof blocker === "string" && BLOCKERS.includes(blocker)))
+        return null;
+    const offerId = nullish(value, "offerId", isString);
+    const offerName = nullish(value, "offerName", isString);
+    const discount = nullish(value, "discount", isFiniteNumber);
+    if (!offerId.ok || !offerName.ok || !discount.ok)
+        return null;
+    return {
+        productId,
+        variantId,
+        variantLabel,
+        productName,
+        quantity,
+        unitPrice,
+        lineTotal,
+        ...offerId.entry,
+        ...offerName.entry,
+        ...discount.entry,
+        maxQuantity,
+        blocker: blocker,
+    };
+}
+function readReward(value) {
+    if (!isObject(value))
+        return null;
+    const { offerId, productId, productName, quantity } = value;
+    if (typeof offerId !== "string" || !isNullableString(productId) || !isNullableString(productName) || !isInteger(quantity))
+        return null;
+    const offerName = nullish(value, "offerName", isString);
+    const variantId = nullish(value, "variantId", isString);
+    const variantLabel = nullish(value, "variantLabel", isString);
+    if (!offerName.ok || !variantId.ok || !variantLabel.ok)
+        return null;
+    return { offerId, ...offerName.entry, productId, productName, ...variantId.entry, ...variantLabel.entry, quantity };
+}
+function readDelivery(value) {
+    if (!isObject(value))
+        return null;
+    if (value.available === true)
+        return isFiniteNumber(value.fee) && isFiniteNumber(value.total) ? { available: true, fee: value.fee, total: value.total } : null;
+    return value.available === false && value.fee === null && value.total === null ? { available: false, fee: null, total: null } : null;
+}
+function readList(value, read) {
+    if (!Array.isArray(value))
+        return null;
+    const items = [];
+    for (const item of value) {
+        const parsed = read(item);
+        if (parsed === null)
+            return null;
+        items.push(parsed);
+    }
+    return items;
+}
+/**
+ * A cart quote (`CartValidation`) — the `data` of the theme's cart-validate
+ * route — or null when the value is not one. What the quote says is the
+ * server's: lines re-priced from the catalog, rewards, the subtotal, the free
+ * delivery progress, and, when asked, the delivery fee and the coupon's outcome.
+ */
+export function readCartQuote(value) {
+    if (!isObject(value) || !isFiniteNumber(value.subtotal))
+        return null;
+    const lines = readList(value.lines, readQuoteLine);
+    const rewards = readList(value.rewards, readReward);
+    if (lines === null || rewards === null)
+        return null;
+    const free = value.freeDelivery;
+    if (!isObject(free) || typeof free.fromOffer !== "boolean" || typeof free.qualified !== "boolean" || !isFiniteNumber(free.remaining))
+        return null;
+    if (free.threshold !== null && !isFiniteNumber(free.threshold))
+        return null;
+    let delivery = null;
+    if ("delivery" in value && value.delivery !== undefined) {
+        delivery = readDelivery(value.delivery);
+        if (delivery === null)
+            return null;
+    }
+    let coupon;
+    if ("coupon" in value && value.coupon !== undefined) {
+        coupon = value.coupon === null ? null : readCouponOutcome(value.coupon);
+        if (coupon === null && value.coupon !== null)
+            return null;
+    }
+    return {
+        lines,
+        subtotal: value.subtotal,
+        rewards,
+        freeDelivery: { fromOffer: free.fromOffer, threshold: free.threshold, qualified: free.qualified, remaining: free.remaining },
+        ...(delivery === null ? {} : { delivery }),
+        ...(coupon === undefined ? {} : { coupon }),
+    };
+}
+/** The delivery rates of a value (`ShippingRates`), or null when it is not a rate table. */
+export function readShippingRates(value) {
+    if (!isObject(value))
+        return null;
+    const rates = {};
+    for (const [wilaya, entry] of Object.entries(value)) {
+        if (wilaya === "__proto__")
+            continue;
+        if (!isObject(entry) || !isFiniteNumber(entry.home) || !isFiniteNumber(entry.stopDesk))
+            return null;
+        rates[wilaya] = { home: entry.home, stopDesk: entry.stopDesk };
+    }
+    return rates;
+}
+/** What a coupon did in a quote (`CouponOutcome`), or null when the value is not one. */
+export function readCouponOutcome(value) {
+    if (!isObject(value) || typeof value.code !== "string")
+        return null;
+    const { code } = value;
+    if (value.applied === true) {
+        if (!isFiniteNumber(value.discount) || typeof value.freeShipping !== "boolean")
+            return null;
+        return { code, applied: true, discount: value.discount, freeShipping: value.freeShipping };
+    }
+    if (value.applied !== false || typeof value.reason !== "string")
+        return null;
+    const { reason, shortBy, startsAt } = value;
+    if (shortBy !== undefined && !isFiniteNumber(shortBy))
+        return null;
+    if (startsAt !== undefined && typeof startsAt !== "string")
+        return null;
+    return {
+        code,
+        applied: false,
+        reason,
+        ...(shortBy === undefined ? {} : { shortBy }),
+        ...(startsAt === undefined ? {} : { startsAt }),
+    };
+}

package/dist/astro.d.ts

@@ -6,3 +6,5 @@ export { placeOrderInput, executePlaceOrder, collectForwardedHeaders, } from "./
 export type { PlaceOrderInput, PlaceOrderResult } from "./actions.js";
 export { runFormAction, resolveActionRedirectDecision } from "./middleware.js";
 export type { PrgDecision, ActionMiddlewareDeps, ActionDescriptor } from "./middleware.js";
+export { notFound, resolvePreviewStore, resolveStoreRequest } from "./store-request.js";
+export type { NotFoundContext, ResolvedStore, StoreRequestOptions, StoreRequestResolution } from "./store-request.js";

package/dist/astro.js

@@ -2,3 +2,4 @@ export { createProxyEndpoint } from "./endpoints/proxy.js";
 export { createStorefrontRoutes, REVIEWS_PAGE_DEFAULT, REVIEWS_PAGE_MAX, } from "./endpoints/storefront-routes.js";
 export { placeOrderInput, executePlaceOrder, collectForwardedHeaders, } from "./actions.js";
 export { runFormAction, resolveActionRedirectDecision } from "./middleware.js";
+export { notFound, resolvePreviewStore, resolveStoreRequest } from "./store-request.js";

package/dist/basket-line.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A basket line's identity and the server's limits for one basket: what the
+ * browser's basket needs to keep itself well-formed. Plain values and no
+ * schema — this module runs in every shopper's browser that holds a basket,
+ * and the schemas that check a basket on the server (`domain.ts`) read the
+ * same limits from here.
+ */
+/** The server's hard limits for one canonical browser basket. */
+export declare const MAX_BASKET_LINES: 20;
+export declare const MAX_BASKET_LINE_QUANTITY: 100;
+/**
+ * Product + variant is the identity of a basket line. A null variant is a
+ * real identity, not the same thing as any selected variant.
+ */
+export declare function basketLineKey(productId: string, variantId: string | null): string;

package/dist/basket-line.js

@@ -0,0 +1,17 @@
+/**
+ * A basket line's identity and the server's limits for one basket: what the
+ * browser's basket needs to keep itself well-formed. Plain values and no
+ * schema — this module runs in every shopper's browser that holds a basket,
+ * and the schemas that check a basket on the server (`domain.ts`) read the
+ * same limits from here.
+ */
+/** The server's hard limits for one canonical browser basket. */
+export const MAX_BASKET_LINES = 20;
+export const MAX_BASKET_LINE_QUANTITY = 100;
+/**
+ * Product + variant is the identity of a basket line. A null variant is a
+ * real identity, not the same thing as any selected variant.
+ */
+export function basketLineKey(productId, variantId) {
+    return `${productId}\u0000${variantId ?? ""}`;
+}

package/dist/basket.d.ts

@@ -9,7 +9,8 @@
  * (or memory fake in server/tests). The server always validates and re-prices
  * every line at checkout.
  */
-import { type BasketLine, type BasketLineInput } from "./domain.js";
+import type { BasketLine, BasketLineInput } from "./domain.js";
+import type { CreateOrderVariantSelection } from "./types.js";
 /** Default key used in browser storage, versioned to prevent schema drift crashes. */
 export declare const DEFAULT_BASKET_STORAGE_KEY = "cod_cart_v1";
 /**
@@ -35,10 +36,12 @@ export interface BasketStoreOptions {
     maxLineQuantity?: number;
 }
 export type BasketListener = (lines: readonly BasketLine[]) => void;
+/** A product line before its variant and quantity: what `addSelections` gives each variant chosen. */
+export type BasketSelectionLine = Omit<BasketLine, "variantId" | "variantLabel" | "quantity">;
 /**
  * Basket Store Interface.
  *
- * Deep module interface: 9 simple, focused methods that hide all storage
+ * Deep module interface: simple, focused methods that hide all storage
  * failures, cross-tab events, line reconciliation, and normalization.
  */
 export interface BasketStore {
@@ -50,6 +53,13 @@ export interface BasketStore {
     getSubtotal(): number;
     /** Add a line. Merges with existing product+variant, caps quantities. */
     addLine(line: BasketLine): readonly BasketLine[];
+    /**
+     * Add a choice made piece by piece — an offer of three in two sizes, as an
+     * order's `variantSelections` carries it: one line per variant, its
+     * quantity the pieces of that variant, as one change. All or nothing: when
+     * the basket has no room for every new line, nothing is added.
+     */
+    addSelections(line: BasketSelectionLine, selections: readonly CreateOrderVariantSelection[]): readonly BasketLine[];
     /** Update quantity of an existing line. Removes if <= 0. */
     setQuantity(key: string, quantity: number): readonly BasketLine[];
     /** Remove a line by its composite key. */

package/dist/basket.js

@@ -9,7 +9,7 @@
  * (or memory fake in server/tests). The server always validates and re-prices
  * every line at checkout.
  */
-import { MAX_BASKET_LINES, MAX_BASKET_LINE_QUANTITY, basketLineKey, } from "./domain.js";
+import { MAX_BASKET_LINES, MAX_BASKET_LINE_QUANTITY, basketLineKey } from "./basket-line.js";
 /** Default key used in browser storage, versioned to prevent schema drift crashes. */
 export const DEFAULT_BASKET_STORAGE_KEY = "cod_cart_v1";
 /**
@@ -227,6 +227,23 @@ export function createBasketStore(options = {}) {
             }
             return commit([...state, line]);
         },
+        addSelections(line, selections) {
+            const pieces = new Map();
+            for (const selection of selections) {
+                const existing = pieces.get(selection.variantId);
+                if (existing)
+                    existing.quantity += 1;
+                else
+                    pieces.set(selection.variantId, { ...line, variantId: selection.variantId, variantLabel: selection.variantLabel ?? null, quantity: 1 });
+            }
+            if (pieces.size === 0)
+                return state;
+            const held = new Set(state.map((l) => basketLineKey(l.productId, l.variantId)));
+            const added = [...pieces.values()].filter((piece) => !held.has(basketLineKey(piece.productId, piece.variantId))).length;
+            if (state.length + added > maxLines)
+                return state;
+            return commit([...state, ...pieces.values()]);
+        },
         setQuantity(key, quantity) {
             if (!Number.isInteger(quantity) || quantity < 1) {
                 return this.removeLine(key);

package/dist/catalog.d.ts

@@ -0,0 +1,18 @@
+/**
+ * How a storefront listing can be ordered, for a theme's sort control. Absent,
+ * a listing keeps its own order: a collection's, a search's best match first,
+ * else newest.
+ */
+export declare const PRODUCT_SORTS: readonly ["newest", "price-ascending", "price-descending"];
+/**
+ * Every step `orders.status()` can name, in a shopper's words, for a theme to
+ * word each one. A newer server may add one; a theme then shows its general
+ * words.
+ */
+export declare const SHOPPER_ORDER_STAGES: readonly ["placed", "confirmed", "preparing", "shipped", "out_for_delivery", "delivered", "returned", "cancelled"];
+/**
+ * The collections every store starts with, the likeliest to hold products
+ * first: what to show when a page needs a collection and none was named (an
+ * editor's preview of the collection template).
+ */
+export declare const DEFAULT_COLLECTION_HANDLES: readonly ["best-sellers", "new-arrivals", "featured"];

package/dist/catalog.js

@@ -0,0 +1,27 @@
+/**
+ * How a storefront listing can be ordered, for a theme's sort control. Absent,
+ * a listing keeps its own order: a collection's, a search's best match first,
+ * else newest.
+ */
+export const PRODUCT_SORTS = ["newest", "price-ascending", "price-descending"];
+/**
+ * Every step `orders.status()` can name, in a shopper's words, for a theme to
+ * word each one. A newer server may add one; a theme then shows its general
+ * words.
+ */
+export const SHOPPER_ORDER_STAGES = [
+    "placed",
+    "confirmed",
+    "preparing",
+    "shipped",
+    "out_for_delivery",
+    "delivered",
+    "returned",
+    "cancelled",
+];
+/**
+ * The collections every store starts with, the likeliest to hold products
+ * first: what to show when a page needs a collection and none was named (an
+ * editor's preview of the collection template).
+ */
+export const DEFAULT_COLLECTION_HANDLES = ["best-sellers", "new-arrivals", "featured"];

package/dist/client/cart.js

@@ -12,7 +12,7 @@
  * keeps its optimistic view and checkout re-validates everything anyway.
  */
 import { CartValidationSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 /**
  * Create cart namespace

package/dist/client/categories.js

@@ -12,7 +12,7 @@
  */
 import { z } from "zod";
 import { CategorySchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { reportDegradedRead } from "./core.js";
 /**

package/dist/client/collections.js

@@ -10,7 +10,7 @@
  * failed read — the page answers a real 404.
  */
 import { StoreCollectionSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 export function createCollectionsNamespace(core) {

package/dist/client/config.js

@@ -15,7 +15,7 @@
  * outage recovers on the next request.
  */
 import { StoreConfigSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { reportDegradedRead } from "./core.js";
 /**

package/dist/client/geo.js

@@ -14,7 +14,7 @@
  */
 import { z } from "zod";
 import { CommuneSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { reportDegradedRead } from "./core.js";
 import { WILAYAS } from "../data/wilayas.js";
 /**

package/dist/client/menus.js

@@ -11,7 +11,7 @@
  * read — the theme renders its own fallback navigation.
  */
 import { StoreMenuSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 export function createMenusNamespace(core) {

package/dist/client/orders.d.ts

@@ -13,7 +13,7 @@
  */
 import { type ClientCore, type ClientResult } from "./core.js";
 import type { AbandonedCheckoutInput } from "../domain.js";
-import type { CreateOrderInput, CreatedOrder, OrderTracking, OtpSendResult, OtpVerifyResult } from "../types.js";
+import type { CreateOrderInput, CreatedOrder, OrderTracking, OtpSendResult, OtpVerifyResult, ShopperOrderProof, ShopperOrderStatus } from "../types.js";
 export interface AbandonedNamespace {
     /**
      * Upsert an abandoned-checkout record — fire-and-forget. `forwardedHeaders`
@@ -62,6 +62,15 @@ export interface OrdersNamespace {
      * the thank-you page fires no conversion at all in that case.
      */
     tracking(orderId: string): Promise<OrderTracking | null>;
+    /**
+     * Where a shopper's order is, proved by its number and the phone it was
+     * placed with: its step in the shopper's words, its lines and total, and
+     * the carrier's tracking number once shipped. A wrong number and a wrong
+     * phone both fail with `ORDER_NOT_FOUND`; too many tries with
+     * `ORDER_LOOKUP_RATE_LIMITED` and `windowSeconds`. `forwardedHeaders`
+     * carries the shopper's address: the limit counts per shopper.
+     */
+    status(proof: ShopperOrderProof, forwardedHeaders?: Record<string, string>): Promise<ClientResult<ShopperOrderStatus>>;
     abandoned: AbandonedNamespace;
     otp: OtpNamespace;
 }

package/dist/client/orders.js

@@ -11,8 +11,8 @@
  * - tracking resolves to null on any failure — firing no conversion event
  *   is recoverable; reporting it to the wrong ad account is not.
  */
-import { CreatedOrderSchema, IdResponseSchema, OrderTrackingSchema, OtpSendResultSchema, OtpVerifyResultSchema, } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { CreatedOrderSchema, IdResponseSchema, OrderTrackingSchema, OtpSendResultSchema, ShopperOrderStatusSchema, OtpVerifyResultSchema, } from "../schemas.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 /**
  * Create orders namespace
@@ -39,6 +39,13 @@ export function createOrdersNamespace(core) {
                 return null;
             }
         },
+        async status(proof, forwardedHeaders) {
+            return core.post("/store/orders/status", { orderNumber: proof.orderNumber, phone: proof.phone }, {
+                ...(forwardedHeaders ? { headers: forwardedHeaders } : {}),
+                schema: ShopperOrderStatusSchema,
+                operation: STOREFRONT_OPERATIONS.ordersStatus,
+            });
+        },
         abandoned: {
             async upsert(body, forwardedHeaders) {
                 // The server answers `{ success, id }` — the payload sits at the

package/dist/client/page-data.js

@@ -17,7 +17,7 @@
  * the next render, subject only to the theme's route cache).
  */
 import { PageDocumentPayloadSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 /**
  * Create the page-data namespace.

package/dist/client/pages.js

@@ -12,7 +12,7 @@
  *   redirects to the store home instead of a dead end.
  */
 import { LandingPageSchema, StorePagePublicSchema } from "../schemas.js";
-import { STOREFRONT_OPERATIONS } from "../domain.js";
+import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 /**

package/dist/client/products.d.ts

@@ -31,11 +31,21 @@ export interface ProductsNamespace {
      */
     list(filters?: ProductListFilters): Promise<ProductList[]>;
     /**
-     * One page of products, and whether another page follows. The server is
-     * asked for one row more than the page, so the answer is exact without a
-     * count query. A failed read is an empty final page, as `list` degrades.
+     * One page of products, whether another page follows, and how many the
+     * whole listing holds. The server is asked for one row more than the page,
+     * so `hasNext` is exact even from a server that does not count. A failed
+     * read is an empty final page, as `list` degrades.
      */
     page(filters?: ProductListFilters): Promise<ProductPage>;
+    /**
+     * The products a shopper's words find — every word in the product's name,
+     * in the client's language or the catalog's, or in its tags — as a page,
+     * with the listing filters, sort and paging. Without a `sort`, products
+     * whose name holds every word come first. Blank words find nothing; a
+     * server that predates search answers an empty page (reported through
+     * `onError`), never the whole catalog.
+     */
+    search(text: string, filters?: ProductListFilters): Promise<ProductPage>;
     /**
      * Reviews sub-namespace
      */