@mohasinac/appkit 4.42.18 → 4.44.0

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

@@ -1,8 +1,16 @@
+import { notifyRevalidate } from "./revalidateNotify";
 import { reviewRepository, storeRepository } from "../../../../repositories";
 import { ReviewStatusValues } from "../../../../features/reviews/schemas/firestore";
 import { PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
 export async function handleReviewWrite(input, ctx) {
     const { reviewId, before: beforeData, after: afterData } = input;
+    /*
+     * A review changes the product's rating badge AND the homepage's
+     * `platform_rating` / `total_reviews` stats, so the targets are the listing
+     * pages rather than a per-review page (there isn't one). Uses the review's own
+     * id purely for log correlation. No Firestore write here (Root Cause #92).
+     */
+    await notifyRevalidate({ collection: "reviews", id: reviewId }, ctx);
     const beforeStatus = beforeData?.status ?? null;
     const afterStatus = afterData?.status ?? null;
     const wasApproved = beforeStatus === ReviewStatusValues.APPROVED;

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

@@ -10,4 +10,4 @@ export interface HandleStoreWriteInput {
     before: StoreDoc | null;
     after: StoreDoc | null;
 }
-export declare function handleStoreWrite(_input: HandleStoreWriteInput, _ctx: JobContext): Promise<void>;
+export declare function handleStoreWrite(input: HandleStoreWriteInput, ctx: JobContext): Promise<void>;

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

@@ -2,6 +2,12 @@
  * Core: stores/{id} onWrite — currently a no-op. Previous implementation
  * synced an external search index that has since been removed.
  */
-export async function handleStoreWrite(_input, _ctx) {
-    // Intentionally empty — search provider removed; Firestore queries handle search now.
+import { notifyRevalidate } from "./revalidateNotify";
+export async function handleStoreWrite(input, ctx) {
+    // The search-index sync this used to perform is gone (Firestore queries handle
+    // search now), so the only remaining side-effect is cache invalidation: drop
+    // the ISR entries for this store's page and the stores listing. Reuses the
+    // existing trigger, so this costs no additional invocations, and performs no
+    // Firestore write (Root Cause #92).
+    await notifyRevalidate({ collection: "stores", id: input.storeId }, ctx);
 }

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,234 @@
+/**
+ * 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";
+import { priceIndexRepository, } from "../../../../features/categories/repository/price-index.repository";
+/** 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;
+}
+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 = samples.reduce((best, s) => (!best || s.at > best.at ? s : best), null);
+    return {
+        min: amounts[0],
+        median: median(amounts),
+        max: amounts[amounts.length - 1],
+        sampleSize: samples.length,
+        byPath,
+        ...(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();
+    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);
+    }
+    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();
+            const samples = types.get(listingType) ?? [];
+            samples.push({ amount, at, via });
+            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/revalidateNotify.d.ts

@@ -0,0 +1,28 @@
+import type { JobContext } from "../runtime/types";
+import type { JsonValue } from "@mohasinac/appkit";
+/** Same shape the sibling job cores use (`ProductDoc`, `CategoryDoc`, …). */
+type Doc = Record<string, JsonValue> | null | undefined;
+/**
+ * Did anything a page renders actually change?
+ *
+ * 🛑 Compared with `JSON.stringify` per FIELD, never over the whole document.
+ * Root Cause #92's bug was a whole-object `JSON.stringify` comparison that could
+ * never report "equal" because Firestore returns map keys alphabetically while
+ * the code built them in construction order. Per-field, the values are scalars
+ * or small arrays whose order IS meaningful, so stringify is sound here.
+ *
+ * A create or a delete always counts — there is no previous/next state to diff.
+ */
+export declare function productCacheFieldsChanged(before: Doc, after: Doc): boolean;
+export interface RevalidateNotifyInput {
+    collection: string;
+    id: string;
+    hints?: {
+        listingType?: string;
+        categorySlugs?: string[];
+        brandSlug?: string;
+        storeId?: string;
+    };
+}
+export declare function notifyRevalidate(input: RevalidateNotifyInput, ctx: JobContext): Promise<void>;
+export {};

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

@@ -0,0 +1,125 @@
+import { normalizeError } from "../../../../errors/normalize";
+/**
+ * Tell the Next.js app that a document changed, so it can drop the stale ISR
+ * entries for the pages that render it.
+ *
+ * ## Why an HTTP call and not `revalidatePath()`
+ *
+ * `revalidatePath` only exists inside the Next.js runtime. The writers that
+ * matter most do NOT run there: a checkout stock decrement, auction settlement,
+ * the nightly reconcilers and every `appkit-seed` write all execute in Cloud
+ * Functions or a CLI. A Firestore trigger is the one place that observes all of
+ * them, and the only way it can reach Next's cache is over the network.
+ *
+ * ## 🛑 This does not write to Firestore — by construction
+ *
+ * Root Cause #92: a trigger that writes back to the collection it watches is how
+ * this project produced 1.02M invocations/day and knocked out production. This
+ * performs exactly one `fetch` and touches no document, so it cannot re-trigger
+ * itself. Keep it that way — if this ever needs to persist anything, it needs a
+ * different trigger path, not a write.
+ *
+ * ## Best-effort, and silent about it
+ *
+ * A failed invalidation must never fail the write side-effects it rides along
+ * with — the product is already saved; the worst case is a page that stays stale
+ * until its TTL rolls. So this swallows every error after classifying it, and
+ * logs at `warn` once per failure rather than per document.
+ */
+/** Fields whose change can alter what a public page renders. */
+const CACHE_RELEVANT_PRODUCT_FIELDS = [
+    "status",
+    "stockQuantity",
+    "isSold",
+    "price",
+    "salePrice",
+    "title",
+    "images",
+    "categorySlugs",
+    "brandSlug",
+    "brand",
+    "storeId",
+    "listingType",
+    "auctionEndDate",
+    "currentBid",
+    "buyNowPrice",
+    "isFeatured",
+    "isPromoted",
+    "featured",
+];
+/**
+ * Did anything a page renders actually change?
+ *
+ * 🛑 Compared with `JSON.stringify` per FIELD, never over the whole document.
+ * Root Cause #92's bug was a whole-object `JSON.stringify` comparison that could
+ * never report "equal" because Firestore returns map keys alphabetically while
+ * the code built them in construction order. Per-field, the values are scalars
+ * or small arrays whose order IS meaningful, so stringify is sound here.
+ *
+ * A create or a delete always counts — there is no previous/next state to diff.
+ */
+export function productCacheFieldsChanged(before, after) {
+    if (!before || !after)
+        return true;
+    for (const field of CACHE_RELEVANT_PRODUCT_FIELDS) {
+        if (JSON.stringify(before[field] ?? null) !== JSON.stringify(after[field] ?? null)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The app origin to call.
+ *
+ * No existing job needed one, so this introduces `APP_ORIGIN`. Returning null
+ * (rather than guessing a host) makes an unconfigured deployment a no-op with a
+ * one-line warning instead of a stream of failed requests to the wrong site —
+ * and the stale page it leaves behind is bounded by the TTL.
+ */
+function appOrigin(ctx) {
+    const raw = ctx.env("APP_ORIGIN");
+    if (!raw)
+        return null;
+    return raw.replace(/\/+$/, "");
+}
+export async function notifyRevalidate(input, ctx) {
+    const origin = appOrigin(ctx);
+    const secret = ctx.env("CACHE_REVALIDATION_SECRET");
+    if (!origin || !secret) {
+        ctx.logger.warn("revalidate-notify: not configured — skipping", {
+            hasOrigin: !!origin,
+            hasSecret: !!secret,
+            collection: input.collection,
+        });
+        return;
+    }
+    try {
+        const res = await fetch(`${origin}/api/cache/revalidate`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "x-api-key": secret },
+            body: JSON.stringify({
+                collections: [input.collection],
+                id: input.id,
+                hints: input.hints ?? {},
+            }),
+            // The caller is a background trigger, not a user request — but an
+            // unbounded fetch would pin the function open until the platform kills it.
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok) {
+            ctx.logger.warn("revalidate-notify: endpoint returned non-ok", {
+                status: res.status,
+                collection: input.collection,
+                id: input.id,
+            });
+        }
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("revalidate-notify: request failed", {
+            collection: input.collection,
+            id: input.id,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}

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}

@@ -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/weeklyPayoutEligibility.js

@@ -6,6 +6,7 @@ import { storeRepository, userRepository, orderRepository, payoutRepository, sit
 import { BATCH_LIMIT } from "../handlers/messages";
 import { getDefaultCurrency } from "../../../../core";
 import { computePayoutDeduction } from "../../../shared/fees/calculator";
+import { ordersTaxableValue } from "../../../shared/checkout/order-math";
 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/handlers/analyticsAlertEvaluate.d.ts

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

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

@@ -0,0 +1,2 @@
+import { runAnalyticsAlertEvaluate } from "../core/analyticsAlertEvaluate";
+export const analyticsAlertEvaluateHandler = runAnalyticsAlertEvaluate;

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

@@ -28,6 +28,8 @@ export { hardBanReinstatementHandler } from "./hardBanReinstatement";
 export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
 export { revenueRollupHandler } from "./revenueRollup";
+export { priceIndexRollupHandler } from "./priceIndexRollup";
+export { analyticsAlertEvaluateHandler } from "./analyticsAlertEvaluate";
 export { pageViewRollupHandler } from "./pageViewRollup";
 export { pageViewPruneHandler } from "./pageViewPrune";
 export { dailyStatusDigestHandler } from "./dailyStatusDigest";
@@ -52,7 +54,7 @@ export { onUserBanChangeHandler } from "./onUserBanChange";
 export { onScamReportCreateHandler } from "./onScamReportCreate";
 export { onScamReportUpdateHandler } from "./onScamReportUpdate";
 export { draftPruneHandler } from "./draftPrune";
-export { testerSandboxCleanupHandler } from "./testerSandboxCleanup";
+export { testDataCleanupHandler } from "./testDataCleanup";
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";
 export { onShipmentItemWriteHandler } from "./onShipmentItemWrite";
 export { onShipmentLotWriteHandler, onShipmentHeaderWriteHandler } from "./onShipmentAllocationSync";

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

@@ -28,6 +28,8 @@ export { hardBanReinstatementHandler } from "./hardBanReinstatement";
 export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
 export { revenueRollupHandler } from "./revenueRollup";
+export { priceIndexRollupHandler } from "./priceIndexRollup";
+export { analyticsAlertEvaluateHandler } from "./analyticsAlertEvaluate";
 export { pageViewRollupHandler } from "./pageViewRollup";
 export { pageViewPruneHandler } from "./pageViewPrune";
 export { dailyStatusDigestHandler } from "./dailyStatusDigest";
@@ -64,7 +66,7 @@ export { onScamReportUpdateHandler } from "./onScamReportUpdate";
 // SB-UNI-Y-1 — 30-day draft prune
 export { draftPruneHandler } from "./draftPrune";
 // Tester program — 7-day auto-expiry sweep for the shared admin-seeded test sandbox
-export { testerSandboxCleanupHandler } from "./testerSandboxCleanup";
+export { testDataCleanupHandler } from "./testDataCleanup";
 // Tester program — every-4h revert-live-edits + prune-extras refresh (faster than the 7-day sweep above)
 // EMI — installment reminder + overdue-flagging sweep
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";

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

@@ -55,8 +55,11 @@ export declare const JOB_ERROR_MESSAGES: {
 export declare const CART_TTL_DAYS = 60;
 /** Default Notification TTL in days (matches functions/config/constants). */
 export declare const NOTIFICATION_TTL_DAYS = 30;
-/** Tester sandbox TTL in days — matches testDataExpiresAt() in features/tester/seed-data/tester-ttl.ts. */
-export declare const TESTER_SANDBOX_TTL_DAYS = 7;
+/**
+ * Test-data TTL in days. RE-EXPORTED, not re-declared — this was a second
+ * literal `7` whose only tie to the real one was a comment saying it matched.
+ */
+export { TEST_DATA_TTL_DAYS } from "../../../../seed/test-data-ttl";
 /** Firestore batch write hard ceiling. */
 export declare const BATCH_LIMIT = 500;
 /** Firestore single-query soft ceiling for reconcile sweeps. */

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

@@ -58,8 +58,11 @@ export const JOB_ERROR_MESSAGES = {
 export const CART_TTL_DAYS = 60;
 /** Default Notification TTL in days (matches functions/config/constants). */
 export const NOTIFICATION_TTL_DAYS = 30;
-/** Tester sandbox TTL in days — matches testDataExpiresAt() in features/tester/seed-data/tester-ttl.ts. */
-export const TESTER_SANDBOX_TTL_DAYS = 7;
+/**
+ * Test-data TTL in days. RE-EXPORTED, not re-declared — this was a second
+ * literal `7` whose only tie to the real one was a comment saying it matched.
+ */
+export { TEST_DATA_TTL_DAYS } from "../../../../seed/test-data-ttl";
 /** Firestore batch write hard ceiling. */
 export const BATCH_LIMIT = 500;
 /** Firestore single-query soft ceiling for reconcile sweeps. */

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

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

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

@@ -0,0 +1,2 @@
+import { runPriceIndexRollup } from "../core/priceIndexRollup";
+export const priceIndexRollupHandler = runPriceIndexRollup;

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

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

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

@@ -0,0 +1,2 @@
+import { runTestDataCleanup } from "../core/testDataCleanup";
+export const testDataCleanupHandler = (ctx) => runTestDataCleanup(ctx);