@mohasinac/appkit 2.8.9 → 3.0.0

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

@@ -1,4 +1,5 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-type ProductDoc = Record<string, unknown>;
+import type { JsonValue } from "@mohasinac/appkit";
+type ProductDoc = Record<string, JsonValue>;
 export declare const onProductStockChangeHandler: FirestoreTriggerHandler<ProductDoc, ProductDoc>;
 export {};

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onReviewWriteHandler: FirestoreTriggerHandler<Record<string, unknown>, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onReviewWriteHandler: FirestoreTriggerHandler<Record<string, JsonValue>, Record<string, JsonValue>>;

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onScamReportCreateHandler: FirestoreTriggerHandler<null, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onScamReportCreateHandler: FirestoreTriggerHandler<null, Record<string, JsonValue>>;

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onScamReportUpdateHandler: FirestoreTriggerHandler<Record<string, unknown>, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onScamReportUpdateHandler: FirestoreTriggerHandler<Record<string, JsonValue>, Record<string, JsonValue>>;

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onSupportTicketCreateHandler: FirestoreTriggerHandler<null, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onSupportTicketCreateHandler: FirestoreTriggerHandler<null, Record<string, JsonValue>>;

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onSupportTicketUpdateHandler: FirestoreTriggerHandler<Record<string, unknown>, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onSupportTicketUpdateHandler: FirestoreTriggerHandler<Record<string, JsonValue>, Record<string, JsonValue>>;

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

@@ -1,2 +1,3 @@
 import type { FirestoreTriggerHandler } from "../runtime/types";
-export declare const onUserBanChangeHandler: FirestoreTriggerHandler<Record<string, unknown>, Record<string, unknown>>;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare const onUserBanChangeHandler: FirestoreTriggerHandler<Record<string, JsonValue>, Record<string, JsonValue>>;

package/dist/_internal/server/jobs/runtime/adapters/firebase.js

@@ -1,3 +1,4 @@
+import { normalizeError } from "../../../../../errors/normalize";
 /**
  * Firebase runtime adapter for appkit job handlers.
  *
@@ -152,6 +153,7 @@ export function bindHttps(job, handler, options) {
             res.status(200).json(output);
         }
         catch (err) {
+            void normalizeError(err);
             const status = err?.httpStatus ?? 500;
             ctx.logger.error("HTTPS handler error", err);
             res.status(status).json({ error: err instanceof Error ? err.message : "Internal error" });

package/dist/_internal/server/jobs/runtime/types.d.ts

@@ -11,10 +11,11 @@
  * Firebase-specific events into JobContext + payloads.
  */
 import type { Firestore } from "firebase-admin/firestore";
+import type { JsonValue } from "@mohasinac/appkit";
 export interface JobLogger {
-    info(message: string, meta?: Record<string, unknown>): void;
-    warn(message: string, meta?: Record<string, unknown>): void;
-    error(message: string, err?: unknown, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, JsonValue>): void;
+    warn(message: string, meta?: Record<string, JsonValue>): void;
+    error(message: string, err?: unknown, meta?: Record<string, JsonValue>): void;
 }
 export interface JobContext {
     /** Stable job/trigger name for log correlation. */

package/dist/_internal/server/providers/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public surface for the provider resolver + mocks.
+ *
+ * Real provider implementations remain in `appkit/src/providers/{payment-razorpay,shipping-shiprocket}/`
+ * because they are independently consumable per-package. This barrel only
+ * exposes the resolver entry points and the in-process mock implementations
+ * Track H requires.
+ */
+export { resolvePaymentProvider, resolveShippingProvider, type PaymentResolutionFactories, type ProviderResolutionContext, type ShippingResolutionFactories, } from "./resolve";
+export { MockRazorpayProvider, type MockWebhookEvent, type MockWebhookPayload, type WebhookSink, } from "./payment/razorpay-mock";
+export { MockShiprocketProvider, type ShipmentEvent, type ShipmentEventSink, } from "./shipping/shiprocket-mock";

package/dist/_internal/server/providers/index.js

@@ -0,0 +1,11 @@
+/**
+ * Public surface for the provider resolver + mocks.
+ *
+ * Real provider implementations remain in `appkit/src/providers/{payment-razorpay,shipping-shiprocket}/`
+ * because they are independently consumable per-package. This barrel only
+ * exposes the resolver entry points and the in-process mock implementations
+ * Track H requires.
+ */
+export { resolvePaymentProvider, resolveShippingProvider, } from "./resolve";
+export { MockRazorpayProvider, } from "./payment/razorpay-mock";
+export { MockShiprocketProvider, } from "./shipping/shiprocket-mock";

package/dist/_internal/server/providers/payment/razorpay-mock.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `MockRazorpayProvider` — in-process mock implementing `IPaymentProvider`.
+ *
+ * Replaces the orphaned `/api/dev/mock-razorpay/**` HTTP routes (deleted in
+ * Track H). The mock behaviour is preserved bit-for-bit so checkout flows
+ * exercise identical wire shapes:
+ *
+ *   - Order IDs prefix `order_mock_`, payment IDs `pay_mock_`, refund IDs
+ *     `rfnd_mock_` — matches the previous route output exactly.
+ *   - Webhook signatures use HMAC-SHA256 with the deterministic
+ *     `MOCK_WEBHOOK_SECRET` so `verifyWebhook(raw, sig)` returns true for
+ *     any signature the mock itself produced.
+ *   - In-memory `Map<orderId, PaymentOrder>` survives per process. State is
+ *     intentionally not persisted — tests reset between runs by recreating
+ *     the provider instance.
+ *
+ * Mocks-only operations:
+ *   - `emitWebhook(event)` synchronously fires a webhook payload through a
+ *     consumer-supplied callback so end-to-end tests can drive a
+ *     payment.captured / payment.failed / order.paid event without leaving
+ *     the process. Registered via `setWebhookSink(fn)`.
+ */
+import type { IPaymentProvider, PaymentCapture, PaymentOrder, Refund } from "../../../../contracts";
+import type { JsonValue } from "../../../../schemas/types";
+export type MockWebhookEvent = "payment.captured" | "payment.failed" | "order.paid";
+export interface MockWebhookPayload {
+    readonly event: MockWebhookEvent;
+    readonly orderId: string;
+    readonly paymentId: string;
+    readonly amount: number;
+    readonly currency: string;
+}
+export type WebhookSink = (rawBody: string, signature: string, payload: MockWebhookPayload) => Promise<void> | void;
+export declare class MockRazorpayProvider implements IPaymentProvider {
+    readonly name: "razorpay-mock";
+    private readonly orders;
+    private readonly captures;
+    private webhookSink;
+    setWebhookSink(sink: WebhookSink | null): void;
+    createOrder(amount: number, currency: string, metadata?: Record<string, JsonValue>): Promise<PaymentOrder>;
+    verifyWebhook(payload: string, signature: string): boolean;
+    capturePayment(orderId: string): Promise<PaymentCapture>;
+    refund(paymentId: string, amount?: number): Promise<Refund>;
+    getOrder(orderId: string): Promise<PaymentOrder>;
+    /**
+     * Mocks-only — fire a webhook event through the consumer-registered sink.
+     * Used by `/api/admin/dev/emit-payment-webhook` to drive end-to-end test
+     * flows. Throws if no sink is registered.
+     */
+    emitWebhook(payload: MockWebhookPayload): Promise<void>;
+}

package/dist/_internal/server/providers/payment/razorpay-mock.js

@@ -0,0 +1,116 @@
+/**
+ * `MockRazorpayProvider` — in-process mock implementing `IPaymentProvider`.
+ *
+ * Replaces the orphaned `/api/dev/mock-razorpay/**` HTTP routes (deleted in
+ * Track H). The mock behaviour is preserved bit-for-bit so checkout flows
+ * exercise identical wire shapes:
+ *
+ *   - Order IDs prefix `order_mock_`, payment IDs `pay_mock_`, refund IDs
+ *     `rfnd_mock_` — matches the previous route output exactly.
+ *   - Webhook signatures use HMAC-SHA256 with the deterministic
+ *     `MOCK_WEBHOOK_SECRET` so `verifyWebhook(raw, sig)` returns true for
+ *     any signature the mock itself produced.
+ *   - In-memory `Map<orderId, PaymentOrder>` survives per process. State is
+ *     intentionally not persisted — tests reset between runs by recreating
+ *     the provider instance.
+ *
+ * Mocks-only operations:
+ *   - `emitWebhook(event)` synchronously fires a webhook payload through a
+ *     consumer-supplied callback so end-to-end tests can drive a
+ *     payment.captured / payment.failed / order.paid event without leaving
+ *     the process. Registered via `setWebhookSink(fn)`.
+ */
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+const MOCK_WEBHOOK_SECRET = "appkit-mock-razorpay-webhook-secret-v1";
+export class MockRazorpayProvider {
+    constructor() {
+        this.name = "razorpay-mock";
+        this.orders = new Map();
+        this.captures = new Map();
+        this.webhookSink = null;
+    }
+    setWebhookSink(sink) {
+        this.webhookSink = sink;
+    }
+    async createOrder(amount, currency, metadata) {
+        const order = {
+            id: `order_mock_${randomBytes(8).toString("hex")}`,
+            amount,
+            currency,
+            status: "created",
+            receipt: `rcpt_mock_${Date.now()}`,
+            metadata,
+            createdAt: new Date().toISOString(),
+        };
+        this.orders.set(order.id, order);
+        return order;
+    }
+    verifyWebhook(payload, signature) {
+        if (signature.length !== 64)
+            return false;
+        const expected = createHmac("sha256", MOCK_WEBHOOK_SECRET)
+            .update(payload)
+            .digest("hex");
+        return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(signature, "hex"));
+    }
+    async capturePayment(orderId) {
+        const order = this.orders.get(orderId);
+        if (!order) {
+            throw Object.assign(new Error(`Mock order not found: ${orderId}`), {
+                httpStatus: 404,
+            });
+        }
+        const capture = {
+            id: `pay_mock_${randomBytes(8).toString("hex")}`,
+            orderId,
+            amount: order.amount,
+            currency: order.currency,
+            status: "captured",
+            capturedAt: new Date().toISOString(),
+        };
+        this.captures.set(capture.id, capture);
+        this.orders.set(orderId, { ...order, status: "paid" });
+        return capture;
+    }
+    async refund(paymentId, amount) {
+        const capture = this.captures.get(paymentId);
+        const refund = {
+            id: `rfnd_mock_${randomBytes(8).toString("hex")}`,
+            paymentId,
+            amount: amount ?? capture?.amount ?? 0,
+            currency: capture?.currency ?? "INR",
+            status: "processed",
+            createdAt: new Date().toISOString(),
+        };
+        return refund;
+    }
+    async getOrder(orderId) {
+        const order = this.orders.get(orderId);
+        if (!order) {
+            throw Object.assign(new Error(`Mock order not found: ${orderId}`), {
+                httpStatus: 404,
+            });
+        }
+        return order;
+    }
+    /**
+     * Mocks-only — fire a webhook event through the consumer-registered sink.
+     * Used by `/api/admin/dev/emit-payment-webhook` to drive end-to-end test
+     * flows. Throws if no sink is registered.
+     */
+    async emitWebhook(payload) {
+        if (!this.webhookSink) {
+            throw new Error("MockRazorpayProvider.emitWebhook called with no webhook sink registered. " +
+                "Call provider.setWebhookSink(handler) at startup.");
+        }
+        const rawBody = JSON.stringify({
+            event: payload.event,
+            payload: {
+                order: { entity: { id: payload.orderId, amount: payload.amount, currency: payload.currency } },
+                payment: { entity: { id: payload.paymentId, amount: payload.amount, currency: payload.currency } },
+            },
+        });
+        const signature = createHmac("sha256", MOCK_WEBHOOK_SECRET).update(rawBody).digest("hex");
+        await this.webhookSink(rawBody, signature, payload);
+    }
+}

package/dist/_internal/server/providers/resolve.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `resolvePaymentProvider` / `resolveShippingProvider` — decide between the
+ * real adapter and the in-process mock based on site-settings feature flags.
+ *
+ * Resolution rule (single explicit boolean per provider, no implicit fallback):
+ *
+ *   1. Read `siteSettings.featureFlags.useMockPayment` /
+ *      `featureFlags.useMockShipping`.
+ *   2. If the flag is `true` and `process.env.NODE_ENV !== "production"` →
+ *      return the mock provider.
+ *   3. If the flag is `true` and `process.env.NODE_ENV === "production"` →
+ *      THROW. Production must never run with a mock flag set. Loud failure
+ *      is the contract.
+ *   4. Otherwise → return the real provider supplied by the caller.
+ *
+ * The resolver is intentionally provider-agnostic (it accepts factories so
+ * the consumer's `providers.config.ts` controls instantiation), keeping this
+ * file zero-dep on Razorpay / Shiprocket SDK chains.
+ */
+import type { IPaymentProvider, IShippingProvider } from "../../../contracts";
+export interface ProviderResolutionContext {
+    readonly nodeEnv: string;
+    readonly siteSettings: {
+        readonly featureFlags?: {
+            readonly useMockPayment?: boolean;
+            readonly useMockShipping?: boolean;
+        };
+    };
+}
+export interface PaymentResolutionFactories {
+    readonly real: () => Promise<IPaymentProvider> | IPaymentProvider;
+    readonly mock: () => Promise<IPaymentProvider> | IPaymentProvider;
+}
+export interface ShippingResolutionFactories {
+    readonly real: () => Promise<IShippingProvider> | IShippingProvider;
+    readonly mock: () => Promise<IShippingProvider> | IShippingProvider;
+}
+export declare function resolvePaymentProvider(ctx: ProviderResolutionContext, factories: PaymentResolutionFactories): Promise<IPaymentProvider>;
+export declare function resolveShippingProvider(ctx: ProviderResolutionContext, factories: ShippingResolutionFactories): Promise<IShippingProvider>;

package/dist/_internal/server/providers/resolve.js

@@ -0,0 +1,37 @@
+/**
+ * `resolvePaymentProvider` / `resolveShippingProvider` — decide between the
+ * real adapter and the in-process mock based on site-settings feature flags.
+ *
+ * Resolution rule (single explicit boolean per provider, no implicit fallback):
+ *
+ *   1. Read `siteSettings.featureFlags.useMockPayment` /
+ *      `featureFlags.useMockShipping`.
+ *   2. If the flag is `true` and `process.env.NODE_ENV !== "production"` →
+ *      return the mock provider.
+ *   3. If the flag is `true` and `process.env.NODE_ENV === "production"` →
+ *      THROW. Production must never run with a mock flag set. Loud failure
+ *      is the contract.
+ *   4. Otherwise → return the real provider supplied by the caller.
+ *
+ * The resolver is intentionally provider-agnostic (it accepts factories so
+ * the consumer's `providers.config.ts` controls instantiation), keeping this
+ * file zero-dep on Razorpay / Shiprocket SDK chains.
+ */
+export async function resolvePaymentProvider(ctx, factories) {
+    const want = ctx.siteSettings.featureFlags?.useMockPayment === true;
+    if (want && ctx.nodeEnv === "production") {
+        throw new Error("[providers] siteSettings.featureFlags.useMockPayment is TRUE in production. " +
+            "The mock payment provider must never run in production. Set the flag to false " +
+            "in Admin → Site Settings, or unset NODE_ENV=production for the deploy.");
+    }
+    return want ? await factories.mock() : await factories.real();
+}
+export async function resolveShippingProvider(ctx, factories) {
+    const want = ctx.siteSettings.featureFlags?.useMockShipping === true;
+    if (want && ctx.nodeEnv === "production") {
+        throw new Error("[providers] siteSettings.featureFlags.useMockShipping is TRUE in production. " +
+            "The mock shipping provider must never run in production. Set the flag to false " +
+            "in Admin → Site Settings, or unset NODE_ENV=production for the deploy.");
+    }
+    return want ? await factories.mock() : await factories.real();
+}

package/dist/_internal/server/providers/shipping/shiprocket-mock.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `MockShiprocketProvider` — in-process mock implementing `IShippingProvider`.
+ *
+ * Replaces the orphaned `/api/dev/mock-shiprocket/**` HTTP routes (deleted
+ * in Track H). State is per-process; status progression is deterministic so
+ * tests can assert against a known sequence.
+ */
+import type { CreateShipmentInput, IShippingProvider, ServiceabilityResult, Shipment, TrackingInfo } from "../../../../contracts";
+export type ShipmentEvent = "Pickup Scheduled" | "Pickup Completed" | "In Transit" | "Out for Delivery" | "Delivered" | "Cancelled";
+export type ShipmentEventSink = (trackingId: string, event: ShipmentEvent, shipment: Shipment) => Promise<void> | void;
+export declare class MockShiprocketProvider implements IShippingProvider {
+    readonly name: "shiprocket-mock";
+    private readonly shipments;
+    private eventSink;
+    setEventSink(sink: ShipmentEventSink | null): void;
+    createShipment(data: CreateShipmentInput): Promise<Shipment>;
+    trackShipment(trackingId: string): Promise<TrackingInfo>;
+    cancelShipment(shipmentId: string): Promise<void>;
+    private findShipmentById;
+    private notifyCancellation;
+    checkServiceability(pincode: string, weight: number): Promise<ServiceabilityResult>;
+    generateLabel(shipmentId: string): Promise<ArrayBuffer>;
+    /**
+     * Mocks-only — advance a shipment's tracking status and fire a tracking
+     * event through the consumer-registered sink. Used by
+     * `/api/admin/dev/emit-shipping-event` to drive end-to-end test flows.
+     */
+    emitTrackingEvent(trackingId: string, event: ShipmentEvent): Promise<void>;
+}

package/dist/_internal/server/providers/shipping/shiprocket-mock.js

@@ -0,0 +1,152 @@
+/**
+ * `MockShiprocketProvider` — in-process mock implementing `IShippingProvider`.
+ *
+ * Replaces the orphaned `/api/dev/mock-shiprocket/**` HTTP routes (deleted
+ * in Track H). State is per-process; status progression is deterministic so
+ * tests can assert against a known sequence.
+ */
+import { randomBytes } from "node:crypto";
+const PICKUP_SCHEDULED = "Pickup Scheduled";
+const TRACKING_PROGRESSION = [
+    PICKUP_SCHEDULED,
+    "Pickup Completed",
+    "In Transit",
+    "Out for Delivery",
+    "Delivered",
+];
+export class MockShiprocketProvider {
+    constructor() {
+        this.name = "shiprocket-mock";
+        this.shipments = new Map();
+        this.eventSink = null;
+    }
+    setEventSink(sink) {
+        this.eventSink = sink;
+    }
+    async createShipment(data) {
+        const trackingId = `MOCK${randomBytes(5).toString("hex").toUpperCase()}`;
+        const id = `shp_mock_${randomBytes(8).toString("hex")}`;
+        const courier = "MockExpress";
+        const initialEvent = {
+            status: PICKUP_SCHEDULED,
+            location: data.pickup.city,
+            timestamp: new Date().toISOString(),
+            description: "Pickup scheduled with carrier",
+        };
+        this.shipments.set(trackingId, {
+            id,
+            trackingId,
+            orderId: data.orderId,
+            courier,
+            createdAt: initialEvent.timestamp,
+            events: [initialEvent],
+        });
+        return {
+            id,
+            trackingId,
+            orderId: data.orderId,
+            status: initialEvent.status,
+            courier,
+            createdAt: initialEvent.timestamp,
+        };
+    }
+    async trackShipment(trackingId) {
+        const shipment = this.shipments.get(trackingId);
+        if (!shipment) {
+            throw Object.assign(new Error(`Mock shipment not found: ${trackingId}`), {
+                httpStatus: 404,
+            });
+        }
+        return {
+            trackingId,
+            currentStatus: shipment.events[shipment.events.length - 1]?.status ?? "Unknown",
+            events: [...shipment.events],
+        };
+    }
+    async cancelShipment(shipmentId) {
+        const entry = this.findShipmentById(shipmentId);
+        if (!entry) {
+            throw Object.assign(new Error(`Mock shipment not found: ${shipmentId}`), {
+                httpStatus: 404,
+            });
+        }
+        const [trackingId, ship] = entry;
+        ship.events.push({
+            status: "Cancelled",
+            location: ship.events[ship.events.length - 1]?.location ?? "Origin",
+            timestamp: new Date().toISOString(),
+            description: "Mock shipment cancelled",
+        });
+        await this.notifyCancellation(trackingId, ship);
+    }
+    findShipmentById(shipmentId) {
+        for (const entry of this.shipments) {
+            if (entry[1].id === shipmentId)
+                return entry;
+        }
+        return null;
+    }
+    async notifyCancellation(trackingId, ship) {
+        if (!this.eventSink)
+            return;
+        await this.eventSink(trackingId, "Cancelled", {
+            id: ship.id,
+            trackingId,
+            orderId: ship.orderId,
+            status: "Cancelled",
+            courier: ship.courier,
+            createdAt: ship.createdAt,
+        });
+    }
+    async checkServiceability(pincode, weight) {
+        // Mock policy: every pincode is serviceable; rate scales with weight.
+        return {
+            isServiceable: true,
+            couriers: [
+                { name: "MockExpress", estimatedDays: 3, rate: Math.round(60 + weight * 25) },
+                { name: "MockEconomy", estimatedDays: 5, rate: Math.round(40 + weight * 18) },
+            ],
+        };
+    }
+    async generateLabel(shipmentId) {
+        void shipmentId;
+        // Mock label: a tiny PDF-like blob. Production tests never read the
+        // bytes — they assert the API contract returns an ArrayBuffer.
+        const placeholder = new TextEncoder().encode(`%PDF-MOCK\n${shipmentId}\n`);
+        return placeholder.buffer.slice(placeholder.byteOffset, placeholder.byteOffset + placeholder.byteLength);
+    }
+    /**
+     * Mocks-only — advance a shipment's tracking status and fire a tracking
+     * event through the consumer-registered sink. Used by
+     * `/api/admin/dev/emit-shipping-event` to drive end-to-end test flows.
+     */
+    async emitTrackingEvent(trackingId, event) {
+        const shipment = this.shipments.get(trackingId);
+        if (!shipment) {
+            throw new Error(`Mock shipment not found: ${trackingId}`);
+        }
+        if (!this.eventSink) {
+            throw new Error("MockShiprocketProvider.emitTrackingEvent called with no sink registered. " +
+                "Call provider.setEventSink(handler) at startup.");
+        }
+        if (event !== "Cancelled" && !TRACKING_PROGRESSION.includes(event)) {
+            throw new Error(`Unknown tracking event: ${event}`);
+        }
+        const last = shipment.events[shipment.events.length - 1];
+        const trackingEvent = {
+            status: event,
+            location: last?.location ?? "Origin",
+            timestamp: new Date().toISOString(),
+            description: `Mock event: ${event}`,
+        };
+        shipment.events.push(trackingEvent);
+        await this.eventSink(trackingId, event, {
+            id: shipment.id,
+            trackingId,
+            orderId: shipment.orderId,
+            status: event,
+            courier: shipment.courier,
+            createdAt: shipment.createdAt,
+        });
+    }
+}

package/dist/_internal/shared/checkout/rules/types.d.ts

@@ -11,6 +11,7 @@
  * types zero-consumer-edit additions.
  */
 import type { CartItemDocument } from "../../../../features/cart/schemas/firestore";
+import type { JsonValue } from "@mohasinac/appkit";
 import type { ProductDocument } from "../../../../features/products/schemas/firestore";
 import type { OrderDocumentItem } from "../../../../features/orders/schemas/firestore";
 import type { OrderType } from "../../../../features/orders/utils/order-splitter";
@@ -99,7 +100,7 @@ export interface ListingCheckoutRule {
      *
      * Prize-draw bumps `prizeCurrentEntries`. Pre-order bumps `preOrderCurrentCount`.
      */
-    stockDecrementExtras(product: ProductDocument, quantity: number): Record<string, unknown>;
+    stockDecrementExtras(product: ProductDocument, quantity: number): Record<string, JsonValue>;
     /**
      * Transform a raw order-line input (built from cart item data) before it
      * is written to the OrderDocument.  Adds type-specific fields such as
@@ -111,7 +112,7 @@ export interface ListingCheckoutRule {
      * Used for prize-draw-specific fields (prizeDrawProductId, isNonRefundable,
      * prizeRevealDeadline).
      */
-    decorateOrderDoc(groupFirstItem: CartItemDocument, groupFirstProduct: ProductDocument): Record<string, unknown>;
+    decorateOrderDoc(groupFirstItem: CartItemDocument, groupFirstProduct: ProductDocument): Record<string, JsonValue>;
 }
 /**
  * Checkout rule for a purchaseable CategoryType (currently only "bundle").

package/dist/_internal/shared/config/schema.d.ts

@@ -1,3 +1,4 @@
+import type { FirestoreDocument } from "@mohasinac/appkit";
 /**
  * AppkitConfig — consumer's contract with all appkit CLI binaries.
  *
@@ -10,11 +11,11 @@
  * // appkit.config.ts
  * import type { AppkitConfig } from "@mohasinac/appkit";
  * const config: AppkitConfig = {
- *   baseUrl: "http://localhost:3000",
- *   locales: ["en"],
- *   routes: {
- *     smoke: [{ path: "/", expect: ["MyBrand"] }],
- *   },
+ * baseUrl: "http://localhost:3000",
+ * locales: ["en"],
+ * routes: {
+ * smoke: [{ path: "/", expect: ["MyBrand"] }],
+ * },
  * };
  * export default config;
  * ```
@@ -65,7 +66,7 @@ export interface AppkitFirebaseExtensions {
     /** Additional Firestore field overrides appended to the base list. */
     fieldOverrides?: FirestoreFieldOverride[];
     /** Additional RTDB rule paths deep-merged into the base rules object. */
-    database?: Record<string, unknown>;
+    database?: FirestoreDocument;
     /** Raw Firestore security rules block injected inside the top-level match block. */
     firestoreRules?: string;
     /** Raw Storage security rules block injected inside the bucket match block. */

package/dist/_internal/shared/features/layout/config.js

@@ -23,8 +23,8 @@ export const DASHBOARD_ACCENT_CLASSES = {
         hoverBg: "hover:bg-zinc-50 dark:hover:bg-slate-800/60",
     },
     store: {
-        activeBg: "bg-orange-50 dark:bg-orange-900/20",
-        activeText: "text-orange-700 dark:text-orange-300",
+        activeBg: "bg-warning-surface dark:bg-warning-surface",
+        activeText: "text-warning dark:text-warning",
         hoverBg: "hover:bg-zinc-50 dark:hover:bg-slate-800/60",
     },
     user: {

package/dist/_internal/shared/features/orders/schema.d.ts

@@ -87,13 +87,13 @@ export declare const updateOrderStatusSchema: z.ZodObject<{
     carrier: z.ZodOptional<z.ZodString>;
     note: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    status: "processing" | "refunded" | "shipped" | "delivered" | "cancelled" | "return_requested";
+    status: "cancelled" | "processing" | "refunded" | "shipped" | "delivered" | "return_requested";
     orderId: string;
     note?: string | undefined;
     trackingNumber?: string | undefined;
     carrier?: string | undefined;
 }, {
-    status: "processing" | "refunded" | "shipped" | "delivered" | "cancelled" | "return_requested";
+    status: "cancelled" | "processing" | "refunded" | "shipped" | "delivered" | "return_requested";
     orderId: string;
     note?: string | undefined;
     trackingNumber?: string | undefined;