@mohasinac/appkit 3.8.2 → 3.9.1

package/dist/_internal/server/jobs/core/hardBanCascade.js

@@ -52,7 +52,7 @@ async function cascadePaymentClusterBan(uid, banData) {
     }
 }
 export async function runHardBanCascade(input, ctx) {
-    const { uid, reason, bannedBy } = input;
+    const { uid, reason, bannedBy, expiresAt, fraudOrderId } = input;
     const target = await userRepository.findById(uid);
     if (!target) {
         return {
@@ -81,6 +81,8 @@ export async function runHardBanCascade(input, ctx) {
         hardBanReason: reason,
         hardBannedAt: new Date(),
         hardBannedBy: bannedBy,
+        hardBanExpiresAt: expiresAt ?? null,
+        ...(fraudOrderId ? { hardBanFraudOrderId: fraudOrderId } : {}),
     });
     // 3. Delete active sessions
     try {
@@ -125,7 +127,12 @@ export async function runHardBanCascade(input, ctx) {
             error: err instanceof Error ? err.message : String(err),
         });
     }
-    // 6. Cascade address ban + cross-account cluster ban
+    // 6. Cascade address ban + cross-account cluster ban. Note: this bans the
+    // ADDRESS record for other accounts sharing a hash cluster, not those
+    // accounts' full status — `AddressDocument.banStatus` has no expiry
+    // concept, so a temporary hard-ban's cluster cascade is scoped the same
+    // as a permanent one's; only the primary `uid`'s account-level ban is
+    // ever time-bound.
     try {
         const banData = { banReason: `User hard-banned: ${reason}`, bannedBy };
         await addressesRepository.banAllForOwner("user", uid, banData);
@@ -155,12 +162,16 @@ export async function runHardBanCascade(input, ctx) {
     try {
         const siteSettings = await siteSettingsRepository.getSingleton();
         const supportEmail = siteSettings.contact?.email || "support@example.com";
+        const title = expiresAt ? "Account temporarily suspended" : "Account permanently suspended";
+        const message = expiresAt
+            ? `Your account has been suspended for 7 days. Reason: ${reason}. Access will be automatically restored on ${expiresAt.toDateString()}. You may appeal sooner by emailing ${supportEmail}.`
+            : `Your account has been permanently suspended. Reason: ${reason}. You may appeal by emailing ${supportEmail}.`;
         await sendNotification({
             userId: uid,
             type: "account_action",
             priority: "high",
-            title: "Account permanently suspended",
-            message: `Your account has been permanently suspended. Reason: ${reason}. You may appeal by emailing ${supportEmail}.`,
+            title,
+            message,
             relatedId: uid,
             relatedType: "user",
         });

package/dist/_internal/server/jobs/core/hardBanReinstatement.d.ts

@@ -0,0 +1,16 @@
+import type { JobContext } from "../runtime/types";
+/**
+ * Reinstatement sweep for temporary hard-bans (Tier PP — 7-day fraud-reject
+ * bans) whose `hardBanExpiresAt` has passed. Reversal scope is deliberately
+ * narrow — only what the ban itself directly controlled:
+ *   - Re-enable Firebase Auth login.
+ *   - Clear `isDisabled`, stamp `hardBanReinstatedAt` (keeps `hardBanReason`/
+ *     `hardBannedAt`/`hardBannedBy`/`hardBanExpiresAt` as historical record).
+ * Deliberately NOT reversed — these need separate admin/appeal action:
+ *   - The seller's store stays `suspended` (hardBanCascade stage 4).
+ *   - Cancelled bids stay cancelled (stage 5).
+ *   - Cross-account address/payment-method cluster bans stay banned
+ *     (stages 6/7 — independent fraud-ring findings, not solely contingent
+ *     on this user's temporary status).
+ */
+export declare function runHardBanReinstatement(ctx: JobContext): Promise<void>;

package/dist/_internal/server/jobs/core/hardBanReinstatement.js

@@ -0,0 +1,63 @@
+import { normalizeError } from "../../../../errors/normalize";
+import { userRepository } from "../../../../repositories";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { getAdminAuth } from "../../../../providers/db-firebase";
+/**
+ * Reinstatement sweep for temporary hard-bans (Tier PP — 7-day fraud-reject
+ * bans) whose `hardBanExpiresAt` has passed. Reversal scope is deliberately
+ * narrow — only what the ban itself directly controlled:
+ *   - Re-enable Firebase Auth login.
+ *   - Clear `isDisabled`, stamp `hardBanReinstatedAt` (keeps `hardBanReason`/
+ *     `hardBannedAt`/`hardBannedBy`/`hardBanExpiresAt` as historical record).
+ * Deliberately NOT reversed — these need separate admin/appeal action:
+ *   - The seller's store stays `suspended` (hardBanCascade stage 4).
+ *   - Cancelled bids stay cancelled (stage 5).
+ *   - Cross-account address/payment-method cluster bans stay banned
+ *     (stages 6/7 — independent fraud-ring findings, not solely contingent
+ *     on this user's temporary status).
+ */
+export async function runHardBanReinstatement(ctx) {
+    ctx.logger.info("Scanning temporary hard-bans past their expiry");
+    const expired = await userRepository.getExpiredHardBans();
+    if (expired.length === 0) {
+        ctx.logger.info("No expired hard bans found");
+        return;
+    }
+    let reinstated = 0;
+    for (const user of expired) {
+        try {
+            try {
+                await getAdminAuth().updateUser(user.uid, { disabled: false });
+            }
+            catch (err) {
+                void normalizeError(err);
+                ctx.logger.warn("hard-ban reinstatement: Auth re-enable failed (non-fatal)", {
+                    uid: user.uid,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            await userRepository.update(user.uid, {
+                isDisabled: false,
+                hardBanReinstatedAt: ctx.now,
+            });
+            reinstated += 1;
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("Failed to reinstate expired hard ban", err, { uid: user.uid });
+        }
+    }
+    await Promise.allSettled(expired.map((user) => sendNotification({
+        userId: user.uid,
+        type: "account_action",
+        priority: "normal",
+        title: "Account access restored",
+        message: "Your account access has been restored. If your seller store was suspended, contact support to reactivate it.",
+        relatedId: user.uid,
+        relatedType: "user",
+    })));
+    ctx.logger.info("Hard ban reinstatement sweep complete", {
+        scanned: expired.length,
+        reinstated,
+    });
+}

package/dist/_internal/server/jobs/core/jobRunners.js

@@ -30,7 +30,9 @@ async function runHardBanCascadeJob(payload, ctx) {
     const uid = String(payload.uid ?? "");
     const reason = String(payload.reason ?? "");
     const bannedBy = String(payload.bannedBy ?? "");
-    return runHardBanCascade({ uid, reason, bannedBy }, ctx);
+    const expiresAt = typeof payload.expiresAt === "string" ? new Date(payload.expiresAt) : undefined;
+    const fraudOrderId = typeof payload.fraudOrderId === "string" ? payload.fraudOrderId : undefined;
+    return runHardBanCascade({ uid, reason, bannedBy, expiresAt, fraudOrderId }, ctx);
 }
 async function runResetOtpVerificationJob(_payload, ctx) {
     return runResetOtpVerification(ctx);

package/dist/_internal/server/jobs/core/onScamReportCreate.js

@@ -35,7 +35,7 @@ export async function handleScamReportCreate(input, ctx) {
             pageSize: 100,
         });
         const scamTypeLabel = scamType ? (SCAM_TYPE_LABELS[scamType] ?? scamType) : "Unknown";
-        const amountStr = amountLost ? ` ₹${(amountLost / 100).toLocaleString("en-IN")}` : "";
+        const amountStr = amountLost ? ` ₹${amountLost.toLocaleString("en-IN")}` : "";
         const platformStr = scamPlatform ? ` via ${scamPlatform}` : "";
         await Promise.all(result.items.filter((e) => !!e.id).map((employee) => sendNotification({
             userId: employee.id,

package/dist/_internal/server/jobs/core/paymentReviewAutoApprove.d.ts

@@ -0,0 +1,10 @@
+import type { JobContext } from "../runtime/types";
+/**
+ * 2-hour auto-approve safety net — a manual-payment proof nobody has acted
+ * on (no admin approve / re-upload-request / fraud-reject) within 2 hours of
+ * submission is auto-confirmed, exactly mirroring `adminVerifyPaymentAction`'s
+ * effect, plus `autoApproved`/`autoApprovedAt` so it's visibly distinguishable
+ * from a manually-reviewed order. Buyer/seller can raise a dispute afterward
+ * via `raiseOrderDisputeAction` — this sweep never reverses itself.
+ */
+export declare function runPaymentReviewAutoApprove(ctx: JobContext): Promise<void>;

package/dist/_internal/server/jobs/core/paymentReviewAutoApprove.js

@@ -0,0 +1,60 @@
+import { orderRepository } from "../../../../repositories";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { normalizeError } from "../../../../errors/normalize";
+import { ORDER_MESSAGES } from "../handlers/messages";
+const AUTO_APPROVE_HOURS = 2;
+/**
+ * 2-hour auto-approve safety net — a manual-payment proof nobody has acted
+ * on (no admin approve / re-upload-request / fraud-reject) within 2 hours of
+ * submission is auto-confirmed, exactly mirroring `adminVerifyPaymentAction`'s
+ * effect, plus `autoApproved`/`autoApprovedAt` so it's visibly distinguishable
+ * from a manually-reviewed order. Buyer/seller can raise a dispute afterward
+ * via `raiseOrderDisputeAction` — this sweep never reverses itself.
+ */
+export async function runPaymentReviewAutoApprove(ctx) {
+    ctx.logger.info(`Scanning unreviewed payment proofs > ${AUTO_APPROVE_HOURS}h old`);
+    const unreviewed = await orderRepository.getUnreviewedProofPastDeadline(AUTO_APPROVE_HOURS);
+    if (unreviewed.length === 0) {
+        ctx.logger.info("No unreviewed payment proofs past the auto-approve window");
+        return;
+    }
+    let approved = 0;
+    for (const entry of unreviewed) {
+        try {
+            await orderRepository.update(entry.id, {
+                paymentStatus: "paid",
+                paymentId: entry.data.paymentTransactionId ?? entry.data.paymentId ?? `manual-${entry.id}`,
+                status: "processing",
+                paymentRecord: {
+                    method: "manual",
+                    transactionId: entry.data.paymentTransactionId,
+                    proofUrl: entry.data.paymentProofUrl,
+                    amount: entry.data.totalPrice,
+                    paidAt: ctx.now,
+                    verifiedBy: "system:auto-approve",
+                    verificationMethod: "manual_review",
+                },
+                autoApproved: true,
+                autoApprovedAt: ctx.now,
+            });
+            approved += 1;
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("Failed to auto-approve payment proof", err, { orderId: entry.id });
+        }
+    }
+    await Promise.allSettled(unreviewed.map((entry) => sendNotification({
+        userId: entry.data.userId,
+        type: "payment_review",
+        priority: "normal",
+        title: ORDER_MESSAGES.AUTO_APPROVED_TITLE,
+        message: ORDER_MESSAGES.AUTO_APPROVED_MESSAGE(entry.data.productTitle),
+        relatedId: entry.id,
+        relatedType: "order",
+    })));
+    ctx.logger.info("Payment review auto-approve sweep complete", {
+        scanned: unreviewed.length,
+        approved,
+    });
+}

package/dist/_internal/server/jobs/core/paymentWindowTimeout.d.ts

@@ -0,0 +1,15 @@
+import type { JobContext } from "../runtime/types";
+/**
+ * 15-minute payment window sweep — cancels + restocks any `upi_manual`/
+ * `cash`/`emi` order still `pending`/`pending` with no proof uploaded past
+ * its `paymentDeadline`. Runs every 5 minutes (`EVERY_5_MIN`), so an order
+ * can overshoot its 15-minute deadline by up to ~5 minutes before this
+ * catches it — acceptable, matches the existing tight-interval precedent
+ * (`prizeRevealOpen`/`prizeRevealClose`) rather than inventing a 1-minute
+ * cron that would multiply invocation cost for marginal UX gain.
+ *
+ * Orders that already have a `paymentProofUrl` are excluded by the
+ * repository query — those are the 2-hour auto-approve sweep's domain
+ * (`paymentReviewAutoApprove`), not this one's.
+ */
+export declare function runPaymentWindowTimeout(ctx: JobContext): Promise<void>;

package/dist/_internal/server/jobs/core/paymentWindowTimeout.js

@@ -0,0 +1,59 @@
+import { orderRepository } from "../../../../repositories";
+import { normalizeError } from "../../../../errors/normalize";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { restoreStockForOrder } from "../../features/checkout/stock-restore";
+import { OrderStatusValues } from "../../../../features/orders/schemas/firestore";
+import { PAYMENT_WINDOW_EXPIRED_REASON } from "../../../../features/orders/constants/payment-window";
+import { ORDER_MESSAGES } from "../handlers/messages";
+/**
+ * 15-minute payment window sweep — cancels + restocks any `upi_manual`/
+ * `cash`/`emi` order still `pending`/`pending` with no proof uploaded past
+ * its `paymentDeadline`. Runs every 5 minutes (`EVERY_5_MIN`), so an order
+ * can overshoot its 15-minute deadline by up to ~5 minutes before this
+ * catches it — acceptable, matches the existing tight-interval precedent
+ * (`prizeRevealOpen`/`prizeRevealClose`) rather than inventing a 1-minute
+ * cron that would multiply invocation cost for marginal UX gain.
+ *
+ * Orders that already have a `paymentProofUrl` are excluded by the
+ * repository query — those are the 2-hour auto-approve sweep's domain
+ * (`paymentReviewAutoApprove`), not this one's.
+ */
+export async function runPaymentWindowTimeout(ctx) {
+    ctx.logger.info("Scanning orders past their 15-minute payment deadline");
+    const expired = await orderRepository.getExpiredPaymentDeadlines();
+    if (expired.length === 0) {
+        ctx.logger.info("No expired payment-window orders found");
+        return;
+    }
+    let restored = 0;
+    for (const entry of expired) {
+        try {
+            await restoreStockForOrder(ctx.db, { ...entry.data, id: entry.id }, {
+                status: OrderStatusValues.CANCELLED,
+                cancellationDate: ctx.now,
+                cancellationReason: PAYMENT_WINDOW_EXPIRED_REASON,
+                updatedAt: ctx.now,
+            });
+            restored += 1;
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("Failed to cancel + restore stock for expired payment-window order", err, {
+                orderId: entry.id,
+            });
+        }
+    }
+    await Promise.allSettled(expired.map((entry) => sendNotification({
+        userId: entry.data.userId,
+        type: "order_cancelled",
+        priority: "normal",
+        title: ORDER_MESSAGES.CANCELLED_PAYMENT_WINDOW_TITLE,
+        message: ORDER_MESSAGES.CANCELLED_PAYMENT_WINDOW_MESSAGE(entry.data.productTitle),
+        relatedId: entry.id,
+        relatedType: "order",
+    })));
+    ctx.logger.info("Payment window timeout sweep complete", {
+        scanned: expired.length,
+        restored,
+    });
+}

package/dist/_internal/server/jobs/core/pendingOrderTimeout.d.ts

@@ -1,2 +1,9 @@
 import type { JobContext } from "../runtime/types";
+/**
+ * COD 24h safety net. Orders with a `paymentDeadline` set (upi_manual/cash/
+ * emi) are excluded — those belong to the 15-minute `paymentWindowTimeout`
+ * sweep instead (Tier PP), which fires far sooner. Leaving them in this
+ * job's scope too would just be redundant double-processing against the
+ * same order under two different `cancellationReason`s.
+ */
 export declare function runPendingOrderTimeout(ctx: JobContext): Promise<void>;

package/dist/_internal/server/jobs/core/pendingOrderTimeout.js

@@ -1,28 +1,54 @@
 import { orderRepository } from "../../../../repositories";
+import { normalizeError } from "../../../../errors/normalize";
 import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { restoreStockForOrder } from "../../features/checkout/stock-restore";
+import { OrderStatusValues } from "../../../../features/orders/schemas/firestore";
 import { ORDER_MESSAGES } from "../handlers/messages";
 const DEFAULT_TIMEOUT_HOURS = 24;
+/**
+ * COD 24h safety net. Orders with a `paymentDeadline` set (upi_manual/cash/
+ * emi) are excluded — those belong to the 15-minute `paymentWindowTimeout`
+ * sweep instead (Tier PP), which fires far sooner. Leaving them in this
+ * job's scope too would just be redundant double-processing against the
+ * same order under two different `cancellationReason`s.
+ */
 export async function runPendingOrderTimeout(ctx) {
     const timeoutHours = Number(ctx.env("ORDER_TIMEOUT_HOURS") ?? DEFAULT_TIMEOUT_HOURS);
     ctx.logger.info(`Scanning orders unpaid > ${timeoutHours}h`);
-    const timedOut = await orderRepository.getTimedOutPending(timeoutHours);
+    const timedOutAll = await orderRepository.getTimedOutPending(timeoutHours);
+    const timedOut = timedOutAll.filter((entry) => !entry.data.paymentDeadline);
     if (timedOut.length === 0) {
         ctx.logger.info("No timed-out pending orders found");
         return;
     }
-    const batch = ctx.db.batch();
+    let restored = 0;
     for (const entry of timedOut) {
-        orderRepository.cancelInBatch(batch, entry.ref);
+        try {
+            // Stock decremented at checkout for every payment method (including
+            // COD) was never restored on timeout-cancel before this fix.
+            await restoreStockForOrder(ctx.db, { ...entry.data, id: entry.id }, {
+                status: OrderStatusValues.CANCELLED,
+                cancellationDate: ctx.now,
+                cancellationReason: "payment_timeout",
+                updatedAt: ctx.now,
+            });
+            restored += 1;
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("Failed to cancel + restore stock for timed-out order", err, {
+                orderId: entry.id,
+            });
+        }
     }
-    await batch.commit();
     await Promise.allSettled(timedOut.map((entry) => sendNotification({
         userId: entry.data.userId,
         type: "order_cancelled",
         priority: "normal",
         title: ORDER_MESSAGES.CANCELLED_TITLE,
         message: ORDER_MESSAGES.CANCELLED_TIMEOUT_MESSAGE(entry.data.productTitle, timeoutHours),
-        relatedId: entry.data.id,
+        relatedId: entry.id,
         relatedType: "order",
     })));
-    ctx.logger.info("Pending order timeout complete", { cancelled: timedOut.length });
+    ctx.logger.info("Pending order timeout complete", { cancelled: timedOut.length, restored });
 }

package/dist/_internal/server/jobs/handlers/hardBanReinstatement.d.ts

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

package/dist/_internal/server/jobs/handlers/hardBanReinstatement.js

@@ -0,0 +1,2 @@
+import { runHardBanReinstatement } from "../core/hardBanReinstatement";
+export const hardBanReinstatementHandler = runHardBanReinstatement;

package/dist/_internal/server/jobs/handlers/index.d.ts

@@ -24,6 +24,9 @@ export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler, type PromotionsCallableResult } from "./promotions";
 export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
 export { pendingOrderTimeoutHandler } from "./pendingOrderTimeout";
+export { paymentWindowTimeoutHandler } from "./paymentWindowTimeout";
+export { hardBanReinstatementHandler } from "./hardBanReinstatement";
+export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
 export { positionsReconcileHandler } from "./positionsReconcile";
 export { payoutBatchHandler } from "./payoutBatch";

package/dist/_internal/server/jobs/handlers/index.js

@@ -24,6 +24,9 @@ export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler } from "./promotions";
 export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
 export { pendingOrderTimeoutHandler } from "./pendingOrderTimeout";
+export { paymentWindowTimeoutHandler } from "./paymentWindowTimeout";
+export { hardBanReinstatementHandler } from "./hardBanReinstatement";
+export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
 export { positionsReconcileHandler } from "./positionsReconcile";
 export { payoutBatchHandler } from "./payoutBatch";

package/dist/_internal/server/jobs/handlers/messages.d.ts

@@ -18,6 +18,10 @@ export declare const BID_MESSAGES: {
 export declare const ORDER_MESSAGES: {
     CANCELLED_TITLE: string;
     CANCELLED_TIMEOUT_MESSAGE: (productTitle: string, hours: number) => string;
+    CANCELLED_PAYMENT_WINDOW_TITLE: string;
+    CANCELLED_PAYMENT_WINDOW_MESSAGE: (productTitle: string) => string;
+    AUTO_APPROVED_TITLE: string;
+    AUTO_APPROVED_MESSAGE: (productTitle: string) => string;
     CONFIRMED_TITLE: string;
     CONFIRMED_MESSAGE: (productTitle: string) => string;
     SHIPPED_TITLE: string;

package/dist/_internal/server/jobs/handlers/messages.js

@@ -18,6 +18,10 @@ export const BID_MESSAGES = {
 export const ORDER_MESSAGES = {
     CANCELLED_TITLE: "Order cancelled",
     CANCELLED_TIMEOUT_MESSAGE: (productTitle, hours) => `Your order for "${productTitle}" was cancelled because payment was not received within ${hours} hours.`,
+    CANCELLED_PAYMENT_WINDOW_TITLE: "Payment window expired",
+    CANCELLED_PAYMENT_WINDOW_MESSAGE: (productTitle) => `Your order for "${productTitle}" was cancelled because payment wasn't completed within the 15-minute window. The item is back in stock — you're welcome to order again.`,
+    AUTO_APPROVED_TITLE: "Payment auto-confirmed",
+    AUTO_APPROVED_MESSAGE: (productTitle) => `Your payment proof for "${productTitle}" was auto-confirmed after 2 hours without manual review. If something looks wrong, you can raise a dispute from your order.`,
     CONFIRMED_TITLE: "Order confirmed ✅",
     CONFIRMED_MESSAGE: (productTitle) => `Your order for "${productTitle}" has been confirmed and is being prepared.`,
     SHIPPED_TITLE: "Your order has shipped 📦",

package/dist/_internal/server/jobs/handlers/onShipmentAllocationSync.d.ts

@@ -5,12 +5,12 @@
  *   (a) any write to shipmentLots/{lotId} (itemCount/revenue changed via
  *       Function #1, or the admin edited weight/cost/remainder fields)
  *   (b) any write to procurementShipments/{shipmentId} (admin edited
- *       customsTotalPaise/shippingTotalPaise/laborHoursSpent/status)
+ *       customsTotal/shippingTotal/laborHoursSpent/status)
  *
  * Both re-run the same cross-lot allocation: read every sibling lot
  * (bounded ≤10), call the shared pure allocateShipmentCosts(), batch-write
- * each lot's customsAllocatedPaise/shippingAllocatedPaise/totalLandedCostPaise/
- * projectedRevenuePaise/projectedProfitPaise plus the shipment's persisted
+ * each lot's customsAllocated/shippingAllocated/totalLandedCost/
+ * projectedRevenue/projectedProfit plus the shipment's persisted
  * `totals` + `totalsComputedAt`. Also keeps ShipmentLot.shipmentStatus in
  * sync with its parent so the Projections list can filter on it directly.
  *

package/dist/_internal/server/jobs/handlers/onShipmentAllocationSync.js

@@ -10,23 +10,23 @@ async function recomputeShipmentAllocation(shipmentId, ctx) {
     const lots = lotsSnap.docs.map((doc) => ({ id: doc.id, ...doc.data() }));
     const allocationInputs = lots.map((lot) => ({
         id: lot.id,
-        purchaseCostPaise: lot.purchaseCostPaise ?? 0,
+        purchaseCost: lot.purchaseCost ?? 0,
         weightGrams: lot.weightGrams ?? 0,
-        mainItemsProjectedRevenuePaise: lot.mainItemsProjectedRevenuePaise ?? 0,
-        remainderEstimatedValuePaise: lot.remainderEstimatedValuePaise,
+        mainItemsProjectedRevenue: lot.mainItemsProjectedRevenue ?? 0,
+        remainderEstimatedValue: lot.remainderEstimatedValue,
         itemCount: lot.itemCount ?? 0,
     }));
     // Site-settings labor rate could be read here; falls back to the
     // shipment's own snapshot rate + a fixed max-hours-per-day default,
     // matching what the admin editor's preview also uses.
-    const laborRatePaisePerHour = shipment.laborRatePaisePerHour ?? 0;
+    const laborRatePerHour = shipment.laborRatePerHour ?? 0;
     const laborHoursSpent = shipment.laborHoursSpent ?? 0;
     const { perLot, totals } = allocateShipmentCosts({
         lots: allocationInputs,
-        customsTotalPaise: shipment.customsTotalPaise ?? 0,
-        shippingTotalPaise: shipment.shippingTotalPaise ?? 0,
+        customsTotal: shipment.customsTotal ?? 0,
+        shippingTotal: shipment.shippingTotal ?? 0,
         laborHoursSpent,
-        laborRatePaisePerHour,
+        laborRatePerHour,
         maxHoursPerDay: DEFAULT_MAX_HOURS_PER_DAY,
     });
     const batch = ctx.db.batch();
@@ -34,11 +34,11 @@ async function recomputeShipmentAllocation(shipmentId, ctx) {
     for (const lot of lots) {
         const computed = perLot[lot.id];
         const statusChanged = lot.shipmentStatus !== shipment.status;
-        const valuesChanged = lot.customsAllocatedPaise !== computed.customsAllocatedPaise ||
-            lot.shippingAllocatedPaise !== computed.shippingAllocatedPaise ||
-            lot.totalLandedCostPaise !== computed.totalLandedCostPaise ||
-            lot.projectedRevenuePaise !== computed.projectedRevenuePaise ||
-            lot.projectedProfitPaise !== computed.projectedProfitPaise;
+        const valuesChanged = lot.customsAllocated !== computed.customsAllocated ||
+            lot.shippingAllocated !== computed.shippingAllocated ||
+            lot.totalLandedCost !== computed.totalLandedCost ||
+            lot.projectedRevenue !== computed.projectedRevenue ||
+            lot.projectedProfit !== computed.projectedProfit;
         if (statusChanged || valuesChanged) {
             anyLotChanged = true;
             batch.update(ctx.db.collection("shipmentLots").doc(lot.id), {

package/dist/_internal/server/jobs/handlers/onShipmentItemWrite.d.ts

@@ -2,7 +2,7 @@
  * Function #1 of the procurement-shipments cascade.
  *
  * Fires on any write to shipmentItems/{itemId}. Recomputes the owning lot's
- * item-derived aggregates (itemCount, mainItemsProjectedRevenuePaise) by
+ * item-derived aggregates (itemCount, mainItemsProjectedRevenue) by
  * summing all of that lot's items (bounded ≤500 — Firestore's own batch cap).
  * Writing those aggregates onto shipmentLots/{lotId} is what triggers
  * Function #2 (onShipmentLotWrite) to redo the cross-lot cost allocation.

package/dist/_internal/server/jobs/handlers/onShipmentItemWrite.js

@@ -3,14 +3,14 @@ export const onShipmentItemWriteHandler = async (event, ctx) => {
     if (!lotId)
         return;
     const itemsSnap = await ctx.db.collection("shipmentItems").where("lotId", "==", lotId).get();
-    let mainItemsProjectedRevenuePaise = 0;
+    let mainItemsProjectedRevenue = 0;
     itemsSnap.docs.forEach((doc) => {
         const item = doc.data();
         if (item.isForSelfUse)
             return;
         const price = item.price ?? 0;
         const quantity = item.quantity ?? 0;
-        mainItemsProjectedRevenuePaise += price * quantity;
+        mainItemsProjectedRevenue += price * quantity;
     });
     const itemCount = itemsSnap.size;
     const lotRef = ctx.db.collection("shipmentLots").doc(lotId);
@@ -18,9 +18,9 @@ export const onShipmentItemWriteHandler = async (event, ctx) => {
     if (!lotSnap.exists)
         return;
     const lot = lotSnap.data() ?? {};
-    if (lot.itemCount === itemCount && lot.mainItemsProjectedRevenuePaise === mainItemsProjectedRevenuePaise) {
+    if (lot.itemCount === itemCount && lot.mainItemsProjectedRevenue === mainItemsProjectedRevenue) {
         return; // no-op — breaks the write→trigger→write cycle once settled
     }
-    await lotRef.update({ itemCount, mainItemsProjectedRevenuePaise, updatedAt: ctx.now });
-    ctx.logger.info("Recomputed lot item aggregates", { lotId, itemCount, mainItemsProjectedRevenuePaise });
+    await lotRef.update({ itemCount, mainItemsProjectedRevenue, updatedAt: ctx.now });
+    ctx.logger.info("Recomputed lot item aggregates", { lotId, itemCount, mainItemsProjectedRevenue });
 };

package/dist/_internal/server/jobs/handlers/paymentReviewAutoApprove.d.ts

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

package/dist/_internal/server/jobs/handlers/paymentReviewAutoApprove.js

@@ -0,0 +1,2 @@
+import { runPaymentReviewAutoApprove } from "../core/paymentReviewAutoApprove";
+export const paymentReviewAutoApproveHandler = runPaymentReviewAutoApprove;

package/dist/_internal/server/jobs/handlers/paymentWindowTimeout.d.ts

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

package/dist/_internal/server/jobs/handlers/paymentWindowTimeout.js

@@ -0,0 +1,2 @@
+import { runPaymentWindowTimeout } from "../core/paymentWindowTimeout";
+export const paymentWindowTimeoutHandler = runPaymentWindowTimeout;

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

@@ -1010,6 +1010,33 @@ export const ACTIONS = {
                 confirmLabel: "Yes, verify",
             },
         },
+        "request-payment-reupload": {
+            id: "admin.request-payment-reupload",
+            label: "Request Re-upload",
+            ariaLabel: "Ask the buyer to re-upload a corrected payment proof",
+            description: "Clears the current proof and gives the buyer 15 more minutes to resubmit — for honest mistakes (blurry screenshot, wrong amount), not fraud.",
+            kind: "secondary",
+            permissions: ["admin", "moderator"],
+            confirmation: {
+                title: "Request a proof re-upload?",
+                body: "The buyer's current proof will be cleared and they'll get 15 more minutes to resubmit. Use this for honest mistakes, not suspected fraud.",
+                confirmLabel: "Request re-upload",
+            },
+        },
+        "reject-payment-fraud": {
+            id: "admin.reject-payment-fraud",
+            label: "Reject as Fraudulent",
+            ariaLabel: "Reject this payment proof as fraudulent, cancel the order, and ban the account",
+            description: "Cancels the order, restores stock, and triggers a temporary 7-day full-account ban. Use only for suspected deliberate fraud, not honest mistakes.",
+            kind: "danger",
+            permissions: ["admin", "moderator"],
+            confirmation: {
+                title: "Reject as fraudulent?",
+                body: "This cancels the order, returns the item to stock, and suspends the buyer's account for 7 days. This is severe — use only for suspected deliberate fraud, not an honest mistake.",
+                confirmLabel: "Reject and ban 7 days",
+                confirmKind: "danger",
+            },
+        },
         "verify-vendor": {
             id: "admin.verify-vendor",
             label: "Verify vendor",

package/dist/_internal/shared/checkout/order-math.js

@@ -1,3 +1,4 @@
+import { roundRupees } from "../../../utils/number.formatter";
 // SB-UNI-5 2026-05-13 — bundle cart-lines use item.price (locked bundle price
 // at add-time); regular lines use product.price (current Firestore). Prevents
 // stale cart-cached prices from being charged on COD/UPI orders.
@@ -18,7 +19,7 @@ export function computePreOrderDepositAmount(group, defaultDepositPercent) {
     const raw = group.reduce((sum, { item, product }) => {
         const lineTotal = unitPriceFor(item, product) * item.quantity;
         const pct = product.preOrderDepositPercent ?? defaultDepositPercent;
-        return sum + lineTotal * (pct / 100);
+        return sum + lineTotal * (pct / 100); // audit-money-units-ok: percentage divisor, not paise
     }, 0);
-    return Math.round(raw * 100) / 100;
+    return roundRupees(raw);
 }

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

@@ -15,6 +15,7 @@ export const DEFAULT_LISTING_RULE = {
     splitMultipleOrders: (item) => [item],
     preflightChecks: (_pairs) => { },
     stockDecrementExtras: (_product, _qty) => ({}),
+    stockIncrementExtras: (_product, _qty) => ({}),
     decorateOrderItem: (line, product) => ({
         ...line,
         ...(product.listingType ? { listingType: product.listingType } : {}),

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

@@ -25,4 +25,11 @@ export const preOrderRule = {
             preOrderCurrentCount: (product.preOrderCurrentCount ?? 0) + quantity,
         };
     },
+    stockIncrementExtras: (product, quantity) => {
+        if (product.listingType !== "pre-order")
+            return {};
+        return {
+            preOrderCurrentCount: Math.max(0, (product.preOrderCurrentCount ?? 0) - quantity),
+        };
+    },
 };