@mohasinac/appkit 4.43.0 → 4.45.0

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

@@ -1,9 +1,9 @@
-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";
+import { orderRepository } from "../../../../repositories/index.js";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions.js";
+import { restoreStockForOrder } from "../../features/checkout/stock-restore.js";
+import { OrderStatusValues } from "../../../../features/orders/schemas/firestore.js";
+import { ORDER_MESSAGES } from "../handlers/messages.js";
 const DEFAULT_TIMEOUT_HOURS = 24;
 /**
  * COD 24h safety net. Orders with a `paymentDeadline` set (upi_manual/cash/

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

@@ -3,7 +3,7 @@
  * DFS pre-order from the roots. Heals drift left by the trigger's
  * `positionDirty` flag and any failed real-time updates.
  */
-import { BATCH_LIMIT } from "../handlers/messages";
+import { BATCH_LIMIT } from "../handlers/messages.js";
 const CATEGORIES = "categories";
 function dfsAssign(nodeId, childMap, counter, result) {
     const position = counter;

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

@@ -0,0 +1,47 @@
+/**
+ * Core: the realised-price index — what things actually SOLD for here.
+ *
+ * ## Why this exists
+ *
+ * Every price signal we show a seller today is an ASK: the seeded `market`
+ * band is a competitor's listed price, and a competitor's sold-out row proves
+ * the item is GONE, not that it sold at that figure. With 76–93% of listings
+ * across the crawled catalogues never selling, the gap between an ask and a
+ * realised price is the single most useful thing we can tell a seller — and we
+ * are the only party who can measure it on our own sales.
+ *
+ * A seeded blog post already tells sellers to *"check what similar items sold
+ * for on LetItRip in the last 30 days"*, which has never been possible.
+ *
+ * ## 🛑 `market` and `sold` are NEVER blended
+ *
+ * They answer different questions and the gap IS the information. Averaging
+ * them would launder an inference into a measurement. This job writes only the
+ * sold half, into its own collection, and never touches the seeded band.
+ *
+ * ## The authoritative field
+ *
+ * **`OrderDocument.items[].unitPrice`** — and specifically not:
+ *
+ *   `OrderDocument.unitPrice`  the FIRST line's price (`unitPriceFor(items[0])`),
+ *                              wrong for every other line
+ *   `OrderDocument.totalPrice` folds in GST, platform fee, shipping and add-ons
+ *   `BidDocument.status==won`  its own comment: `orderId` is absent on a
+ *                              won-but-unpaid bid
+ *   `OfferDocument==accepted`  an agreement, not a sale. `paid` is the sale
+ *   `product.currentBid`       a display mirror a pending buyout never writes
+ *
+ * Won auctions and accepted offers arrive through the same field via
+ * `lockedPrice`, so one field covers all six acquisition paths and
+ * `sourceContext` labels each for free.
+ *
+ * ## Why daily and never live
+ *
+ * A live index would scan orders per request — the unbounded-per-request
+ * pattern that paused this project on Hobby caps. One pre-computed read per
+ * row, with a visible "prices as of {date}". Deliberately one day stale.
+ */
+import type { JobContext } from "../runtime/types";
+/** How far back a band looks. */
+export declare const PRICE_INDEX_WINDOW_DAYS = 90;
+export declare function runPriceIndexRollup(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,304 @@
+/**
+ * Core: the realised-price index — what things actually SOLD for here.
+ *
+ * ## Why this exists
+ *
+ * Every price signal we show a seller today is an ASK: the seeded `market`
+ * band is a competitor's listed price, and a competitor's sold-out row proves
+ * the item is GONE, not that it sold at that figure. With 76–93% of listings
+ * across the crawled catalogues never selling, the gap between an ask and a
+ * realised price is the single most useful thing we can tell a seller — and we
+ * are the only party who can measure it on our own sales.
+ *
+ * A seeded blog post already tells sellers to *"check what similar items sold
+ * for on LetItRip in the last 30 days"*, which has never been possible.
+ *
+ * ## 🛑 `market` and `sold` are NEVER blended
+ *
+ * They answer different questions and the gap IS the information. Averaging
+ * them would launder an inference into a measurement. This job writes only the
+ * sold half, into its own collection, and never touches the seeded band.
+ *
+ * ## The authoritative field
+ *
+ * **`OrderDocument.items[].unitPrice`** — and specifically not:
+ *
+ *   `OrderDocument.unitPrice`  the FIRST line's price (`unitPriceFor(items[0])`),
+ *                              wrong for every other line
+ *   `OrderDocument.totalPrice` folds in GST, platform fee, shipping and add-ons
+ *   `BidDocument.status==won`  its own comment: `orderId` is absent on a
+ *                              won-but-unpaid bid
+ *   `OfferDocument==accepted`  an agreement, not a sale. `paid` is the sale
+ *   `product.currentBid`       a display mirror a pending buyout never writes
+ *
+ * Won auctions and accepted offers arrive through the same field via
+ * `lockedPrice`, so one field covers all six acquisition paths and
+ * `sourceContext` labels each for free.
+ *
+ * ## Why daily and never live
+ *
+ * A live index would scan orders per request — the unbounded-per-request
+ * pattern that paused this project on Hobby caps. One pre-computed read per
+ * row, with a visible "prices as of {date}". Deliberately one day stale.
+ */
+import { orderRepository, productRepository } from "../../../../repositories/index.js";
+import { priceIndexRepository, } from "../../../../features/categories/repository/price-index.repository.js";
+/** How far back a band looks. */
+export const PRICE_INDEX_WINDOW_DAYS = 90;
+/**
+ * Hard ceiling on the products scan.
+ *
+ * The scan exists only to build `productId → categorySlugs[0]`, and that join
+ * disappears for future orders once `categorySlugs[0]` is snapshotted onto the
+ * order item (done in the same change as this job). So the cap is a guard
+ * against a catalogue that grows faster than the snapshot backfills, not a
+ * permanent design limit — and it is logged when it bites rather than
+ * truncating silently.
+ */
+const PRODUCT_SCAN_LIMIT = 5000;
+function toDate(v) {
+    if (!v)
+        return null;
+    const d = v instanceof Date ? v : new Date(v);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+/**
+ * Which acquisition path produced this sale.
+ *
+ * `sourceContext.path` is the richer signal — it distinguishes a settled
+ * auction win from a buy-now, which `orderType` cannot (both are `"auction"`).
+ * Falls back to `orderType`, then to `standard`.
+ */
+function pathOf(order) {
+    const p = order.sourceContext?.path ?? order.orderType;
+    if (p === "auction-won" || p === "auction-buy-now" || p === "auction")
+        return "auction";
+    if (p === "offer-accepted" || p === "offer")
+        return "offer";
+    return "standard";
+}
+/**
+ * 🛑 Completed means delivered AND paid AND not refunded.
+ *
+ * The repo's convention elsewhere is `delivered` alone, and **nothing
+ * currently excludes a delivered-then-refunded order** — whose realised price
+ * is zero. Including one would publish a sale that was undone as evidence of
+ * what things sell for.
+ */
+function isCompleted(order) {
+    if (order.status !== "delivered")
+        return false;
+    if (order.paymentStatus !== "paid")
+        return false;
+    return !(order.refunds && order.refunds.length > 0);
+}
+function median(sorted) {
+    const n = sorted.length;
+    if (n === 0)
+        return 0;
+    const mid = Math.floor(n / 2);
+    const raw = n % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+    return Math.round(raw * 100) / 100;
+}
+/**
+ * The arithmetic mean, to the paisa.
+ *
+ * 🛑 Not a substitute for the median — see `PriceIndexBand.mean`. Both are
+ * computed and both are stored, because on a collectibles leaf one grail sale
+ * moves the mean and not the median, and the gap is the thing worth seeing.
+ */
+function mean(amounts) {
+    if (amounts.length === 0)
+        return 0;
+    const total = amounts.reduce((s, a) => s + a, 0);
+    return Math.round((total / amounts.length) * 100) / 100;
+}
+/** The newest sample, or null for an empty set. */
+function latestOf(samples) {
+    return samples.reduce((best, s) => (!best || s.at > best.at ? s : best), null);
+}
+function toConditionBand(samples) {
+    const amounts = samples.map((s) => s.amount).sort((a, b) => a - b);
+    const latest = latestOf(samples);
+    return {
+        min: amounts[0],
+        median: median(amounts),
+        max: amounts[amounts.length - 1],
+        mean: mean(amounts),
+        sampleSize: samples.length,
+        ...(latest ? { lastSold: { amount: latest.amount, at: latest.at } } : {}),
+    };
+}
+function toBand(samples) {
+    const amounts = samples.map((s) => s.amount).sort((a, b) => a - b);
+    const byPath = {};
+    for (const s of samples)
+        byPath[s.via] = (byPath[s.via] ?? 0) + 1;
+    const latest = latestOf(samples);
+    /*
+     * The per-condition slice.
+     *
+     * 🛑 Samples with no recorded condition are SKIPPED here while still counting
+     * toward the parent band above — their amount is a real sale, but they cannot
+     * tell us what condition sold for what. Bucketing them anywhere would invent
+     * a market.
+     *
+     * 🛑 And the key is omitted entirely rather than written as `{}` when nothing
+     * qualifies. An empty object renders as "we measured conditions and found
+     * none", which is false; absence renders as "no breakdown available", which
+     * is true. Same reasoning as `undefined` vs `0` on a count (Root Cause #72).
+     */
+    const byConditionSamples = new Map();
+    for (const s of samples) {
+        if (!s.condition)
+            continue;
+        const bucket = byConditionSamples.get(s.condition) ?? [];
+        bucket.push(s);
+        byConditionSamples.set(s.condition, bucket);
+    }
+    const byCondition = {};
+    for (const [condition, bucket] of byConditionSamples) {
+        byCondition[condition] = toConditionBand(bucket);
+    }
+    return {
+        min: amounts[0],
+        median: median(amounts),
+        max: amounts[amounts.length - 1],
+        mean: mean(amounts),
+        sampleSize: samples.length,
+        byPath,
+        ...(Object.keys(byCondition).length > 0 ? { byCondition } : {}),
+        ...(latest ? { lastSold: { amount: latest.amount, at: latest.at, via: latest.via } } : {}),
+    };
+}
+/** `YYYYMMDD` in UTC, so the id is stable regardless of where the job runs. */
+function utcDateKey(d) {
+    return `${d.getUTCFullYear()}${String(d.getUTCMonth() + 1).padStart(2, "0")}${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+export async function runPriceIndexRollup(ctx) {
+    const now = new Date();
+    const cutoff = new Date(now.getTime() - PRICE_INDEX_WINDOW_DAYS * 24 * 60 * 60 * 1000);
+    /*
+     * One products scan into a MAP, never N `findById` calls.
+     *
+     * `storeAnalytics.ts:94` does the per-item lookup and it is the pattern not
+     * to copy — an order with 4 items costs 4 reads there, so a 90-day window
+     * over a growing order list is an unbounded read multiplier.
+     */
+    const products = await productRepository.list({
+        page: 1,
+        pageSize: PRODUCT_SCAN_LIMIT,
+    });
+    const rows = products.items ?? [];
+    if (rows.length >= PRODUCT_SCAN_LIMIT) {
+        ctx.logger.warn("priceIndexRollup: product scan saturated — the leaf join may be incomplete", {
+            limit: PRODUCT_SCAN_LIMIT,
+        });
+    }
+    const leafOf = new Map();
+    const typeOf = new Map();
+    const conditionOf = new Map();
+    for (const p of rows) {
+        if (!p.id)
+            continue;
+        const leaf = p.categorySlugs?.[0];
+        if (leaf)
+            leafOf.set(p.id, leaf);
+        if (p.listingType)
+            typeOf.set(p.id, p.listingType);
+        if (p.condition)
+            conditionOf.set(p.id, p.condition);
+    }
+    const delivered = (await orderRepository.findByStatus("delivered"));
+    /** leafId → listingType → samples */
+    const byLeaf = new Map();
+    let considered = 0;
+    let skippedNoLeaf = 0;
+    for (const order of delivered) {
+        if (!isCompleted(order))
+            continue;
+        const at = toDate(order.orderDate) ?? toDate(order.createdAt);
+        if (!at || at < cutoff)
+            continue;
+        const via = pathOf(order);
+        for (const item of order.items ?? []) {
+            const amount = Number(item.unitPrice ?? 0);
+            if (!Number.isFinite(amount) || amount <= 0)
+                continue;
+            /*
+             * A fully-cancelled line is not a sale. A partially-cancelled one is —
+             * the units that shipped sold at that unit price, and the unit price is
+             * what a band is made of, so the quantity does not weight it.
+             */
+            const live = (item.quantity ?? 1) - (item.cancelledQuantity ?? 0);
+            if (live <= 0)
+                continue;
+            /*
+             * The snapshot first, the join second. New orders carry
+             * `categorySlug` and need no products read at all; older ones fall
+             * back to the map. An item whose product has since been deleted
+             * resolves to neither and is COUNTED AS SKIPPED rather than dropped
+             * silently — a band missing sales is indistinguishable from a quiet
+             * category unless somebody says so.
+             */
+            const leaf = item.categorySlug ?? (item.productId ? leafOf.get(item.productId) : undefined);
+            if (!leaf) {
+                skippedNoLeaf += 1;
+                continue;
+            }
+            const listingType = item.listingType ?? (item.productId ? typeOf.get(item.productId) : undefined) ?? "standard";
+            const types = byLeaf.get(leaf) ?? new Map();
+            /*
+             * 🛑 The product's CURRENT condition is a fallback, not the answer.
+             *
+             * A seller who relists the same slug after refurbishing it changes
+             * `product.condition`, which would retroactively re-file an old sale
+             * under the new condition — the same class of lie as recomputing GST
+             * from a changed tax code, which is why `hsnCode`/`gstRate`/`finalSale`
+             * are all snapshotted on the order item. `condition` now is too, and
+             * the map only answers for orders written before that.
+             */
+            const condition = item.condition ?? (item.productId ? conditionOf.get(item.productId) : undefined);
+            const samples = types.get(listingType) ?? [];
+            samples.push({ amount, at, via, ...(condition ? { condition } : {}) });
+            types.set(listingType, samples);
+            byLeaf.set(leaf, types);
+            considered += 1;
+        }
+    }
+    const dateKey = utcDateKey(now);
+    let written = 0;
+    for (const [leafId, types] of byLeaf) {
+        const byListingType = {};
+        const point = {};
+        for (const [listingType, samples] of types) {
+            const band = toBand(samples);
+            byListingType[listingType] = band;
+            point[listingType] = { median: band.median, sampleSize: band.sampleSize };
+        }
+        /*
+         * 🛑 Only leaves WITH sales are written, and nothing is ever zeroed.
+         *
+         * An absent band means "we have no sales here", which the UI renders as
+         * silence. A zeroed one would render as "things sell here for ₹0", which
+         * is worse than silence and is exactly what a defaulting write would
+         * manufacture on the first quiet night. A refund removing the last sale in
+         * a leaf therefore leaves a stale band for a day and then it ages out of
+         * the window — which is the correct behaviour for a figure labelled "as
+         * of" a date.
+         */
+        await priceIndexRepository.setForLeaf(leafId, {
+            byListingType,
+            windowDays: PRICE_INDEX_WINDOW_DAYS,
+        });
+        await priceIndexRepository.setDailyPoint(leafId, dateKey, point);
+        written += 1;
+    }
+    ctx.logger.info("priceIndexRollup: complete", {
+        deliveredScanned: delivered.length,
+        salesCounted: considered,
+        leavesWritten: written,
+        skippedNoLeaf,
+        windowDays: PRICE_INDEX_WINDOW_DAYS,
+    });
+}

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

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
-import { normalizeError } from "../../../../errors/normalize";
-import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions.js";
 const PRODUCT_COLLECTION = "products";
 const ORDER_COLLECTION = "orders";
 /**

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

@@ -1,6 +1,6 @@
-import { normalizeError } from "../../../../errors/normalize";
-import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
-import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names.js";
+import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner.js";
 const PRODUCT_COLLECTION = "products";
 const ORDER_COLLECTION = "orders";
 const PRIZE_DRAW_LISTING_TYPE = "prize-draw";

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

@@ -1,6 +1,6 @@
-import { normalizeError } from "../../../../errors/normalize";
-import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names";
-import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { PRODUCT_FIELDS, ORDER_FIELDS, COMMON_FIELDS } from "../../../../constants/field-names.js";
+import { assignPrizeDrawWinner } from "./prizeDrawAssignWinner.js";
 const ORDER_COLLECTION = "orders";
 function isSoldOut(doc) {
     if (!doc)

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

@@ -4,7 +4,7 @@
  *
  * Concurrency capped at 5 to avoid Firestore read-rate spikes.
  */
-import { productRepository, reviewRepository } from "../../../../repositories";
+import { productRepository, reviewRepository } from "../../../../repositories/index.js";
 const CONCURRENCY = 5;
 async function syncOne(productId) {
     const { count, avgRating } = await reviewRepository.getApprovedRatingAggregate(productId);

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

@@ -1,5 +1,5 @@
-import { productRepository, couponsRepository } from "../../../../repositories";
-import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { productRepository, couponsRepository } from "../../../../repositories/index.js";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore.js";
 /**
  * Promotions data — promoted + featured products and active coupons.
  * Wraps the listing query that needs an OR-shaped

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

@@ -12,9 +12,9 @@
  * freshly-re-enabled feature doesn't inherit rate-limit state from before
  * it was off.
  */
-import { USER_COLLECTION } from "../../../../features/auth/schemas/firestore";
-import { SMS_COUNTERS_COLLECTION } from "../../../../features/auth/schemas/firestore";
-import { normalizeError } from "../../../../errors/normalize";
+import { USER_COLLECTION } from "../../../../features/auth/schemas/firestore.js";
+import { SMS_COUNTERS_COLLECTION } from "../../../../features/auth/schemas/firestore.js";
+import { normalizeError } from "../../../../errors/normalize.js";
 const BATCH_SIZE = 400;
 async function resetPhoneVerifiedFlags(ctx) {
     const failed = [];

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

@@ -1,4 +1,4 @@
-import { normalizeError } from "../../../../errors/normalize";
+import { normalizeError } from "../../../../errors/normalize.js";
 /**
  * Tell the Next.js app that a document changed, so it can drop the stale ISR
  * entries for the pages that render it.

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

@@ -9,8 +9,8 @@
  * `analytics/dashboardRollup` singleton doc; the API route now reads that
  * single doc instead of scanning the collection.
  */
-import { orderRepository } from "../../../../repositories";
-import { analyticsRollupRepository } from "../../../../repositories";
+import { orderRepository } from "../../../../repositories/index.js";
+import { analyticsRollupRepository } from "../../../../repositories/index.js";
 export async function runRevenueRollup(ctx) {
     // No `.catch(() => [])` here on purpose: an empty list is a legitimate
     // outcome that writes `totalRevenue: 0`, so swallowing a query failure would

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

@@ -3,9 +3,9 @@
  * `{ sellerId }` (the Firebase Auth UID); store slug is resolved server-side
  * via `storeRepository.findByOwnerId`.
  */
-import { orderRepository, productRepository, storeRepository, } from "../../../../repositories";
-import { formatMonthYear } from "../../../../utils/date.formatter";
-import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { orderRepository, productRepository, storeRepository, } from "../../../../repositories/index.js";
+import { formatMonthYear } from "../../../../utils/date.formatter.js";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore.js";
 class StoreAnalyticsError extends Error {
     constructor(status, message) {
         super(message);

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

@@ -18,9 +18,9 @@
  * Idempotent: a product already carrying both correct values is skipped, so a
  * re-run over a synced catalogue performs zero writes.
  */
-import { storeRepository } from "../../../../features/stores/repository/store.repository";
-import { productRepository } from "../../../../features/products/repository/products.repository";
-import { normalizeError } from "../../../../errors/normalize";
+import { storeRepository } from "../../../../features/stores/repository/store.repository.js";
+import { productRepository } from "../../../../features/products/repository/products.repository.js";
+import { normalizeError } from "../../../../errors/normalize.js";
 /** Firestore caps a batched write at 500 operations. */
 const BATCH_LIMIT = 500;
 export async function runStoreNameBackfill(payload, ctx) {

package/dist/_internal/server/jobs/core/{testerSandboxCleanup.d.ts → testDataCleanup.d.ts}

@@ -14,9 +14,9 @@ import type { JobContext } from "../runtime/types";
  * (This used to be shared with testerSandboxRefresh.ts, which was removed when
  * the tester runner took over fixture state — see scheduled.ts.)
  */
-export declare const SANDBOX_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events", "offers"];
-export interface TesterSandboxCleanupOptions {
+export declare const TEST_DATA_COLLECTIONS: readonly ["categories", "stores", "products", "blogPosts", "events", "offers"];
+export interface TestDataCleanupOptions {
     /** true = wipe every isTestData:true doc regardless of testDataExpiresAt (manual force-purge). */
     force?: boolean;
 }
-export declare function runTesterSandboxCleanup(ctx: JobContext, opts?: TesterSandboxCleanupOptions): Promise<void>;
+export declare function runTestDataCleanup(ctx: JobContext, opts?: TestDataCleanupOptions): Promise<void>;

package/dist/_internal/server/jobs/core/{testerSandboxCleanup.js → testDataCleanup.js}

@@ -1,5 +1,5 @@
-import { batchDelete, getTestDataRefs } from "../handlers/_helpers";
-import { BID_FIELDS } from "../../../../constants/field-names";
+import { batchDelete, getTestDataRefs } from "../handlers/_helpers.js";
+import { BID_FIELDS } from "../../../../constants/field-names.js";
 /**
  * 🛑 THE definition of "sandbox scope" — six collections, and nothing else.
  *
@@ -15,16 +15,16 @@ import { BID_FIELDS } from "../../../../constants/field-names";
  * (This used to be shared with testerSandboxRefresh.ts, which was removed when
  * the tester runner took over fixture state — see scheduled.ts.)
  */
-export const SANDBOX_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events", "offers"];
+export const TEST_DATA_COLLECTIONS = ["categories", "stores", "products", "blogPosts", "events", "offers"];
 const BID_CHUNK_SIZE = 30; // Firestore `in` query cap
-export async function runTesterSandboxCleanup(ctx, opts = {}) {
+export async function runTestDataCleanup(ctx, opts = {}) {
     const cutoff = opts.force ? null : new Date();
     ctx.logger.info(opts.force
         ? "Force-purging all tester sandbox test data"
         : "Sweeping expired tester sandbox test data");
     const allRefs = [];
     let deletedProductIds = [];
-    for (const collection of SANDBOX_COLLECTIONS) {
+    for (const collection of TEST_DATA_COLLECTIONS) {
         const refs = await getTestDataRefs(ctx.db, collection, cutoff);
         allRefs.push(...refs);
         if (collection === "products") {

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

@@ -3,7 +3,7 @@
  * logic keys off the event's `raffleType`.
  */
 import crypto from "node:crypto";
-import { EVENT_ENTRY_FIELDS } from "../../../../constants/field-names";
+import { EVENT_ENTRY_FIELDS } from "../../../../constants/field-names.js";
 const EVENTS_COLLECTION = "events";
 const EVENT_ENTRIES_COLLECTION = "eventEntries";
 export async function runTriggerEventRaffle(input, ctx) {

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

@@ -2,10 +2,11 @@
  * Core: weekly Saturday sweep — converts delivered orders with
  * `payoutStatus=eligible` into pending payout documents grouped by seller.
  */
-import { storeRepository, userRepository, orderRepository, payoutRepository, siteSettingsRepository, } from "../../../../repositories";
-import { BATCH_LIMIT } from "../handlers/messages";
-import { getDefaultCurrency } from "../../../../core";
-import { computePayoutDeduction } from "../../../shared/fees/calculator";
+import { storeRepository, userRepository, orderRepository, payoutRepository, siteSettingsRepository, } from "../../../../repositories/index.js";
+import { BATCH_LIMIT } from "../handlers/messages.js";
+import { getDefaultCurrency } from "../../../../core/index.js";
+import { computePayoutDeduction } from "../../../shared/fees/calculator.js";
+import { ordersTaxableValue } from "../../../shared/checkout/order-math.js";
 export async function runWeeklyPayoutEligibility(ctx) {
     if (ctx.env("FEATURE_PAYOUTS") !== "true") {
         ctx.logger.info("FEATURE_PAYOUTS disabled — skipping weekly payout eligibility");
@@ -42,7 +43,10 @@ export async function runWeeklyPayoutEligibility(ctx) {
             ctx.logger.warn(`Store/seller ${storeId} not found — skipping ${orders.length} order(s)`);
             continue;
         }
-        const grossAmount = orders.reduce((sum, o) => sum + (o.data.totalPrice ?? 0), 0);
+        /* The TAXABLE VALUE — see `orderTaxableValue`. This job and
+         * `autoPayoutEligibility` must agree, or the weekly run and the automatic
+         * one pay different amounts for the same orders. */
+        const grossAmount = ordersTaxableValue(orders.map((o) => o.data));
         const { platformFee, gatewayFee, gstOnFee, netAmount } = computePayoutDeduction(grossAmount, commissions);
         const payoutInput = {
             storeId,

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

@@ -19,9 +19,9 @@
  *  - That Set is updated as we create, so duplicate rows within one Meta
  *    response can't produce two products.
  */
-import { normalizeError } from "../../../../errors/normalize";
-import { storeRepository, productRepository } from "../../../../repositories";
-import { decryptPii } from "../../../../security/index";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { storeRepository, productRepository } from "../../../../repositories/index.js";
+import { decryptPii } from "../../../../security/index.js";
 const META_GRAPH_BASE = "https://graph.facebook.com/v20.0";
 const SLUG_PREFIX = "product-";
 const PAGE_SIZE = 250;

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

@@ -17,11 +17,11 @@
  * Firebase Function's 300s budget, and a terminal error just burns two
  * extra fast failures before giving up.
  */
-import { normalizeError } from "../../../../errors/normalize";
-import { notificationRepository } from "../../../../features/admin/repository/notification.repository";
-import { sendWhatsAppTemplateMessage, sendWhatsAppBusinessMessage, } from "../../../../features/whatsapp-bot/helpers/whatsapp";
-import { isChannelHealthy, recordChannelOutcome } from "../../notifications/channel-health";
-import { guardSend, logSuppressedSend } from "../../notifications/send-guard";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { notificationRepository } from "../../../../features/admin/repository/notification.repository.js";
+import { sendWhatsAppTemplateMessage, sendWhatsAppBusinessMessage, } from "../../../../features/whatsapp-bot/helpers/whatsapp.js";
+import { isChannelHealthy, recordChannelOutcome } from "../../notifications/channel-health.js";
+import { guardSend, logSuppressedSend } from "../../notifications/send-guard.js";
 const MAX_ATTEMPTS = 3;
 const RETRY_DELAY_MS = 1500;
 function delay(ms) {

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

@@ -6,9 +6,9 @@
  * Apply to every handler in the consumer's runtime adapter so the maintenance
  * UI sees a row for every Cloud Function failure.
  */
-import { mapToHttpError } from "../../../../errors/error-mapping";
-import { normalizeError } from "../../../../errors/normalize";
-import { serverErrorsRepository } from "../../../../features/server-errors/repository/server-errors.repository";
+import { mapToHttpError } from "../../../../errors/error-mapping.js";
+import { normalizeError } from "../../../../errors/normalize.js";
+import { serverErrorsRepository } from "../../../../features/server-errors/repository/server-errors.repository.js";
 async function persist(name, err, ctxLike) {
     const mapped = mapToHttpError(err);
     try {

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

@@ -1,9 +1,9 @@
 /**
  * Shared helpers for job handlers.
  */
-import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
-import { PRODUCT_FIELDS } from "../../../../constants/field-names";
-import { BATCH_LIMIT } from "./messages";
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase/index.js";
+import { PRODUCT_FIELDS } from "../../../../constants/field-names.js";
+import { BATCH_LIMIT } from "./messages.js";
 /** Batch-delete document refs, respecting Firestore's 500-write batch limit. */
 export async function batchDelete(ctx, refs) {
     let deleted = 0;

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

@@ -1,2 +1,2 @@
-import { runAdminAnalytics } from "../core/adminAnalytics";
+import { runAdminAnalytics } from "../core/adminAnalytics.js";
 export const adminAnalyticsHandler = runAdminAnalytics;