@mohasinac/appkit 4.62.0 → 4.62.1

package/dist/features/shipping-boxes/repository/shipping-boxes.repository.d.ts

@@ -0,0 +1,43 @@
+import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
+import { BaseRepository } from "../../../providers/db-firebase";
+import { type ShippingBoxDocument } from "../schemas/firestore";
+/**
+ * The shared carton library. See the schema header for why it is global.
+ */
+export declare class ShippingBoxesRepository extends BaseRepository<ShippingBoxDocument> {
+    static readonly SIEVE_FIELDS: FirebaseSieveFields;
+    constructor();
+    /**
+     * The picker's list. Active only, by name.
+     *
+     * 🛑 Retired presets are excluded here and NOT deleted, so a draft shipment
+     * holding one does not lose it mid-dispatch.
+     */
+    listActive(model: SieveModel): Promise<FirebaseSieveResult<ShippingBoxDocument>>;
+    /**
+     * Create a preset, keyed on a slug of its name.
+     *
+     * 🛑 `box-<slug>` as the document id, so the SAME carton name cannot be added
+     * twice by two sellers. That is the whole value of a shared library — two
+     * rows called "Standard carton" with different numbers is worse than one
+     * row, because the picker gives no way to tell them apart.
+     *
+     * A colliding create is reported to the caller rather than silently
+     * overwriting: the existing row has an author and may be in use, and the
+     * second seller's intent ("I want a preset for this") is already satisfied
+     * by the row that exists.
+     */
+    createPreset(input: {
+        name: string;
+        length: number;
+        width: number;
+        height: number;
+        tareWeight?: number;
+        createdByUid: string;
+        createdByName: string;
+    }): Promise<{
+        box: ShippingBoxDocument;
+        created: boolean;
+    }>;
+}
+export declare const shippingBoxesRepository: ShippingBoxesRepository;

package/dist/features/shipping-boxes/repository/shipping-boxes.repository.js

@@ -0,0 +1,90 @@
+import { BaseRepository } from "../../../providers/db-firebase/index.js";
+import { slugify } from "../../../utils/string.formatter.js";
+import { SHIPPING_BOX_COLLECTION, SHIPPING_BOX_FIELDS, SHIPPING_BOX_LIMITS, } from "../schemas/firestore.js";
+/**
+ * The shared carton library. See the schema header for why it is global.
+ */
+export class ShippingBoxesRepository extends BaseRepository {
+    constructor() {
+        super(SHIPPING_BOX_COLLECTION);
+    }
+    /**
+     * The picker's list. Active only, by name.
+     *
+     * 🛑 Retired presets are excluded here and NOT deleted, so a draft shipment
+     * holding one does not lose it mid-dispatch.
+     */
+    async listActive(model) {
+        const baseQuery = this.getCollection().where(SHIPPING_BOX_FIELDS.IS_ACTIVE, "==", true);
+        return this.sieveQuery(model, ShippingBoxesRepository.SIEVE_FIELDS, {
+            baseQuery,
+            defaultPageSize: 20,
+            maxPageSize: 50,
+        });
+    }
+    /**
+     * Create a preset, keyed on a slug of its name.
+     *
+     * 🛑 `box-<slug>` as the document id, so the SAME carton name cannot be added
+     * twice by two sellers. That is the whole value of a shared library — two
+     * rows called "Standard carton" with different numbers is worse than one
+     * row, because the picker gives no way to tell them apart.
+     *
+     * A colliding create is reported to the caller rather than silently
+     * overwriting: the existing row has an author and may be in use, and the
+     * second seller's intent ("I want a preset for this") is already satisfied
+     * by the row that exists.
+     */
+    async createPreset(input) {
+        const name = input.name.trim();
+        const id = `box-${slugify(name)}`;
+        const existing = await this.findById(id);
+        if (existing)
+            return { box: existing, created: false };
+        const now = new Date();
+        const box = {
+            id,
+            name,
+            length: clampCm(input.length),
+            width: clampCm(input.width),
+            height: clampCm(input.height),
+            ...(input.tareWeight === undefined ? {} : { tareWeight: clampKg(input.tareWeight) }),
+            createdByUid: input.createdByUid,
+            createdByName: input.createdByName,
+            isActive: true,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.createWithId(id, box);
+        return { box, created: true };
+    }
+}
+ShippingBoxesRepository.SIEVE_FIELDS = {
+    /*
+     * `name` is sortable AND filterable because this list is picked from by
+     * typing — `PaginatedSelect` searches it. A field the picker searches that
+     * is not allowlisted here would have its clause silently DROPPED and the
+     * search would return the whole library while looking like it filtered
+     * (Root Cause #62).
+     */
+    name: { canFilter: true, canSort: true },
+    isActive: { canFilter: true, canSort: false },
+    createdByUid: { canFilter: true, canSort: false },
+};
+/*
+ * Clamped rather than rejected. These bounds exist so a typo cannot reach a
+ * courier API as a 4-metre parcel; they are not a tariff, and refusing a
+ * legitimate large parcel client-side is worse than letting it through to be
+ * priced by `checkServiceability` against the real figures.
+ */
+function clampCm(v) {
+    if (!Number.isFinite(v))
+        return SHIPPING_BOX_LIMITS.minCm;
+    return Math.min(SHIPPING_BOX_LIMITS.maxCm, Math.max(SHIPPING_BOX_LIMITS.minCm, v));
+}
+function clampKg(v) {
+    if (!Number.isFinite(v))
+        return SHIPPING_BOX_LIMITS.minKg;
+    return Math.min(SHIPPING_BOX_LIMITS.maxKg, Math.max(SHIPPING_BOX_LIMITS.minKg, v));
+}
+export const shippingBoxesRepository = new ShippingBoxesRepository();

package/dist/features/shipping-boxes/schemas/firestore.d.ts

@@ -0,0 +1,82 @@
+/**
+ * `shippingBoxes` — a GLOBAL library of named carton presets.
+ *
+ * ## Why global rather than per-store
+ *
+ * A box is a real physical carton size. Scoping presets per store would give
+ * every seller their own private copy of "Medium", each with slightly
+ * different numbers, and the second seller to ship a Beyblade in a standard
+ * carton would re-measure instead of picking what already exists.
+ *
+ * `createdByName` is what keeps a shared library accountable: a wrong preset
+ * has an author, and the next seller can see who added the one they are about
+ * to trust.
+ *
+ * ## 🛑 A preset is a DEFAULT, never a lock
+ *
+ * The dimensions are COPIED onto the shipment when a seller uses one. Editing
+ * a preset later must not retroactively change what an already-dispatched
+ * parcel was declared as — the courier billed against the figures at dispatch,
+ * and a stored reference would make a past declaration mutable. Same snapshot
+ * discipline as the checkout's fee terms (D61).
+ *
+ * ## 🛑 Weight is not a formality
+ *
+ * An understated weight is re-billed by the courier AFTER delivery as a
+ * weight-discrepancy adjustment — real money, arriving on a reconciliation we
+ * cannot dispute without the parcel. The form says so rather than treating it
+ * as a required field to get past.
+ */
+/** `box-` prefixed slug, so the id reads as what it is. */
+export declare const SHIPPING_BOX_COLLECTION = "shippingBoxes";
+export interface ShippingBoxDocument {
+    id: string;
+    /** What a seller picks it by: "Standard Beyblade carton", "Poly mailer S". */
+    name: string;
+    /** cm. */
+    length: number;
+    width: number;
+    height: number;
+    /**
+     * kg, the EMPTY box. The parcel's weight is this plus contents, entered on
+     * the dispatch form — a preset cannot know what went inside it.
+     *
+     * 🛑 Separate from the shipment's `weight` for exactly that reason. Storing
+     * one "weight" on a preset and reusing it as the parcel weight is how every
+     * parcel gets declared at the same figure regardless of contents.
+     */
+    tareWeight?: number;
+    /** Who added it. Display name, so a seller can see whose preset this is. */
+    createdByName: string;
+    /** The uid, for moderation. Never rendered. */
+    createdByUid: string;
+    /**
+     * Soft-retire rather than delete. A preset in use by a draft shipment must
+     * not vanish mid-dispatch, and a deleted row takes its author with it.
+     */
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare const SHIPPING_BOX_FIELDS: {
+    readonly ID: "id";
+    readonly NAME: "name";
+    readonly IS_ACTIVE: "isActive";
+    readonly CREATED_BY_UID: "createdByUid";
+    readonly CREATED_AT: "createdAt";
+};
+/**
+ * Bounds, so a typo cannot reach a courier API as a 4-metre parcel.
+ *
+ * 🛑 Generous on purpose — these are a sanity check, not a tariff. India Post
+ * and most couriers cap a single parcel well below these, and the right place
+ * to learn a real limit is `checkServiceability`, which quotes against the
+ * actual weight. A client-side rule that refuses a legitimate large parcel is
+ * worse than one that lets it through to be priced.
+ */
+export declare const SHIPPING_BOX_LIMITS: {
+    readonly minCm: 1;
+    readonly maxCm: 200;
+    readonly minKg: 0;
+    readonly maxKg: 50;
+};

package/dist/features/shipping-boxes/schemas/firestore.js

@@ -0,0 +1,53 @@
+/**
+ * `shippingBoxes` — a GLOBAL library of named carton presets.
+ *
+ * ## Why global rather than per-store
+ *
+ * A box is a real physical carton size. Scoping presets per store would give
+ * every seller their own private copy of "Medium", each with slightly
+ * different numbers, and the second seller to ship a Beyblade in a standard
+ * carton would re-measure instead of picking what already exists.
+ *
+ * `createdByName` is what keeps a shared library accountable: a wrong preset
+ * has an author, and the next seller can see who added the one they are about
+ * to trust.
+ *
+ * ## 🛑 A preset is a DEFAULT, never a lock
+ *
+ * The dimensions are COPIED onto the shipment when a seller uses one. Editing
+ * a preset later must not retroactively change what an already-dispatched
+ * parcel was declared as — the courier billed against the figures at dispatch,
+ * and a stored reference would make a past declaration mutable. Same snapshot
+ * discipline as the checkout's fee terms (D61).
+ *
+ * ## 🛑 Weight is not a formality
+ *
+ * An understated weight is re-billed by the courier AFTER delivery as a
+ * weight-discrepancy adjustment — real money, arriving on a reconciliation we
+ * cannot dispute without the parcel. The form says so rather than treating it
+ * as a required field to get past.
+ */
+/** `box-` prefixed slug, so the id reads as what it is. */
+export const SHIPPING_BOX_COLLECTION = "shippingBoxes";
+export const SHIPPING_BOX_FIELDS = {
+    ID: "id",
+    NAME: "name",
+    IS_ACTIVE: "isActive",
+    CREATED_BY_UID: "createdByUid",
+    CREATED_AT: "createdAt",
+};
+/**
+ * Bounds, so a typo cannot reach a courier API as a 4-metre parcel.
+ *
+ * 🛑 Generous on purpose — these are a sanity check, not a tariff. India Post
+ * and most couriers cap a single parcel well below these, and the right place
+ * to learn a real limit is `checkServiceability`, which quotes against the
+ * actual weight. A client-side rule that refuses a legitimate large parcel is
+ * worse than one that lets it through to be priced.
+ */
+export const SHIPPING_BOX_LIMITS = {
+    minCm: 1,
+    maxCm: 200,
+    minKg: 0,
+    maxKg: 50,
+};

package/dist/features/store-extensions/schemas/report-create-form.d.ts

@@ -12,14 +12,14 @@ export declare const reportCreateSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     entityId: string;
     entityType: import("./firestore").ReportEntityType;
-    detail: string;
     reason: import("./firestore").ReportReason;
+    detail: string;
     evidenceUrls?: string[] | undefined;
 }, {
     entityId: string;
     entityType: import("./firestore").ReportEntityType;
-    detail: string;
     reason: import("./firestore").ReportReason;
+    detail: string;
     evidenceUrls?: string[] | undefined;
 }>;
 export type ReportCreateValues = z.infer<typeof reportCreateSchema>;

package/dist/features/store-extensions/schemas/shipping-config-form.d.ts

@@ -133,8 +133,8 @@ export declare const shippingConfigUpdateSchema: z.ZodObject<{
     label?: string | undefined;
     isActive?: boolean | undefined;
     isDefault?: boolean | undefined;
-    method?: ShippingMethod | undefined;
     estimatedDays?: number | undefined;
+    method?: ShippingMethod | undefined;
     flatRate?: number | undefined;
     pricePerKg?: number | undefined;
     freeAbove?: number | undefined;
@@ -144,8 +144,8 @@ export declare const shippingConfigUpdateSchema: z.ZodObject<{
     label?: string | undefined;
     isActive?: boolean | undefined;
     isDefault?: boolean | undefined;
-    method?: ShippingMethod | undefined;
     estimatedDays?: number | undefined;
+    method?: ShippingMethod | undefined;
     flatRate?: number | undefined;
     pricePerKg?: number | undefined;
     freeAbove?: number | undefined;

package/dist/features/stores/components/StoreOrdersGuideView.js

@@ -2,6 +2,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ArrowLeft } from "lucide-react";
 import { Accordion, Alert, Code, Div, Heading, Li, Ol, Row, Section, Span, Stack, Table, Tbody, Td, Text, TextLink, Th, Thead, Tr, Ul } from "../../../ui/index.js";
 import { ROUTES } from "../../../next/routing/route-map.js";
+import { resolvePublishedValues } from "../../../_internal/shared/content/published-values.js";
+/* Phase 9 — one definition of the refund timeline. */
+const { refundBusinessDaysMin: REFUND_DAYS_MIN, refundBusinessDaysMax: REFUND_DAYS_MAX } = resolvePublishedValues();
 const SUBHEADING = "mb-1 font-semibold text-[var(--appkit-color-text)]";
 const LIST_DISC = "list-disc leading-relaxed";
 const SECTION_BODY = "space-y-4 text-[length:var(--appkit-text-sm)] text-[var(--appkit-color-text-muted)]";
@@ -41,7 +44,9 @@ const STATUS_ROWS = [
     {
         status: "CANCELLED",
         meaning: "Order was cancelled before shipping (by buyer or seller).",
-        action: "Refund is automatic via Razorpay (3–7 business days).",
+        // Phase 9 — one definition, and no gateway name. See the identical note in
+        // AdminOrdersGuideView.
+        action: `Refund is automatic (${REFUND_DAYS_MIN}–${REFUND_DAYS_MAX} business days).`,
     },
     {
         status: "RETURN_REQUESTED",

package/dist/features/stores/schemas/firestore.d.ts

@@ -233,6 +233,77 @@ export interface StoreDocument extends BaseDocument {
      */
     supportsShippingProtection?: boolean;
     supportsSaleProtection?: boolean;
+    /**
+     * This store accepts buyer points as part-payment.
+     *
+     * ## 🛑 OPT-IN, because the accepting store ABSORBS the redemption
+     *
+     * Decision 3: a redeemed point reduces THAT store's payout for THAT order.
+     * Earning is mandatory (it costs the seller nothing at issue time); accepting
+     * is optional, because accepting is where the money actually moves. So this
+     * follows `supportsSaleProtection` above exactly — **absent means NOT
+     * accepted, never "unknown"** — and for the identical reason: defaulting it
+     * `true` would enrol every existing seller in funding discounts they never
+     * agreed to, and retrofitting consent later means switching a working feature
+     * off for them.
+     *
+     * 🛑 Live currently has ONE store, so this flag is inert today. It is still
+     * built now rather than later: the day a second seller exists, enabling
+     * redemption for them without asking is taking their money, and the cost of
+     * the field today is one boolean and one check.
+     *
+     * `store-letitrip-official` is always treated as accepting — the platform's
+     * own storefront cannot decline to fund its own programme. That is resolved
+     * in code rather than seeded, so it cannot be switched off by an edit.
+     */
+    acceptsPoints?: boolean;
+    /**
+     * ── S5a: this store allows a SHARED PURCHASE (one payer, N destinations) ──
+     *
+     * The coordinator buys everything and assigns a destination per item, so the
+     * seller packs one order into several parcels. That is real extra work —
+     * picking, packing and labelling N shipments instead of one — which is why
+     * it is an opt-in with its own fees rather than a free platform behaviour.
+     *
+     * 🛑 **Absent means NOT allowed**, matching `supportsSaleProtection` and
+     * `acceptsPoints` above, and for the same reason: the cost falls on the
+     * seller, so enrolling them without asking is taking their labour. Every
+     * existing store therefore starts with it off, which is the correct state
+     * rather than a migration problem.
+     *
+     * 🛑 This is S5a ONLY — one payer. It is NOT the N-party flow (S5b), which
+     * needs multi-party payment, a coordinator deposit, an approval cascade, a
+     * stock-reservation primitive that does not exist, and per-buyer invoicing
+     * and GST. A seller enabling this is agreeing to split one paid order across
+     * destinations, not to be paid by several people.
+     */
+    allowSharedPurchase?: boolean;
+    /**
+     * Flat fee per shared-purchase arrangement, in decimal rupees.
+     *
+     * Covers picking, packing and labelling one order into N parcels. Borne by
+     * the COORDINATOR — they chose the arrangement — which keeps each
+     * destination's own cost to goods plus that destination's shipping.
+     *
+     * 🛑 SNAPSHOTTED onto the order at checkout, never re-read later. The
+     * precedent is exact: the refund path reads `finalSale` from the ORDER
+     * snapshot rather than the live product, because "re-reading the live
+     * product would let a seller flip the switch afterwards" (D61). A fee read
+     * late is the same hole.
+     */
+    sharedPurchaseHandlingFee?: number;
+    /**
+     * Extra shipping per destination BEYOND THE FIRST, in decimal rupees.
+     *
+     * The first destination is the shipping the order would have paid anyway;
+     * this is the marginal cost of each additional parcel. Borne by the buyer at
+     * that destination in the full N-party flow — in S5a there is one payer, so
+     * the coordinator pays all of it, which is correct because they are the
+     * person who asked for the extra legs.
+     *
+     * Snapshotted with the handling fee, for the same reason.
+     */
+    sharedPurchaseExtraShippingPerDestination?: number;
     /**
      * ── C5g: ADMIN-GRANTED trust. Routes even a protected claim to the seller ──
      *

package/dist/features/stores/types/index.d.ts

@@ -24,6 +24,25 @@ export interface StoreListItem {
      */
     supportsShippingProtection: boolean;
     supportsSaleProtection: boolean;
+    /**
+     * S5a — this seller will split one paid order across several destinations.
+     *
+     * Not optional, for the same reason as the two above: the projection
+     * resolves absence to `false`, so the client never decides what `undefined`
+     * means.
+     */
+    allowSharedPurchase: boolean;
+    /**
+     * The two shared-purchase fees, in decimal rupees.
+     *
+     * 🛑 OPTIONAL here where `allowSharedPurchase` is not, and the asymmetry is
+     * the point: a flag's absence means "no", but a fee's absence means "not
+     * configured" — which is not ₹0. A client that defaulted these to zero would
+     * quote a free arrangement from a store that has simply not priced one, and
+     * the coordinator commits against that quote.
+     */
+    sharedPurchaseHandlingFee?: number;
+    sharedPurchaseExtraShippingPerDestination?: number;
     createdAt?: string;
 }
 export interface StoreDetail extends StoreListItem {

package/dist/features/support/schemas/index.d.ts

@@ -175,11 +175,11 @@ export declare const supportTicketFirestoreSchema: z.ZodObject<{
         attachments?: string[] | undefined;
     }[];
     orderId?: string | undefined;
-    assignedTo?: string | undefined;
-    resolvedAt?: string | Date | z.objectOutputType<{
+    closedAt?: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    closedAt?: string | Date | z.objectOutputType<{
+    assignedTo?: string | undefined;
+    resolvedAt?: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     assignedToName?: string | undefined;
@@ -218,11 +218,11 @@ export declare const supportTicketFirestoreSchema: z.ZodObject<{
         attachments?: string[] | undefined;
     }[];
     orderId?: string | undefined;
-    assignedTo?: string | undefined;
-    resolvedAt?: string | Date | z.objectInputType<{
+    closedAt?: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    closedAt?: string | Date | z.objectInputType<{
+    assignedTo?: string | undefined;
+    resolvedAt?: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
     assignedToName?: string | undefined;

package/dist/features/wishlist/hooks/useWishlistWithGuest.d.ts

@@ -29,7 +29,7 @@ export declare function useWishlistWithGuest(userId: string | null | undefined,
         productPrice: number;
         productSlug: string;
         addedAt: string | undefined;
-        type: "category" | "store" | "classified" | "auction" | "digital-code" | "live" | "product" | "preorder";
+        type: "category" | "store" | "classified" | "auction" | "digital-code" | "live" | "preorder" | "product";
     }[];
     total: number;
     wishlistedIds: Set<string>;

package/dist/index.d.ts

@@ -1962,6 +1962,8 @@ export type { OrderSiblingPaymentsProps } from "./features/orders/index";
 export { OrderPaymentSummary } from "./features/orders/index";
 export type { OrderPaymentSummaryProps } from "./features/orders/index";
 export { OrderStatusTimeline } from "./features/orders/index";
+export { OrderProvenanceCard } from "./features/orders/index";
+export type { OrderProvenanceCardProps } from "./features/orders/index";
 export { OrderCompletionPanel } from "./features/orders/index";
 export { StatusTimeline, stepsFromEntries } from "./features/status-history/index";
 export type { StatusTimelineProps, TimelineEntry, TimelineStep } from "./features/status-history/index";
@@ -2000,6 +2002,7 @@ export type { OrderAdminUpdateInput } from "./features/orders/index";
 export type { AppliedOrderDiscount } from "./features/orders/index";
 export type { OrderCreateInput } from "./features/orders/index";
 export type { OrderDocument } from "./features/orders/index";
+export type { OrderSourceContext } from "./features/orders/index";
 export type { OrderRefundEvent, RefundType } from "./features/orders/schemas/firestore";
 export { MANUAL_PAYMENT_METHODS, isManualPaymentMethod, PAYMENT_REVIEW_QUEUE_MODES, isPaymentReviewQueueMode, PAYMENT_REVIEW_QUEUE_SCAN_LIMIT, } from "./features/orders/constants/payment-window";
 export type { PaymentReviewQueueMode } from "./features/orders/constants/payment-window";
@@ -2190,7 +2193,7 @@ export { actionTracker, setActionTrackerSink, resetActionTrackerSink, type Actio
 export { cartRequiresShipping, cartIsDigitalOnly, cartIsChatOnly, } from "./_internal/shared/listing-types/cart-shipping";
 export { ACTIONS, action, act, canPerformAction, actionsForListingType, actionLabel, type ActionDef, type ActionKind, type ActionResource, type ActionTree, type ActionConfirmation, } from "./_internal/shared/actions/action-registry";
 export { buildBulkAction } from "./_internal/shared/actions/bulk-helpers";
-export { computeCheckoutFees, computePayoutDeduction, computeCodHandlingFee, computeGiftWrapFee, computeShipmentProtectionFee, computeSaleProtectionFee, calculateGst, } from "./_internal/shared/fees/calculator";
+export { computeCheckoutFees, allocateCheckoutFees, computePayoutDeduction, computeCodHandlingFee, computeGiftWrapFee, computeShipmentProtectionFee, computeSaleProtectionFee, calculateGst, } from "./_internal/shared/fees/calculator";
 export { searchPriceIndex, PRICE_INDEX_SEARCH_LIMIT, PRICE_INDEX_MIN_QUERY_LENGTH } from "./_internal/server/features/price-index/search";
 export type { PriceIndexSearchResponse, PriceIndexSearchResult, PriceIndexSearchResultBand, } from "./_internal/server/features/price-index/search";
 export { protectionAvailability, computeProtectionFees, adjudicateClaim, badgesFor, showsRiskNotice, showsSafetyBadge, returnDestination, rtoDestination, PROTECTION_KINDS, } from "./_internal/shared/features/shipping/protections";
@@ -2852,6 +2855,8 @@ export { BUNDLE_COPY, BUNDLE_STOCK_VARIANT, } from "./_internal/shared/features/
 export { REFUND_COPY } from "./_internal/shared/features/orders/refund-copy";
 export { RETURN_REASON, FINAL_SALE_EXEMPT_REASONS, RETURN_REASON_LABEL, RETURN_REASON_GROUP_LABEL, isFinalSaleExempt, isReturnReason, selectableReturnReasons, } from "./_internal/shared/features/orders/return-reasons";
 export type { ReturnReason } from "./_internal/shared/features/orders/return-reasons";
+export { DISPUTE_KIND, DISPUTE_KIND_LABEL, DISPUTE_GATE, DISPUTE_TRANSIT_WINDOW_DAYS, DISPUTE_NOT_REACHED_GRACE_DAYS, isDisputeKind, checkDisputeGate, resolveDisputeEtd, disputeNotReachedFilableFrom, } from "./_internal/shared/features/orders/dispute-reasons";
+export type { DisputeKind, DisputeGateOrder, DisputeGateResult, } from "./_internal/shared/features/orders/dispute-reasons";
 export { bundleCreateSchema, bundleUpdateSchema, bundleQueryRuleSchema, bundleDisplaySchema, type BundleCreateBody, type BundleUpdateBody, } from "./_internal/shared/features/categories/bundle-schemas";
 export type { GroupedListingDocument, GroupTheme, GroupVisibility } from "./features/grouped/schemas/firestore";
 export { navItemFormSchema, navItemCreateSchema, navItemUpdateSchema, type NavItemFormValues, } from "./features/admin/schemas/nav-item-form";

package/dist/index.js

@@ -3691,6 +3691,9 @@ export { OrdersList } from "./features/orders/index.js";
 export { OrderSiblingPayments } from "./features/orders/index.js";
 export { OrderPaymentSummary } from "./features/orders/index.js";
 export { OrderStatusTimeline } from "./features/orders/index.js";
+// OrderProvenanceCard — renders sourceContext, the record of HOW the buyer
+// earned this price. Mounted on the buyer, seller AND admin order detail.
+export { OrderProvenanceCard } from "./features/orders/index.js";
 // OrderCompletionPanel - Per-line ratings + Mark complete, the buyer's fast path.
 export { OrderCompletionPanel } from "./features/orders/index.js";
 // [CLIENT] StatusTimeline — the ONE rail both orders and offers render.
@@ -4075,7 +4078,14 @@ export { cartRequiresShipping, cartIsDigitalOnly, cartIsChatOnly, } from "./_int
 export { ACTIONS, action, act, canPerformAction, actionsForListingType, actionLabel, } from "./_internal/shared/actions/action-registry.js";
 export { buildBulkAction } from "./_internal/shared/actions/bulk-helpers.js";
 // Shared fee calculator — platform/gateway/GST/COD handling/addon fee math (pure, client-safe).
-export { computeCheckoutFees, computePayoutDeduction, computeCodHandlingFee, computeGiftWrapFee, computeShipmentProtectionFee, computeSaleProtectionFee, calculateGst, } from "./_internal/shared/fees/calculator.js";
+export { computeCheckoutFees, 
+// The per-group split of the ONE capped commission. Exported for the capture
+// route's points tender: the tender is applied per order group against the
+// same base the order path uses, and that base includes this share. Without
+// it the route would have to re-derive the apportionment — and the allocator
+// also carries the `minimumTransactionFee` floor (D41), which already spent
+// a release being re-implemented by hand in that very file.
+allocateCheckoutFees, computePayoutDeduction, computeCodHandlingFee, computeGiftWrapFee, computeShipmentProtectionFee, computeSaleProtectionFee, calculateGst, } from "./_internal/shared/fees/calculator.js";
 // C5e buyer protections — the pure three-tier gate plus the one fee pair
 // every money path must agree on. Public API because the capture route
 // (/api/payment/create-order) is one of the three sites that must agree.
@@ -5121,6 +5131,9 @@ export { REFUND_COPY } from "./_internal/shared/features/orders/refund-copy.js";
 // See the module docstring for why the exempt set is "seller or carrier fault"
 // rather than "serious reasons".
 export { RETURN_REASON, FINAL_SALE_EXEMPT_REASONS, RETURN_REASON_LABEL, RETURN_REASON_GROUP_LABEL, isFinalSaleExempt, isReturnReason, selectableReturnReasons, } from "./_internal/shared/features/orders/return-reasons.js";
+// Dispute KINDS and their gates. `_internal/*` is not a subpath export, so a
+// consumer route reaches these only through a barrel.
+export { DISPUTE_KIND, DISPUTE_KIND_LABEL, DISPUTE_GATE, DISPUTE_TRANSIT_WINDOW_DAYS, DISPUTE_NOT_REACHED_GRACE_DAYS, isDisputeKind, checkDisputeGate, resolveDisputeEtd, disputeNotReachedFilableFrom, } from "./_internal/shared/features/orders/dispute-reasons.js";
 // S-SBUNI-4 follow-up â€" shared admin bundle zod schemas.
 export { bundleCreateSchema, bundleUpdateSchema, bundleQueryRuleSchema, bundleDisplaySchema, } from "./_internal/shared/features/categories/bundle-schemas.js";
 export { navItemFormSchema, navItemCreateSchema, navItemUpdateSchema, } from "./features/admin/schemas/nav-item-form.js";

package/dist/next/routing/route-map.d.ts

@@ -377,6 +377,16 @@ export declare const DEFAULT_ROUTE_MAP: {
         readonly AUDIT_LOG: "/admin/audit-log";
         readonly MONEY_CASES: "/admin/money-cases";
         readonly MONEY_CASE_DETAIL: (id: string) => string;
+        /**
+         * Phase 7 — the GSTR-1 draft export.
+         *
+         * 🛑 Under Finance for the same reason `MONEY_CASES` is, and the reason is
+         * stronger here: the export contains the company's tax position for a
+         * quarter plus every buyer's place of supply. That is not a maintenance
+         * diagnostic, and it is admin-only — deliberately not granted to
+         * `maintenance_employee`.
+         */
+        readonly INVOICING: "/admin/invoicing";
         readonly PROTECTION_CLAIMS: "/admin/protection-claims";
         readonly MAINTENANCE_GATEWAY_EVENTS: "/admin/maintenance/gateway-events";
         readonly MAINTENANCE_OBLIGATIONS: "/admin/maintenance/obligations";
@@ -831,6 +841,16 @@ export declare const ROUTES: {
         readonly AUDIT_LOG: "/admin/audit-log";
         readonly MONEY_CASES: "/admin/money-cases";
         readonly MONEY_CASE_DETAIL: (id: string) => string;
+        /**
+         * Phase 7 — the GSTR-1 draft export.
+         *
+         * 🛑 Under Finance for the same reason `MONEY_CASES` is, and the reason is
+         * stronger here: the export contains the company's tax position for a
+         * quarter plus every buyer's place of supply. That is not a maintenance
+         * diagnostic, and it is admin-only — deliberately not granted to
+         * `maintenance_employee`.
+         */
+        readonly INVOICING: "/admin/invoicing";
         readonly PROTECTION_CLAIMS: "/admin/protection-claims";
         readonly MAINTENANCE_GATEWAY_EVENTS: "/admin/maintenance/gateway-events";
         readonly MAINTENANCE_OBLIGATIONS: "/admin/maintenance/obligations";

package/dist/next/routing/route-map.js

@@ -579,6 +579,16 @@ export const DEFAULT_ROUTE_MAP = {
          */
         MONEY_CASES: "/admin/money-cases",
         MONEY_CASE_DETAIL: (id) => `/admin/money-cases/${id}`,
+        /**
+         * Phase 7 — the GSTR-1 draft export.
+         *
+         * 🛑 Under Finance for the same reason `MONEY_CASES` is, and the reason is
+         * stronger here: the export contains the company's tax position for a
+         * quarter plus every buyer's place of supply. That is not a maintenance
+         * diagnostic, and it is admin-only — deliberately not granted to
+         * `maintenance_employee`.
+         */
+        INVOICING: "/admin/invoicing",
         PROTECTION_CLAIMS: "/admin/protection-claims",
         MAINTENANCE_GATEWAY_EVENTS: "/admin/maintenance/gateway-events",
         MAINTENANCE_OBLIGATIONS: "/admin/maintenance/obligations",

package/dist/providers/shipping-shiprocket/index.d.ts

@@ -66,7 +66,7 @@
  * @tag access:server-only
  */
 import { IShippingProvider } from "../../contracts";
-import type { CreateShipmentInput, Shipment, TrackingInfo, ServiceabilityResult } from "../../contracts";
+import type { CreateShipmentInput, Shipment, TrackingInfo, ServiceabilityResult, WalletBalance } from "../../contracts";
 export interface ShiprocketConfig {
     /** The API user's email. See the header on why this is not a "login id". */
     email: string;
@@ -74,6 +74,21 @@ export interface ShiprocketConfig {
     /** Shiprocket pickup-location nickname, as registered in their dashboard. */
     pickupLocation?: string;
 }
+/**
+ * Does this upstream error body look like "your wallet is empty"?
+ *
+ * 🛑 The substring list is UNVERIFIED and that is acceptable, because of where
+ * it sits in the design: a funding failure and any other booking failure take
+ * the SAME path — the order gets a `courierBlock`, the admin is alerted, the
+ * seller is offered retry-or-self-ship. Classifying only changes the WORDING
+ * of the operator's alert. So a false negative costs a less specific message
+ * and never a wrong action, which is why this is allowed to be a heuristic
+ * rather than something this plan pretended to have confirmed.
+ *
+ * Triggering the real error would mean deliberately booking a shipment against
+ * a drained wallet, which is not a probe anyone should run on a live account.
+ */
+export declare function looksLikeInsufficientFunds(body: string): boolean;
 export declare class ShiprocketShippingProvider extends IShippingProvider {
     private readonly config;
     readonly name = "shiprocket";
@@ -119,6 +134,17 @@ export declare class ShiprocketShippingProvider extends IShippingProvider {
      */
     createShipment(data: CreateShipmentInput): Promise<Shipment>;
     trackShipment(trackingId: string): Promise<TrackingInfo>;
+    /**
+     * The prepaid wallet balance. Read-only; never charges anything.
+     *
+     * 🛑 Returns `{ known: false, supported: true }` on ANY failure rather than
+     * `0`. Shiprocket HAS a wallet, so `supported` is true regardless — the
+     * caller must treat "unreadable" as "attempt the booking anyway and let the
+     * attempt's own failure decide", because refusing on an unreadable balance
+     * would block every order on a transient network blip. A `0` here is a real
+     * decision to skip; an unreadable balance is not.
+     */
+    getWalletBalance(): Promise<WalletBalance>;
     cancelShipment(shipmentId: string): Promise<void>;
     checkServiceability(pincode: string, weight: number): Promise<ServiceabilityResult>;
     generateLabel(shipmentId: string): Promise<ArrayBuffer>;