@mohasinac/appkit 3.4.8 → 3.5.1

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

@@ -0,0 +1,181 @@
+/**
+ * Core: hard-ban cascade — disables Auth login, marks the user banned,
+ * revokes sessions, suspends any owned store + archives its products,
+ * cancels active bids, and cascades the ban across any address / payment
+ * clusters shared with other accounts (fraud-ring containment).
+ *
+ * Extracted verbatim (stage-for-stage) from the former synchronous
+ * `POST /api/admin/users/[uid]/hard-ban` route body — that route now only
+ * runs the cheap pre-flight guards (self-ban / target-exists / admin-target)
+ * and enqueues this as a `hardBanCascade` job (see `./jobRunners.ts`) so the
+ * cascade runs inside a Firebase Function instead of the Vercel 10s sync
+ * ceiling (CLAUDE.md Rule #6).
+ *
+ * Each stage keeps its original non-fatal try/catch-log-continue behavior,
+ * EXCEPT stage 2 (marking the user banned on Firestore), which is the one
+ * write that must succeed for the ban to take effect — if it throws, the job
+ * is marked failed so an admin can retry.
+ */
+import { normalizeError } from "../../../../errors/normalize";
+import { userRepository, sessionRepository, storeRepository, productRepository, bidRepository, addressesRepository, savedPaymentMethodsRepository, siteSettingsRepository, } from "../../../../repositories";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { isSellerUser } from "../../../../features/auth/role-predicates";
+import { getAdminAuth } from "../../../../providers/db-firebase";
+async function cascadeAddressClusterBan(uid, banData) {
+    const userAddresses = await addressesRepository.listByOwner("user", uid);
+    const uniqueHashes = [...new Set(userAddresses.map((a) => a.addressHash).filter(Boolean))];
+    for (const hash of uniqueHashes) {
+        const cluster = await addressesRepository.listByAddressHash(hash);
+        const hasBannedAccount = cluster.some((a) => a.ownerId !== uid && a.banStatus === "banned");
+        if (!hasBannedAccount)
+            continue;
+        const otherOwners = [...new Set(cluster.filter((a) => a.ownerId !== uid).map((a) => `${a.ownerType}|${a.ownerId}`))];
+        for (const ownerKey of otherOwners) {
+            const [ownerType, ownerId] = ownerKey.split("|");
+            await addressesRepository.banAllForOwner(ownerType, ownerId, banData);
+        }
+    }
+}
+async function cascadePaymentClusterBan(uid, banData) {
+    const userMethods = await savedPaymentMethodsRepository.listByUser(uid);
+    for (const method of userMethods) {
+        if (!method.identifierHash)
+            continue;
+        const cluster = await savedPaymentMethodsRepository.listByIdentifierHash(method.identifierHash);
+        const hasBannedAccount = cluster.some((m) => m.userId !== uid && m.banStatus === "banned");
+        if (!hasBannedAccount)
+            continue;
+        const otherUserIds = [...new Set(cluster.filter((m) => m.userId !== uid).map((m) => m.userId))];
+        for (const otherId of otherUserIds) {
+            await savedPaymentMethodsRepository.banAllForUser(otherId, banData);
+        }
+    }
+}
+export async function runHardBanCascade(input, ctx) {
+    const { uid, reason, bannedBy } = input;
+    const target = await userRepository.findById(uid);
+    if (!target) {
+        return {
+            summary: { total: 1, succeeded: 0, skipped: 1, failed: 0 },
+            succeeded: [],
+            skipped: [uid],
+            failed: [],
+        };
+    }
+    // 1. Disable Firebase Auth login
+    try {
+        await getAdminAuth().updateUser(uid, { disabled: true });
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: Auth disable failed (user may lack Auth record)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    // 2. Mark banned on Firestore doc — the one write that must succeed for the
+    // ban to take effect. Left unguarded so a failure here marks the whole job
+    // failed (matches the original route's behavior of surfacing a 500).
+    await userRepository.update(uid, {
+        isDisabled: true,
+        hardBanReason: reason,
+        hardBannedAt: new Date(),
+        hardBannedBy: bannedBy,
+    });
+    // 3. Delete active sessions
+    try {
+        const sessions = await sessionRepository.findActiveByUser(uid);
+        await Promise.all(sessions.map((s) => sessionRepository.delete(s.id)));
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: session cleanup failed (non-fatal)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    // 4. Cascade to store if seller
+    if (isSellerUser(target)) {
+        try {
+            const store = await storeRepository.findByOwnerId(uid);
+            if (store) {
+                await storeRepository.update(store.id, { status: "suspended" });
+                const products = await productRepository.findByStore(store.id);
+                await Promise.all(products.map((p) => productRepository.update(p.id, { status: "archived" })));
+            }
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.warn("hard-ban: store/product cascade failed (non-fatal)", {
+                uid,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // 5. Cancel active bids
+    try {
+        const bids = await bidRepository.findBy("bidderId", uid);
+        const activeBids = bids.filter((b) => b.status === "active");
+        await Promise.all(activeBids.map((b) => bidRepository.update(b.id, { status: "cancelled" })));
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: bid cancellation failed (non-fatal)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    // 6. Cascade address ban + cross-account cluster ban
+    try {
+        const banData = { banReason: `User hard-banned: ${reason}`, bannedBy };
+        await addressesRepository.banAllForOwner("user", uid, banData);
+        await cascadeAddressClusterBan(uid, banData);
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: address cluster ban failed (non-fatal)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    // 7. Cascade payment method ban + cross-account cluster ban
+    try {
+        const banData = { banReason: `User hard-banned: ${reason}`, bannedBy };
+        await savedPaymentMethodsRepository.banAllForUser(uid, banData);
+        await cascadePaymentClusterBan(uid, banData);
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: payment method cluster ban failed (non-fatal)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    // 8. Notify user
+    try {
+        const siteSettings = await siteSettingsRepository.getSingleton();
+        const supportEmail = siteSettings.contact?.email || "support@example.com";
+        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}.`,
+            relatedId: uid,
+            relatedType: "user",
+        });
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("hard-ban: user notification failed (non-fatal)", {
+            uid,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    return {
+        summary: { total: 1, succeeded: 1, skipped: 0, failed: 0 },
+        succeeded: [uid],
+        skipped: [],
+        failed: [],
+    };
+}

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

@@ -22,7 +22,9 @@ export { runPayoutBatch } from "./payoutBatch";
 export { runAutoPayoutEligibility } from "./autoPayoutEligibility";
 export { runProductStatsSync } from "./productStatsSync";
 export { runPositionsReconcile } from "./positionsReconcile";
-export { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
+export { runWeeklyPayoutEligibility, type WeeklyPayoutEligibilityResult, } from "./weeklyPayoutEligibility";
+export { runHardBanCascade } from "./hardBanCascade";
+export { JOB_RUNNERS, type JobRunner, type JobRunResult, } from "./jobRunners";
 export { runAuctionSettlement } from "./auctionSettlement";
 export { runPrizeRevealOpen } from "./prizeRevealOpen";
 export { runPrizeRevealClose } from "./prizeRevealClose";
@@ -42,3 +44,4 @@ export { handleProductStockChange, type HandleProductStockChangeInput, syncBundl
 export { handleReviewWrite, type HandleReviewWriteInput } from "./onReviewWrite";
 export { handleCategoryWrite, type HandleCategoryWriteInput, type CategoryDoc, } from "./onCategoryWrite";
 export { handleStoreWrite, type HandleStoreWriteInput, type StoreDoc, } from "./onStoreWrite";
+export { handleJobCreated, type HandleJobCreatedInput } from "./onJobCreated";

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

@@ -23,7 +23,9 @@ export { runPayoutBatch } from "./payoutBatch";
 export { runAutoPayoutEligibility } from "./autoPayoutEligibility";
 export { runProductStatsSync } from "./productStatsSync";
 export { runPositionsReconcile } from "./positionsReconcile";
-export { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
+export { runWeeklyPayoutEligibility, } from "./weeklyPayoutEligibility";
+export { runHardBanCascade } from "./hardBanCascade";
+export { JOB_RUNNERS, } from "./jobRunners";
 export { runAuctionSettlement } from "./auctionSettlement";
 export { runPrizeRevealOpen } from "./prizeRevealOpen";
 export { runPrizeRevealClose } from "./prizeRevealClose";
@@ -45,3 +47,4 @@ export { handleProductStockChange, syncBundlesForProduct, syncGroupedListingsFor
 export { handleReviewWrite } from "./onReviewWrite";
 export { handleCategoryWrite, } from "./onCategoryWrite";
 export { handleStoreWrite, } from "./onStoreWrite";
+export { handleJobCreated } from "./onJobCreated";

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

@@ -0,0 +1,28 @@
+/**
+ * JOB_RUNNERS — registry of `jobType` → runner function for the
+ * `onJobCreated` Firestore trigger (see `./onJobCreated.ts`).
+ *
+ * Every runner takes the job's opaque `payload` + a `JobContext` and returns
+ * a `JobRunResult` shaped like the client-facing `BulkActionResult` (see
+ * `appkit/src/react/hooks/useBulkAction.ts`) so it can be written verbatim to
+ * both the `jobs/{jobId}.result` field and the `bulk_events/{jobId}` RTDB
+ * ping channel the client subscribes to via `useBulkEvent`.
+ */
+import type { JobContext } from "../runtime/types";
+export interface JobRunResult {
+    summary: {
+        total: number;
+        succeeded: number;
+        skipped: number;
+        failed: number;
+    };
+    succeeded: string[];
+    skipped: string[];
+    failed: {
+        id: string;
+        reason: string;
+    }[];
+    data?: Record<string, unknown>;
+}
+export type JobRunner = (payload: Record<string, unknown>, ctx: JobContext) => Promise<JobRunResult>;
+export declare const JOB_RUNNERS: Record<string, JobRunner>;

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

@@ -0,0 +1,37 @@
+/**
+ * JOB_RUNNERS — registry of `jobType` → runner function for the
+ * `onJobCreated` Firestore trigger (see `./onJobCreated.ts`).
+ *
+ * Every runner takes the job's opaque `payload` + a `JobContext` and returns
+ * a `JobRunResult` shaped like the client-facing `BulkActionResult` (see
+ * `appkit/src/react/hooks/useBulkAction.ts`) so it can be written verbatim to
+ * both the `jobs/{jobId}.result` field and the `bulk_events/{jobId}` RTDB
+ * ping channel the client subscribes to via `useBulkEvent`.
+ */
+import { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
+import { runHardBanCascade } from "./hardBanCascade";
+async function runPayoutsWeeklyJob(_payload, ctx) {
+    const { payoutsCreated, ordersProcessed, payoutIds } = await runWeeklyPayoutEligibility(ctx);
+    return {
+        summary: {
+            total: payoutsCreated,
+            succeeded: payoutsCreated,
+            skipped: 0,
+            failed: 0,
+        },
+        succeeded: payoutIds,
+        skipped: [],
+        failed: [],
+        data: { payoutsCreated, ordersProcessed },
+    };
+}
+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);
+}
+export const JOB_RUNNERS = {
+    payoutsWeekly: runPayoutsWeeklyJob,
+    hardBanCascade: runHardBanCascadeJob,
+};

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

@@ -0,0 +1,15 @@
+import type { JobContext } from "../runtime/types";
+import type { CatalogueItemDocument } from "../../../../features/catalogue/schemas/firestore";
+export interface CatalogueApprovalEvent {
+    itemId: string;
+    before: CatalogueItemDocument;
+    after: CatalogueItemDocument;
+}
+/**
+ * Fires when a catalogue item's `listingStatus` transitions to
+ * "pending_admin_approval" (a buyer's "Request to sell"). Notifies every
+ * admin so the approvals queue doesn't go unnoticed. Kept out of the
+ * synchronous submit action per Rule #6 — the buyer-facing request stays
+ * fast regardless of how many admins there are to fan out to.
+ */
+export declare function handleCatalogueSubmittedForApproval(event: CatalogueApprovalEvent, ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,38 @@
+import { userRepository } from "../../../../features/auth/repository/user.repository";
+import { sendNotification } from "../../../../features/admin/actions/notification-actions";
+import { normalizeError } from "../../../../errors/normalize";
+/**
+ * Fires when a catalogue item's `listingStatus` transitions to
+ * "pending_admin_approval" (a buyer's "Request to sell"). Notifies every
+ * admin so the approvals queue doesn't go unnoticed. Kept out of the
+ * synchronous submit action per Rule #6 — the buyer-facing request stays
+ * fast regardless of how many admins there are to fan out to.
+ */
+export async function handleCatalogueSubmittedForApproval(event, ctx) {
+    const becamePending = event.before.listingStatus !== "pending_admin_approval" &&
+        event.after.listingStatus === "pending_admin_approval";
+    if (!becamePending)
+        return;
+    const admins = await userRepository.findByRole("admin");
+    for (const admin of admins) {
+        try {
+            await sendNotification({
+                userId: admin.uid,
+                type: "system",
+                priority: "normal",
+                title: "New catalogue listing request",
+                message: `"${event.after.title}" was submitted for approval to list under LetItRip Official.`,
+                actionUrl: "/admin/catalogue-approvals",
+                actionLabel: "Review request",
+                relatedId: event.itemId,
+            });
+        }
+        catch (err) {
+            void normalizeError(err);
+            ctx.logger.error("onCatalogueSubmittedForApproval: failed to notify admin", {
+                itemId: event.itemId,
+                adminUid: admin.uid,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Core: `jobs/{jobId}` document-created trigger.
+ *
+ * This is the single dispatch point for the async-job primitive
+ * (CLAUDE.md Rule #6 — Vercel routes never do heavy work; they write a
+ * `jobs` doc and return, this Function does the actual processing).
+ *
+ * Flow:
+ *   1. Mark the job "processing".
+ *   2. Look up a runner in `JOB_RUNNERS` by `job.jobType`.
+ *   3. Run it, mark the job "done"/"failed", and best-effort ping the
+ *      `bulk_events/{jobId}` RTDB channel the client is subscribed to via
+ *      `useBulkEvent` — every RTDB write is its own try/catch so a ping
+ *      failure never masks the real Firestore result.
+ */
+import type { JobDocument } from "../../../../features/jobs/schemas/firestore";
+import type { JobContext } from "../runtime/types";
+export interface HandleJobCreatedInput {
+    jobId: string;
+    job: JobDocument;
+}
+export declare function handleJobCreated(input: HandleJobCreatedInput, ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,59 @@
+/**
+ * Core: `jobs/{jobId}` document-created trigger.
+ *
+ * This is the single dispatch point for the async-job primitive
+ * (CLAUDE.md Rule #6 — Vercel routes never do heavy work; they write a
+ * `jobs` doc and return, this Function does the actual processing).
+ *
+ * Flow:
+ *   1. Mark the job "processing".
+ *   2. Look up a runner in `JOB_RUNNERS` by `job.jobType`.
+ *   3. Run it, mark the job "done"/"failed", and best-effort ping the
+ *      `bulk_events/{jobId}` RTDB channel the client is subscribed to via
+ *      `useBulkEvent` — every RTDB write is its own try/catch so a ping
+ *      failure never masks the real Firestore result.
+ */
+import { normalizeError } from "../../../../errors/normalize";
+import { jobsRepository } from "../../../../repositories";
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { RTDB_PATHS } from "../../../../providers/db-firebase/rtdb-paths";
+import { JOB_RUNNERS } from "./jobRunners";
+async function pingBulkEvent(jobId, payload, ctx) {
+    try {
+        await getAdminRealtimeDb()
+            .ref(`${RTDB_PATHS.BULK_EVENTS}/${jobId}`)
+            .set({ ...payload, updatedAt: Date.now() });
+    }
+    catch (err) {
+        void normalizeError(err);
+        ctx.logger.warn("onJobCreated: RTDB ping failed (non-fatal)", {
+            jobId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+export async function handleJobCreated(input, ctx) {
+    const { jobId, job } = input;
+    await jobsRepository.markProcessing(jobId);
+    const runner = JOB_RUNNERS[job.jobType];
+    if (!runner) {
+        const error = `Unknown jobType: ${job.jobType}`;
+        await jobsRepository.markFailed(jobId, error);
+        await pingBulkEvent(jobId, { status: "failed", action: job.jobType, error }, ctx);
+        ctx.logger.error("onJobCreated: unknown jobType", null, { jobId, jobType: job.jobType });
+        return;
+    }
+    try {
+        const result = await runner(job.payload, ctx);
+        await jobsRepository.markDone(jobId, result);
+        await pingBulkEvent(jobId, { status: "success", action: job.jobType, ...result }, ctx);
+        ctx.logger.info("onJobCreated: job complete", { jobId, jobType: job.jobType, summary: result.summary });
+    }
+    catch (err) {
+        void normalizeError(err);
+        const message = err instanceof Error ? err.message : String(err);
+        await jobsRepository.markFailed(jobId, message);
+        await pingBulkEvent(jobId, { status: "failed", action: job.jobType, error: message }, ctx);
+        ctx.logger.error("onJobCreated: job failed", err, { jobId, jobType: job.jobType });
+    }
+}

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

@@ -3,4 +3,9 @@
  * `payoutStatus=eligible` into pending payout documents grouped by seller.
  */
 import type { JobContext } from "../runtime/types";
-export declare function runWeeklyPayoutEligibility(ctx: JobContext): Promise<void>;
+export interface WeeklyPayoutEligibilityResult {
+    payoutsCreated: number;
+    ordersProcessed: number;
+    payoutIds: string[];
+}
+export declare function runWeeklyPayoutEligibility(ctx: JobContext): Promise<WeeklyPayoutEligibilityResult>;

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

@@ -9,7 +9,7 @@ import { computePayoutDeduction } from "../../../shared/fees/calculator";
 export async function runWeeklyPayoutEligibility(ctx) {
     if (ctx.env("FEATURE_PAYOUTS") !== "true") {
         ctx.logger.info("FEATURE_PAYOUTS disabled — skipping weekly payout eligibility");
-        return;
+        return { payoutsCreated: 0, ordersProcessed: 0, payoutIds: [] };
     }
     ctx.logger.info("Starting weekly payout eligibility sweep");
     const siteSettings = await siteSettingsRepository.getSingleton();
@@ -17,7 +17,7 @@ export async function runWeeklyPayoutEligibility(ctx) {
     const eligible = await orderRepository.getEligibleForPayoutSweep();
     if (eligible.length === 0) {
         ctx.logger.info("No eligible delivered orders found");
-        return;
+        return { payoutsCreated: 0, ordersProcessed: 0, payoutIds: [] };
     }
     ctx.logger.info(`Found ${eligible.length} eligible order(s) — grouping by seller`);
     const byStore = new Map();
@@ -33,6 +33,7 @@ export async function runWeeklyPayoutEligibility(ctx) {
     }
     let payoutsCreated = 0;
     let ordersProcessed = 0;
+    const payoutIds = [];
     const defaultCurrency = getDefaultCurrency();
     for (const [storeId, orders] of byStore.entries()) {
         const store = await storeRepository.findBySlug(storeId);
@@ -82,6 +83,7 @@ export async function runWeeklyPayoutEligibility(ctx) {
         }
         payoutsCreated++;
         ordersProcessed += orders.length;
+        payoutIds.push(payoutId);
         ctx.logger.info(`Payout created for store ${storeId}`, {
             payoutId,
             orderCount: orders.length,
@@ -91,4 +93,5 @@ export async function runWeeklyPayoutEligibility(ctx) {
         });
     }
     ctx.logger.info("Weekly payout eligibility sweep complete", { payoutsCreated, ordersProcessed });
+    return { payoutsCreated, ordersProcessed, payoutIds };
 }

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

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

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

@@ -0,0 +1,2 @@
+import { runCatalogueImageStalenessReminder } from "../core/catalogueImageStalenessReminder";
+export const catalogueImageStalenessReminderHandler = runCatalogueImageStalenessReminder;

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

@@ -19,6 +19,7 @@ export { countersReconcileHandler } from "./countersReconcile";
 export { onOrderCreateHandler } from "./onOrderCreate";
 export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
 export { onBidPlacedHandler } from "./onBidPlaced";
+export { onJobCreatedHandler } from "./onJobCreated";
 export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler, type PromotionsCallableResult } from "./promotions";
 export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
@@ -48,3 +49,8 @@ export { onScamReportCreateHandler } from "./onScamReportCreate";
 export { onScamReportUpdateHandler } from "./onScamReportUpdate";
 export { draftPruneHandler } from "./draftPrune";
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";
+export { onShipmentItemWriteHandler } from "./onShipmentItemWrite";
+export { onShipmentLotWriteHandler, onShipmentHeaderWriteHandler } from "./onShipmentAllocationSync";
+export { onShipmentDeletedHandler } from "./onShipmentDeleted";
+export { catalogueImageStalenessReminderHandler } from "./catalogueImageStalenessReminder";
+export { onCatalogueSubmittedForApprovalHandler } from "./onCatalogueSubmittedForApproval";

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

@@ -19,6 +19,7 @@ export { countersReconcileHandler } from "./countersReconcile";
 export { onOrderCreateHandler } from "./onOrderCreate";
 export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
 export { onBidPlacedHandler } from "./onBidPlaced";
+export { onJobCreatedHandler } from "./onJobCreated";
 export { onReviewWriteHandler } from "./onReviewWrite";
 export { promotionsHandler } from "./promotions";
 export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
@@ -57,3 +58,10 @@ export { onScamReportUpdateHandler } from "./onScamReportUpdate";
 export { draftPruneHandler } from "./draftPrune";
 // EMI — installment reminder + overdue-flagging sweep
 export { emiInstallmentReminderHandler } from "./emiInstallmentReminder";
+// Procurement Shipments — 3-function recompute cascade (item→lot, lot/header→shipment allocation, cascade-delete)
+export { onShipmentItemWriteHandler } from "./onShipmentItemWrite";
+export { onShipmentLotWriteHandler, onShipmentHeaderWriteHandler } from "./onShipmentAllocationSync";
+export { onShipmentDeletedHandler } from "./onShipmentDeleted";
+// Personal Catalogue (Feature B) — freshness reminder + admin approval-request notification
+export { catalogueImageStalenessReminderHandler } from "./catalogueImageStalenessReminder";
+export { onCatalogueSubmittedForApprovalHandler } from "./onCatalogueSubmittedForApproval";

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

@@ -0,0 +1,12 @@
+/**
+ * Fires on any write to catalogueItems/{itemId} where listingStatus
+ * transitions into "pending_admin_approval" (the buyer "Request to sell"
+ * action). Sends one admin-inbox notification — kept out of the fast
+ * user-facing action per Rule #6, so the buyer's request doesn't wait on
+ * how many admins exist.
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+import type { JsonValue } from "@mohasinac/appkit";
+type Doc = Record<string, JsonValue>;
+export declare const onCatalogueSubmittedForApprovalHandler: FirestoreTriggerHandler<Doc, Doc>;
+export {};

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

@@ -0,0 +1,20 @@
+import { adminNotificationsRepository } from "../../../../repositories";
+export const onCatalogueSubmittedForApprovalHandler = async (event, ctx) => {
+    const before = event.before?.listingStatus;
+    const after = event.after?.listingStatus;
+    if (before === "pending_admin_approval" || after !== "pending_admin_approval")
+        return;
+    const itemId = event.params.itemId ?? event.after?.id;
+    const title = event.after?.title ?? "Untitled item";
+    await adminNotificationsRepository.create({
+        category: "moderation",
+        title: "Catalogue listing pending approval",
+        body: `A buyer requested "${title}" be listed on their behalf.`,
+        severity: "info",
+        isRead: false,
+        entityType: "catalogueItem",
+        entityId: itemId,
+        audienceUserIds: [],
+        createdAt: ctx.now,
+    });
+};

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

@@ -0,0 +1,3 @@
+import type { FirestoreTriggerHandler } from "../runtime/types";
+import type { JobDocument } from "../../../../features/jobs/schemas/firestore";
+export declare const onJobCreatedHandler: FirestoreTriggerHandler<null, JobDocument>;

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

@@ -0,0 +1,9 @@
+import { handleJobCreated } from "../core/onJobCreated";
+export const onJobCreatedHandler = async (event, ctx) => {
+    const job = event.after;
+    if (!job) {
+        ctx.logger.error("No snapshot data", null);
+        return;
+    }
+    await handleJobCreated({ jobId: event.params.jobId, job }, ctx);
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Function #2 of the procurement-shipments cascade — the allocation engine.
+ *
+ * Fires on:
+ *   (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)
+ *
+ * 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
+ * `totals` + `totalsComputedAt`. Also keeps ShipmentLot.shipmentStatus in
+ * sync with its parent so the Projections list can filter on it directly.
+ *
+ * Skips writes that would be no-ops (value-identical) so the cascade
+ * terminates instead of re-triggering itself indefinitely.
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+import type { JsonValue } from "@mohasinac/appkit";
+type Doc = Record<string, JsonValue>;
+export declare const onShipmentLotWriteHandler: FirestoreTriggerHandler<Doc, Doc>;
+export declare const onShipmentHeaderWriteHandler: FirestoreTriggerHandler<Doc, Doc>;
+export {};