@mohasinac/appkit 2.6.3 → 2.6.5

package/dist/_internal/shared/actions/action-registry.d.ts

@@ -0,0 +1,84 @@
+/**
+ * CTA Action Registry — SB-UNI-W-1 shell (foundation only) 2026-05-13.
+ *
+ * Single source of truth for every CTA label, aria-label, permission, scope
+ * and confirmation across the app. Phase 7 W-2..W-4 sweeps the existing
+ * UI to consume `action(...)` references instead of inline strings.
+ *
+ * Shape (per spec):
+ *   ACTIONS.{RESOURCE}.{actionId}: ActionDef
+ *
+ * Helpers:
+ *   action(resource, id)          → ActionDef | null
+ *   canPerformAction(actionDef, role) → boolean (permission gate)
+ *   actionsForListingType(scope)  → ActionDef[] (filter by listingTypeScope)
+ *   actionLabel(actionDef)        → resolved label (LabelsProvider override hook)
+ *
+ * Extended <Button action={...}> in `ui/components/Button.tsx` is the W-1
+ * cohort's other half — wire to it when the consumer surfaces start
+ * adopting actions in W-2..W-4.
+ *
+ * This file ships the SHELL only — the per-resource action leaves are
+ * intentionally sparse so the W-2..W-4 sweeps can fill them surface-by-
+ * surface without merge churn here.
+ */
+import type { UserRole } from "../../../features/auth/types";
+import type { ListingType } from "../../../features/products/types/index";
+import type { CategoryType } from "../../../features/categories/types/index";
+/** What KIND of action — drives default UI affordance (link vs button vs danger). */
+export type ActionKind = "primary" | "secondary" | "danger" | "ghost" | "link" | "chip";
+/** Resource bucket — keyed top-level in the ACTIONS tree. */
+export type ActionResource = "PRODUCT" | "AUCTION" | "PRE_ORDER" | "PRIZE_DRAW" | "CLASSIFIED" | "DIGITAL_CODE" | "LIVE" | "BUNDLE" | "GROUP" | "CATEGORY" | "BRAND" | "SUBLISTING" | "STORE" | "BLOG" | "EVENT" | "USER" | "SELLER" | "ADMIN" | "CART" | "CHECKOUT" | "NAV" | "MEDIA" | "SUPPORT";
+/** Confirmation modal config — when set, <Button action={...}> opens
+ *  a confirm dialog before firing the actual handler. */
+export interface ActionConfirmation {
+    /** Title shown in the confirm dialog. */
+    title: string;
+    /** Body shown in the confirm dialog. */
+    body: string;
+    /** Confirm button label. */
+    confirmLabel: string;
+    /** Cancel button label (defaults to "Cancel"). */
+    cancelLabel?: string;
+    /** Visual variant of the confirm button. */
+    confirmKind?: ActionKind;
+}
+/** One CTA registration. */
+export interface ActionDef {
+    /** Stable id, e.g. "product.add-to-cart". */
+    id: string;
+    /** User-visible label (English default; i18n overrides land via LabelsProvider). */
+    label: string;
+    /** Optional aria-label override (defaults to `label`). */
+    ariaLabel?: string;
+    /** One-line semantic comment — surfaces in dev tooling + audit reports. */
+    description: string;
+    /** Affordance hint. */
+    kind: ActionKind;
+    /** Optional target route — useful for Link-style actions. */
+    target?: string;
+    /** Roles that may perform this action; absent = anyone authed. */
+    permissions?: readonly UserRole[];
+    /** Listing-type scope — surfaces this action only on these listingTypes. */
+    listingTypeScope?: readonly ListingType[];
+    /** Category-type scope — same but for category discriminators. */
+    categoryTypeScope?: readonly CategoryType[];
+    /** Optional icon name (resolved by the consumer's icon set). */
+    iconKey?: string;
+    /** Optional confirmation modal config. */
+    confirmation?: ActionConfirmation;
+}
+export type ActionTree = Record<ActionResource, Record<string, ActionDef>>;
+/** Pluck an `ActionDef` by resource + id. Returns null when missing. */
+export declare function action(tree: ActionTree, resource: ActionResource, id: string): ActionDef | null;
+/** Permission gate — returns true when the role may perform the action.
+ *  Admin always passes. No `permissions` field = anyone authed passes. */
+export declare function canPerformAction(def: ActionDef, role: UserRole | undefined): boolean;
+/** Filter the registry to actions scoped to the given listingType. */
+export declare function actionsForListingType(tree: ActionTree, listingType: ListingType): ActionDef[];
+/** Resolve the label — placeholder for LabelsProvider i18n override.
+ *  Today returns the English default; Phase 7 wires the override hook. */
+export declare function actionLabel(def: ActionDef): string;
+export declare const ACTIONS: ActionTree;
+/** Sugar — `act("PRODUCT", "add-to-cart")` reads more naturally at call sites. */
+export declare function act(resource: ActionResource, id: string): ActionDef | null;

package/dist/_internal/shared/actions/action-registry.js

@@ -0,0 +1,160 @@
+/**
+ * CTA Action Registry — SB-UNI-W-1 shell (foundation only) 2026-05-13.
+ *
+ * Single source of truth for every CTA label, aria-label, permission, scope
+ * and confirmation across the app. Phase 7 W-2..W-4 sweeps the existing
+ * UI to consume `action(...)` references instead of inline strings.
+ *
+ * Shape (per spec):
+ *   ACTIONS.{RESOURCE}.{actionId}: ActionDef
+ *
+ * Helpers:
+ *   action(resource, id)          → ActionDef | null
+ *   canPerformAction(actionDef, role) → boolean (permission gate)
+ *   actionsForListingType(scope)  → ActionDef[] (filter by listingTypeScope)
+ *   actionLabel(actionDef)        → resolved label (LabelsProvider override hook)
+ *
+ * Extended <Button action={...}> in `ui/components/Button.tsx` is the W-1
+ * cohort's other half — wire to it when the consumer surfaces start
+ * adopting actions in W-2..W-4.
+ *
+ * This file ships the SHELL only — the per-resource action leaves are
+ * intentionally sparse so the W-2..W-4 sweeps can fill them surface-by-
+ * surface without merge churn here.
+ */
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/** Pluck an `ActionDef` by resource + id. Returns null when missing. */
+export function action(tree, resource, id) {
+    const bucket = tree[resource];
+    if (!bucket)
+        return null;
+    return bucket[id] ?? null;
+}
+/** Permission gate — returns true when the role may perform the action.
+ *  Admin always passes. No `permissions` field = anyone authed passes. */
+export function canPerformAction(def, role) {
+    if (role === "admin")
+        return true;
+    if (!def.permissions || def.permissions.length === 0) {
+        return Boolean(role); // anyone authed
+    }
+    if (!role)
+        return false;
+    return def.permissions.includes(role);
+}
+/** Filter the registry to actions scoped to the given listingType. */
+export function actionsForListingType(tree, listingType) {
+    const out = [];
+    for (const bucket of Object.values(tree)) {
+        for (const def of Object.values(bucket)) {
+            if (!def.listingTypeScope || def.listingTypeScope.includes(listingType)) {
+                out.push(def);
+            }
+        }
+    }
+    return out;
+}
+/** Resolve the label — placeholder for LabelsProvider i18n override.
+ *  Today returns the English default; Phase 7 wires the override hook. */
+export function actionLabel(def) {
+    return def.label;
+}
+// ─── Sparse seed tree ────────────────────────────────────────────────────────
+// Phase 7 W-2..W-4 sweeps fill these out resource-by-resource. The shell
+// just establishes the shape + a few "obvious" actions that other Phase 5
+// flows can reference today.
+export const ACTIONS = {
+    PRODUCT: {
+        "add-to-cart": {
+            id: "product.add-to-cart",
+            label: "Add to cart",
+            description: "Add a standard listing to the buyer's cart.",
+            kind: "primary",
+            listingTypeScope: ["standard", "pre-order", "prize-draw", "digital-code", "live"],
+        },
+        "buy-now": {
+            id: "product.buy-now",
+            label: "Buy now",
+            description: "Skip cart and head straight to checkout for this listing.",
+            kind: "primary",
+            listingTypeScope: ["standard", "pre-order"],
+        },
+    },
+    AUCTION: {
+        "place-bid": {
+            id: "auction.place-bid",
+            label: "Place bid",
+            description: "Submit a bid on an auction listing.",
+            kind: "primary",
+            listingTypeScope: ["auction"],
+        },
+        "buy-it-now": {
+            id: "auction.buy-it-now",
+            label: "Buy It Now",
+            description: "Skip bidding and purchase at the BIN price (SB-UNI-H). Hidden once bidsHaveStarted is true.",
+            kind: "secondary",
+            listingTypeScope: ["auction"],
+        },
+    },
+    PRE_ORDER: {},
+    PRIZE_DRAW: {},
+    CLASSIFIED: {
+        "contact-seller": {
+            id: "classified.contact-seller",
+            label: "Contact seller",
+            description: "Open a conversations thread with the seller — classified flow (SB-UNI-M).",
+            kind: "primary",
+            listingTypeScope: ["classified"],
+        },
+    },
+    DIGITAL_CODE: {},
+    LIVE: {},
+    BUNDLE: {
+        "add-bundle-to-cart": {
+            id: "bundle.add-to-cart",
+            label: "Add bundle to cart",
+            description: "Add a categoryType:'bundle' to the cart (SB-UNI-Bundle-Checkout).",
+            kind: "primary",
+            categoryTypeScope: ["bundle"],
+        },
+    },
+    GROUP: {},
+    CATEGORY: {},
+    BRAND: {},
+    SUBLISTING: {},
+    STORE: {},
+    BLOG: {},
+    EVENT: {},
+    USER: {},
+    SELLER: {},
+    ADMIN: {},
+    CART: {
+        "clear-cart": {
+            id: "cart.clear",
+            label: "Clear cart",
+            description: "Remove every item from the buyer's cart.",
+            kind: "danger",
+            confirmation: {
+                title: "Clear your cart?",
+                body: "Every item will be removed. This can't be undone.",
+                confirmLabel: "Clear cart",
+                confirmKind: "danger",
+            },
+        },
+    },
+    CHECKOUT: {
+        "place-order": {
+            id: "checkout.place-order",
+            label: "Place order",
+            description: "Submit the order with the chosen payment method.",
+            kind: "primary",
+        },
+    },
+    NAV: {},
+    MEDIA: {},
+    SUPPORT: {},
+};
+/** Sugar — `act("PRODUCT", "add-to-cart")` reads more naturally at call sites. */
+export function act(resource, id) {
+    return action(ACTIONS, resource, id);
+}

package/dist/_internal/shared/checkout/rules/_defaults.d.ts

@@ -0,0 +1,3 @@
+/** Default ListingCheckoutRule hook implementations. */
+import type { ListingCheckoutRule } from "./types";
+export declare const DEFAULT_LISTING_RULE: Omit<ListingCheckoutRule, "orderType">;

package/dist/_internal/shared/checkout/rules/_defaults.js

@@ -0,0 +1,22 @@
+/** Default ListingCheckoutRule hook implementations. */
+import { STANDARD_MAX_QTY_PER_LINE } from "./_limits";
+export const DEFAULT_LISTING_RULE = {
+    purchaseable: true,
+    cartEligible: true,
+    requiresShippingAddress: true,
+    requiresConsentOtp: true,
+    nonRefundable: false,
+    maxQuantityPerLine: STANDARD_MAX_QTY_PER_LINE,
+    canMergeWithSameProduct: true,
+    maxLinesPerOrder: Infinity,
+    refundPolicy: { full: true, partial: true, partialGranularity: "item" },
+    splitKey: (item) => `standard:${item.storeId ?? "unknown"}`,
+    splitMultipleOrders: (item) => [item],
+    preflightChecks: (_pairs) => { },
+    stockDecrementExtras: (_product, _qty) => ({}),
+    decorateOrderItem: (line, product) => ({
+        ...line,
+        ...(product.listingType ? { listingType: product.listingType } : {}),
+    }),
+    decorateOrderDoc: (_groupFirstItem, _groupFirstProduct) => ({}),
+};

package/dist/_internal/shared/checkout/rules/_limits.d.ts

@@ -0,0 +1,19 @@
+/** Checkout window / capacity constants — single source of truth. */
+/** Maximum distinct line items in one cart (hard cap, already enforced at addToCart). */
+export declare const CART_MAX_ITEMS = 50;
+/**
+ * Maximum number of order documents that can be created in one checkout
+ * transaction.  If the cart produces more groups than this the checkout is
+ * rejected.
+ */
+export declare const CHECKOUT_MAX_ORDERS_PER_TX = 20;
+/**
+ * Maximum prize-draw reveal entries per order document.  Buying 7 entries
+ * produces three orders: [3, 3, 1].  Each order has its own independent
+ * reveal flow.
+ */
+export declare const PRIZE_DRAW_MAX_REVEALS_PER_ORDER = 3;
+/** Maximum qty per bundle purchase (bundles are always single-shot direct buys). */
+export declare const BUNDLE_MAX_QTY_PER_TX = 1;
+/** Standard / pre-order max qty per cart line (enforced at addToCart). */
+export declare const STANDARD_MAX_QTY_PER_LINE = 99;

package/dist/_internal/shared/checkout/rules/_limits.js

@@ -0,0 +1,19 @@
+/** Checkout window / capacity constants — single source of truth. */
+/** Maximum distinct line items in one cart (hard cap, already enforced at addToCart). */
+export const CART_MAX_ITEMS = 50;
+/**
+ * Maximum number of order documents that can be created in one checkout
+ * transaction.  If the cart produces more groups than this the checkout is
+ * rejected.
+ */
+export const CHECKOUT_MAX_ORDERS_PER_TX = 20;
+/**
+ * Maximum prize-draw reveal entries per order document.  Buying 7 entries
+ * produces three orders: [3, 3, 1].  Each order has its own independent
+ * reveal flow.
+ */
+export const PRIZE_DRAW_MAX_REVEALS_PER_ORDER = 3;
+/** Maximum qty per bundle purchase (bundles are always single-shot direct buys). */
+export const BUNDLE_MAX_QTY_PER_TX = 1;
+/** Standard / pre-order max qty per cart line (enforced at addToCart). */
+export const STANDARD_MAX_QTY_PER_LINE = 99;

package/dist/_internal/shared/checkout/rules/_registry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Checkout rule registry — S-SBUNI-RULES 2026-05-13.
+ *
+ * Adding a new ListingType later means:
+ *   1. Create `<type>.rule.ts` with just the overrides from DEFAULT_LISTING_RULE
+ *   2. Add a capability row in `_internal/shared/listing-types/capabilities.ts`
+ *   3. Add the import + entry to CHECKOUT_RULES below
+ *
+ * No grep of the consumer codebase needed.
+ */
+import type { ListingType } from "../../../../features/products/types/index";
+import type { CartItemDocument } from "../../../../features/cart/schemas/firestore";
+import type { ListingCheckoutRule, CategoryCheckoutRule, CartItemProductPair } from "./types";
+import type { OrderType } from "../../../../features/orders/utils/order-splitter";
+export declare const CHECKOUT_RULES: Record<ListingType, ListingCheckoutRule>;
+export declare const CATEGORY_CHECKOUT_RULES: Record<string, CategoryCheckoutRule>;
+/**
+ * Lookup the checkout rule for a listing type. Every consumer that used to
+ * inline `if (listingType === "X")` should call this instead.
+ */
+export declare function getListingRule(listingType: ListingType): ListingCheckoutRule;
+/**
+ * Lookup the checkout rule for a category type. Returns null for
+ * non-purchaseable category types (sublisting, brand, category).
+ */
+export declare function getCategoryRule(categoryType: string): CategoryCheckoutRule | null;
+/**
+ * Pick the OrderType for a cart item — replaces the if/else cascade in
+ * splitCartIntoOrderGroups.
+ */
+export declare function pickOrderType(item: CartItemDocument): OrderType;
+/**
+ * Get the order-grouping split key for a cart item — replaces the inline
+ * key construction in splitCartIntoOrderGroups.
+ */
+export declare function getSplitKey(item: CartItemDocument): string;
+/**
+ * Run all synchronous preflight guards across a cart.  Each item is tested
+ * against its type's rule.  Throws ValidationError on first violation.
+ *
+ * Note: the async maxPerUser cap check remains in the server-only
+ * `enforceMaxPerUserForCart` (prize-bundle-gates.ts) and runs separately.
+ */
+export declare function runSyncPreflight(pairs: CartItemProductPair[]): void;

package/dist/_internal/shared/checkout/rules/_registry.js

@@ -0,0 +1,87 @@
+/**
+ * Checkout rule registry — S-SBUNI-RULES 2026-05-13.
+ *
+ * Adding a new ListingType later means:
+ *   1. Create `<type>.rule.ts` with just the overrides from DEFAULT_LISTING_RULE
+ *   2. Add a capability row in `_internal/shared/listing-types/capabilities.ts`
+ *   3. Add the import + entry to CHECKOUT_RULES below
+ *
+ * No grep of the consumer codebase needed.
+ */
+import { standardRule } from "./standard.rule";
+import { auctionRule } from "./auction.rule";
+import { preOrderRule } from "./preorder.rule";
+import { prizeDrawRule } from "./prize-draw.rule";
+import { offerRule } from "./offer.rule";
+import { bundleRule } from "./bundle.rule";
+import { classifiedRule } from "./classified.rule";
+import { digitalCodeRule } from "./digital-code.rule";
+import { liveRule } from "./live.rule";
+export const CHECKOUT_RULES = {
+    standard: standardRule,
+    auction: auctionRule,
+    "pre-order": preOrderRule,
+    "prize-draw": prizeDrawRule,
+    classified: classifiedRule,
+    "digital-code": digitalCodeRule,
+    live: liveRule,
+};
+export const CATEGORY_CHECKOUT_RULES = {
+    bundle: bundleRule,
+};
+/**
+ * Lookup the checkout rule for a listing type. Every consumer that used to
+ * inline `if (listingType === "X")` should call this instead.
+ */
+export function getListingRule(listingType) {
+    return CHECKOUT_RULES[listingType] ?? CHECKOUT_RULES.standard;
+}
+/**
+ * Lookup the checkout rule for a category type. Returns null for
+ * non-purchaseable category types (sublisting, brand, category).
+ */
+export function getCategoryRule(categoryType) {
+    return CATEGORY_CHECKOUT_RULES[categoryType] ?? null;
+}
+/**
+ * Pick the OrderType for a cart item — replaces the if/else cascade in
+ * splitCartIntoOrderGroups.
+ */
+export function pickOrderType(item) {
+    if (item.isOffer)
+        return offerRule.orderType;
+    const lt = (item.listingType ?? "standard");
+    return (CHECKOUT_RULES[lt] ?? CHECKOUT_RULES.standard).orderType;
+}
+/**
+ * Get the order-grouping split key for a cart item — replaces the inline
+ * key construction in splitCartIntoOrderGroups.
+ */
+export function getSplitKey(item) {
+    if (item.isOffer)
+        return offerRule.splitKey(item);
+    const lt = (item.listingType ?? "standard");
+    return (CHECKOUT_RULES[lt] ?? CHECKOUT_RULES.standard).splitKey(item);
+}
+/**
+ * Run all synchronous preflight guards across a cart.  Each item is tested
+ * against its type's rule.  Throws ValidationError on first violation.
+ *
+ * Note: the async maxPerUser cap check remains in the server-only
+ * `enforceMaxPerUserForCart` (prize-bundle-gates.ts) and runs separately.
+ */
+export function runSyncPreflight(pairs) {
+    const byType = new Map();
+    for (const pair of pairs) {
+        if (pair.item.bundleProductIds?.length)
+            continue; // bundles skip — direct checkout
+        const lt = (pair.item.listingType ?? "standard");
+        const bucket = byType.get(lt) ?? [];
+        bucket.push(pair);
+        byType.set(lt, bucket);
+    }
+    for (const [lt, ltPairs] of byType) {
+        const rule = CHECKOUT_RULES[lt] ?? CHECKOUT_RULES.standard;
+        rule.preflightChecks(ltPairs);
+    }
+}

package/dist/_internal/shared/checkout/rules/auction.rule.d.ts

@@ -0,0 +1,2 @@
+import type { ListingCheckoutRule } from "./types";
+export declare const auctionRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/auction.rule.js

@@ -0,0 +1,10 @@
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const auctionRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "auction",
+    cartEligible: false, // bid-only; add-to-cart is blocked at the action layer
+    maxQuantityPerLine: 1,
+    canMergeWithSameProduct: false,
+    refundPolicy: { full: true, partial: false, partialGranularity: "none" },
+    splitKey: (item) => `auction:${item.itemId}`,
+};

package/dist/_internal/shared/checkout/rules/bundle.rule.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bundle CategoryCheckoutRule — bundles are always direct-checkout-only.
+ *
+ * Bundles (categoryType:"bundle") never enter the cart. The buyer clicks
+ * "Buy bundle" on the bundle PDP which calls directBundleCheckoutAction,
+ * bypassing the cart pipeline entirely.  This rule conveys that intent to the
+ * cart-add gate (cartEligible: false) and informs the checkout CART-UI which
+ * replaces "Add to cart" with "Buy now".
+ */
+import type { CategoryCheckoutRule } from "./types";
+export declare const bundleRule: CategoryCheckoutRule;

package/dist/_internal/shared/checkout/rules/bundle.rule.js

@@ -0,0 +1,6 @@
+export const bundleRule = {
+    purchaseable: true,
+    cartEligible: false, // direct-checkout-only; addBundleToCart has been removed
+    orderType: "standard", // bundle orders resolve to standard orderType
+    requiresShippingAddress: true,
+};

package/dist/_internal/shared/checkout/rules/classified.rule.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Classified listing rule — chat-only, no checkout.
+ *
+ * Classified listings (OLX / Facebook Marketplace pattern) surface a
+ * "Contact Seller" CTA that opens a conversations thread.  No cart, no
+ * payment, no order. SB-UNI-M will wire the full flow.
+ */
+import type { ListingCheckoutRule } from "./types";
+export declare const classifiedRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/classified.rule.js

@@ -0,0 +1,9 @@
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const classifiedRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "standard", // placeholder — classified never reaches order creation
+    purchaseable: false,
+    cartEligible: false,
+    requiresShippingAddress: false,
+    requiresConsentOtp: false,
+};

package/dist/_internal/shared/checkout/rules/digital-code.rule.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Digital-code listing rule — no shipping, instant fulfilment.
+ *
+ * Codes are delivered electronically at purchase confirmation. No shipping
+ * address required. SB-UNI-N wires the full code-pool claim + reveal flow.
+ */
+import type { ListingCheckoutRule } from "./types";
+export declare const digitalCodeRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/digital-code.rule.js

@@ -0,0 +1,6 @@
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const digitalCodeRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "standard", // single-line standard order; fulfilment differs
+    requiresShippingAddress: false,
+};

package/dist/_internal/shared/checkout/rules/index.d.ts

@@ -0,0 +1,12 @@
+export type { ListingCheckoutRule, CategoryCheckoutRule, CartItemProductPair, OrderItemInput, RefundPolicy, } from "./types";
+export { CHECKOUT_RULES, CATEGORY_CHECKOUT_RULES, getListingRule, getCategoryRule, pickOrderType, getSplitKey, runSyncPreflight, } from "./_registry";
+export { CART_MAX_ITEMS, CHECKOUT_MAX_ORDERS_PER_TX, PRIZE_DRAW_MAX_REVEALS_PER_ORDER, BUNDLE_MAX_QTY_PER_TX, STANDARD_MAX_QTY_PER_LINE, } from "./_limits";
+export { standardRule } from "./standard.rule";
+export { auctionRule } from "./auction.rule";
+export { preOrderRule } from "./preorder.rule";
+export { prizeDrawRule } from "./prize-draw.rule";
+export { offerRule } from "./offer.rule";
+export { bundleRule } from "./bundle.rule";
+export { classifiedRule } from "./classified.rule";
+export { digitalCodeRule } from "./digital-code.rule";
+export { liveRule } from "./live.rule";

package/dist/_internal/shared/checkout/rules/index.js

@@ -0,0 +1,12 @@
+export { CHECKOUT_RULES, CATEGORY_CHECKOUT_RULES, getListingRule, getCategoryRule, pickOrderType, getSplitKey, runSyncPreflight, } from "./_registry";
+export { CART_MAX_ITEMS, CHECKOUT_MAX_ORDERS_PER_TX, PRIZE_DRAW_MAX_REVEALS_PER_ORDER, BUNDLE_MAX_QTY_PER_TX, STANDARD_MAX_QTY_PER_LINE, } from "./_limits";
+// Individual rules — exported for tests and direct access.
+export { standardRule } from "./standard.rule";
+export { auctionRule } from "./auction.rule";
+export { preOrderRule } from "./preorder.rule";
+export { prizeDrawRule } from "./prize-draw.rule";
+export { offerRule } from "./offer.rule";
+export { bundleRule } from "./bundle.rule";
+export { classifiedRule } from "./classified.rule";
+export { digitalCodeRule } from "./digital-code.rule";
+export { liveRule } from "./live.rule";

package/dist/_internal/shared/checkout/rules/live.rule.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Live-item listing rule — buyer jurisdiction check + vendor verification.
+ *
+ * Live animals/plants require a verified seller and that the buyer's delivery
+ * state is in the product's `jurisdictionAllowed` list.  Cart eligibility is
+ * blocked at the action layer via `capabilityFor("live").requiresJurisdictionCheck`
+ * until the full gate (SB-UNI-O) is implemented.
+ */
+import type { ListingCheckoutRule } from "./types";
+export declare const liveRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/live.rule.js

@@ -0,0 +1,6 @@
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const liveRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "standard",
+    cartEligible: false, // blocked until SB-UNI-O jurisdiction + vendor-verified gate
+};

package/dist/_internal/shared/checkout/rules/offer.rule.d.ts

@@ -0,0 +1,2 @@
+import type { ListingCheckoutRule } from "./types";
+export declare const offerRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/offer.rule.js

@@ -0,0 +1,9 @@
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const offerRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "offer",
+    maxQuantityPerLine: 1,
+    canMergeWithSameProduct: false,
+    refundPolicy: { full: true, partial: false, partialGranularity: "none" },
+    splitKey: (item) => `offer:${item.itemId}`,
+};

package/dist/_internal/shared/checkout/rules/preorder.rule.d.ts

@@ -0,0 +1,2 @@
+import type { ListingCheckoutRule } from "./types";
+export declare const preOrderRule: ListingCheckoutRule;

package/dist/_internal/shared/checkout/rules/preorder.rule.js

@@ -0,0 +1,28 @@
+import { ValidationError } from "../../../../errors";
+import { DEFAULT_LISTING_RULE } from "./_defaults";
+export const preOrderRule = {
+    ...DEFAULT_LISTING_RULE,
+    orderType: "preorder",
+    splitKey: (item) => `preorder:${item.storeId ?? "unknown"}`,
+    preflightChecks: (pairs) => {
+        for (const { item, product } of pairs) {
+            if (product.listingType !== "pre-order")
+                continue;
+            const cap = product.preOrderMaxQuantity ?? 0;
+            if (cap <= 0)
+                continue;
+            const current = product.preOrderCurrentCount ?? 0;
+            if (current + item.quantity > cap) {
+                throw Object.assign(new ValidationError(`Pre-order quota reached for "${product.title}". ` +
+                    `${current}/${cap} already reserved.`), { code: "PREORDER_QUOTA_FULL", productId: product.id });
+            }
+        }
+    },
+    stockDecrementExtras: (product, quantity) => {
+        if (product.listingType !== "pre-order")
+            return {};
+        return {
+            preOrderCurrentCount: (product.preOrderCurrentCount ?? 0) + quantity,
+        };
+    },
+};

package/dist/_internal/shared/checkout/rules/prize-draw.rule.d.ts

@@ -0,0 +1,2 @@
+import type { ListingCheckoutRule } from "./types";
+export declare const prizeDrawRule: ListingCheckoutRule;