@mohasinac/appkit 4.62.0 → 4.62.1

package/dist/features/cart/repository/cart.repository.d.ts

@@ -129,6 +129,25 @@ export declare class CartRepository extends BaseRepository<CartDocument> {
      * and keeping both shapes around invites readers that handle only one.
      */
     setStoreAddons(userId: string, storeId: string, addons: CartStoreAddons | null): Promise<void>;
+    /**
+     * Opt the cart in or out of paying with points (D46/D47, decision 24).
+     *
+     * 🛑 A BOOLEAN, and the schema deliberately has no numeric sibling. Opt in
+     * and the server applies as many points as the 50% cap allows; whatever
+     * cannot be applied stays in the balance for a later order. A client-supplied
+     * amount is a client-supplied discount, which is the whole reason
+     * `storeAddons` is the source of truth for add-on fees rather than a request
+     * body.
+     *
+     * Written with the same `set(..., { merge: true })` as its neighbours so a
+     * concurrent add-on or selection write is not clobbered.
+     *
+     * 🛑 Opting OUT deletes the field rather than writing `false` — absent and
+     * `false` mean the same thing to every reader (`cart.useAllPoints === true`),
+     * and keeping both shapes invites a reader that handles only one. Same
+     * reasoning as `setStoreAddons` directly above.
+     */
+    setUseAllPoints(userId: string, useAllPoints: boolean): Promise<void>;
     /**
      * Cloud Functions: return refs of stale carts not updated within TTL.
      */

package/dist/features/cart/repository/cart.repository.js

@@ -590,6 +590,33 @@ export class CartRepository extends BaseRepository {
             updatedAt: new Date(),
         }, { merge: true });
     }
+    /**
+     * Opt the cart in or out of paying with points (D46/D47, decision 24).
+     *
+     * 🛑 A BOOLEAN, and the schema deliberately has no numeric sibling. Opt in
+     * and the server applies as many points as the 50% cap allows; whatever
+     * cannot be applied stays in the balance for a later order. A client-supplied
+     * amount is a client-supplied discount, which is the whole reason
+     * `storeAddons` is the source of truth for add-on fees rather than a request
+     * body.
+     *
+     * Written with the same `set(..., { merge: true })` as its neighbours so a
+     * concurrent add-on or selection write is not clobbered.
+     *
+     * 🛑 Opting OUT deletes the field rather than writing `false` — absent and
+     * `false` mean the same thing to every reader (`cart.useAllPoints === true`),
+     * and keeping both shapes invites a reader that handles only one. Same
+     * reasoning as `setStoreAddons` directly above.
+     */
+    async setUseAllPoints(userId, useAllPoints) {
+        await this.db
+            .collection(this.collection)
+            .doc(userId)
+            .set({
+            useAllPoints: useAllPoints ? true : FieldValue.delete(),
+            updatedAt: new Date(),
+        }, { merge: true });
+    }
     /*
      * `pruneStoreAddons(userId, keepStoreIds)` used to live here. It had zero
      * callers from the day it was written, and `pruneForItems` now does the same

package/dist/features/cart/schemas/firestore.d.ts

@@ -6,6 +6,7 @@
  */
 import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 import type { ListingType } from "../../products/types/index";
+import type { CouponType } from "../../promotions/types/index";
 /**
  * What KIND of thing one cart line represents.
  *
@@ -57,6 +58,33 @@ export interface CartLineMember {
     gstRate?: 0 | 5 | 12 | 18 | 28;
     hsnCode?: string;
     listingType?: ListingType;
+    /**
+     * How the coordinator expressed this member's share of the line.
+     *
+     * Absent means `"amount"` — every line written before splits existed, so no
+     * migration and no behaviour change until a coordinator picks percentages.
+     *
+     * 🛑 The PERCENTAGE is the stored fact, not the resolved rupees. Percentages
+     * apply to the LANDED cost (goods + shipping + fees), so a member's figure
+     * MOVES when shipping is re-quoted — storing the computed amount instead
+     * would freeze a number that no longer matches the agreed share. The
+     * computed figures are snapshotted at COMMIT, which is where the
+     * coordinator's agreement actually becomes binding (D61).
+     *
+     * `resolveSplit` (`_internal/shared/checkout/split.ts`) is the only thing
+     * that turns these into money.
+     */
+    splitMode?: "amount" | "percent";
+    /** 0–100, read only when `splitMode === "percent"`. */
+    percent?: number;
+    /**
+     * The member's agreed contribution in decimal rupees, when typed directly.
+     *
+     * 🛑 NOT the same as `unitPrice`. `unitPrice` is what the ITEM costs;
+     * this is what this PERSON agreed to put in, and the two differ by design
+     * the moment a split is uneven or the total exceeds the landed cost.
+     */
+    contribution?: number;
 }
 export interface CartItemDocument {
     itemId: string;
@@ -183,6 +211,26 @@ export interface CartItemDocument {
     chosenShippingProviderId?: string;
     /** Fee in decimal rupees for the chosen provider, snapshotted at cart time. */
     chosenShippingFee?: number;
+    /**
+     * ── S5a: which address THIS line ships to ────────────────────────────────
+     *
+     * One payer, N destinations. Absent means "the order's own shipping
+     * address", which is every cart that predates this and every ordinary
+     * single-destination order — so nothing changes for them.
+     *
+     * 🛑 An `addresses/{id}` REFERENCE, never a copied address. Copying would
+     * put a name, a phone number and a street address onto the cart document,
+     * which is a PII store with no encryption, no `*_PII_FIELDS` entry and no
+     * retention story — and carts are swept by a TTL job that is not written to
+     * handle personal data. The id resolves server-side at checkout, where the
+     * address is already being read and decrypted.
+     *
+     * 🛑 It must belong to the BUYER. An arbitrary `addresses` id would let a
+     * caller address a parcel to any stored address on the platform, which is
+     * both a delivery hijack and a way to read whether an id exists. Checked
+     * server-side at the write, not trusted from the client.
+     */
+    destinationAddressId?: string;
     addedAt: Date;
     updatedAt: Date;
 }
@@ -196,6 +244,28 @@ export interface CartAppliedCoupon {
     storeId?: string;
     /** Item IDs (CartItemDocument.itemId) this coupon was calculated against */
     applicableItemIds?: string[];
+    /**
+     * The coupon's type, snapshotted at apply time (D51).
+     *
+     * 🛑 Needed because `detectCouponConflict` buckets on TYPE, not scope: a
+     * `points_earn` coupon is admin-scoped like every platform coupon but
+     * competes for its own slot, so without this field on the stored entry the
+     * detector could not tell a points coupon already in the cart from an
+     * ordinary platform one, and `RIPLI05` would block every other admin coupon
+     * — the exact defect the third bucket exists to prevent.
+     *
+     * Absent means "a discount coupon", which is what every cart written before
+     * this field holds, and is the reading that preserves the previous
+     * behaviour exactly.
+     *
+     * 🛑 Snapshotted deliberately, unlike the restrictions: a coupon's TYPE
+     * decides which slot it occupies, so re-reading it live would mean an admin
+     * editing a coupon's type could retroactively make a live cart's
+     * combination illegal. The money is still re-validated against the live
+     * coupon at placement (`revalidateAppliedCoupons`), which is where a changed
+     * discount has to be caught.
+     */
+    type?: CouponType;
 }
 /**
  * Paid add-ons the buyer opted into, for ONE store.
@@ -239,6 +309,28 @@ export interface CartDocument extends BaseDocument {
      * rather than a flag someone has to remember to check.
      */
     storeAddons?: Record<string, CartStoreAddons>;
+    /**
+     * The buyer has opted to spend points on this checkout.
+     *
+     * ## 🛑 A BOOLEAN, and the amount is never stored or sent
+     *
+     * Owner's rule: *"if use point it is all and then the balance is returned if
+     * excess"* — one opt-in, all-or-nothing. Ticked, the checkout applies as many
+     * points as the 50% cap allows; whatever cannot be applied stays in the
+     * balance. The buyer never types a number.
+     *
+     * So this is the ONLY thing the client may say about points. The amount is
+     * derived server-side from the live balance and
+     * `POINTS_MAX_REDEMPTION_PERCENT` at the moment the order is priced — the
+     * same rule that makes `storeAddons` above the source of truth rather than a
+     * request body, and for the same reason: a client-supplied money figure is a
+     * client-supplied discount.
+     *
+     * 🛑 This replaces a deleted `pointsToRedeem?: number` on the checkout input,
+     * whose handler debited the buyer AFTER the gateway had captured full price
+     * (D46). A number was the wrong shape as well as the wrong place.
+     */
+    useAllPoints?: boolean;
 }
 export declare const CART_COLLECTION: "carts";
 export declare const CART_INDEXED_FIELDS: string[];

package/dist/features/contact/email.d.ts

@@ -1,14 +1,9 @@
 import "server-only";
 import type { SendGuardContext } from "../../_internal/shared/features/messaging/config";
 import type { JsonValue } from "@mohasinac/appkit";
-type SendEmailOptions = Record<string, JsonValue> & {
-    to: string | string[];
-    subject: string;
+import type { EmailOptions } from "../../contracts/email";
+type SendEmailOptions = Omit<EmailOptions, "html"> & {
     html?: string;
-    text?: string;
-    from?: string;
-    cc?: string | string[];
-    replyTo?: string;
 };
 /**
  * Everything `sendEmail` needs beyond the message itself.
@@ -22,9 +17,9 @@ type SendEmailOptions = Record<string, JsonValue> & {
  * (CLAUDE.md Rule #22: make the wrong thing unrepresentable).
  *
  * Kept as a separate second parameter rather than a field on
- * `SendEmailOptions` because that type has a `Record<string, JsonValue>` index
- * signature — a structured object would not satisfy it, and widening the index
- * signature to accommodate one field would weaken every other field's typing.
+ * `SendEmailOptions`, which is now the provider's own `EmailOptions`. The
+ * guard is about who may send and why; it is not part of the message, and
+ * folding it in would put it on the wire to the provider.
  */
 export type SendEmailGuard = SendGuardContext;
 /**
@@ -59,6 +54,28 @@ export interface OrderConfirmationEmailParams {
         unitPrice: number;
         totalPrice: number;
     }>;
+    /**
+     * Phase 7 — the invoice PDF to attach, as STORED bytes.
+     *
+     * 🛑 Bytes, never a path and never a renderer. Two renders can disagree — a
+     * changed template, a different library version — and the buyer's copy must
+     * be byte-identical to ours. Letting this function render would be a second
+     * render by definition.
+     *
+     * 🛑 Optional, and absence must stay silent. The invoice is numbered on the
+     * PAID transition and its bytes are produced on first request, so a COD
+     * order confirmed before payment legitimately has none — and this email has
+     * always sent without an attachment. Failing or warning here would turn the
+     * normal case into a noisy one.
+     *
+     * Resend supports attachments already (`email-resend/provider.ts`), so this
+     * needs no new send, no new credential and no change to the 80/day ceiling.
+     * Only the payload is bigger.
+     */
+    invoicePdf?: {
+        filename: string;
+        content: Buffer;
+    };
 }
 export declare function sendOrderConfirmationEmail(params: OrderConfirmationEmailParams): Promise<{
     success: boolean;

package/dist/features/contact/email.js

@@ -124,9 +124,10 @@ export async function sendEmail(opts, guard) {
                 ? opts.cc
                 : undefined,
             replyTo: typeof opts.replyTo === "string" ? opts.replyTo : undefined,
-            headers: typeof opts.headers === "object" && opts.headers
-                ? opts.headers
-                : undefined,
+            headers: opts.headers,
+            // Forwarded, not dropped — the provider has mapped these to Resend's
+            // `attachments` all along; nothing here ever handed them over.
+            attachments: opts.attachments,
         });
         void recordSendAttempt({
             to: opts.to,
@@ -184,6 +185,22 @@ export async function sendOrderConfirmationEmail(params) {
             to,
             subject: `Order Confirmed — ${orderId}`,
             html,
+            /*
+             * Phase 7 — the invoice, when there is one. The STORED bytes, handed
+             * in by the caller: see `invoicePdf` on the params type for why this
+             * function must not render its own.
+             */
+            ...(params.invoicePdf
+                ? {
+                    attachments: [
+                        {
+                            filename: params.invoicePdf.filename,
+                            content: params.invoicePdf.content,
+                            contentType: "application/pdf",
+                        },
+                    ],
+                }
+                : {}),
             text: `Hi ${userName},\n\nYour order ${orderId} has been confirmed!\n\n${itemsText}\nTotal: ${formattedTotal}\nPayment: ${paymentLabel}\nShip to: ${shippingAddress ?? "-"}\n\nView your order: ${orderUrl}\n\n© ${currentYear()} ${siteName}`,
         }, {
             channel: "email",

package/dist/features/dispute-reasons/repository/dispute-reasons.repository.d.ts

@@ -0,0 +1,38 @@
+import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
+import { BaseRepository } from "../../../providers/db-firebase";
+import type { DisputeKind } from "../../../_internal/shared/features/orders/dispute-reasons";
+import { type DisputeReasonDocument } from "../schemas/firestore";
+export declare class DisputeReasonsRepository extends BaseRepository<DisputeReasonDocument> {
+    static readonly SIEVE_FIELDS: FirebaseSieveFields;
+    constructor();
+    /**
+     * The picker's list, scoped to one kind.
+     *
+     * 🛑 Scoped by KIND, not merged. A buyer reporting a damaged item must not be
+     * offered "it never arrived" — that reason belongs to the other gate, and
+     * picking it would produce a dispute the gate then refuses, which reads to
+     * the buyer as the form being broken rather than as the wrong choice.
+     */
+    listActiveByKind(kind: DisputeKind, model: SieveModel): Promise<FirebaseSieveResult<DisputeReasonDocument>>;
+    /**
+     * Add a reason. Staff only — enforced at the route, not here.
+     *
+     * 🛑 Keyed `dreason-<slug>`, so two agents cannot add the same wording twice.
+     * A colliding create returns the EXISTING row rather than overwriting it:
+     * that row has an author and may already be named on live disputes, and the
+     * second agent's intent ("there should be a reason for this") is satisfied by
+     * what exists. Same rule as the shipping-box presets.
+     */
+    createReason(input: {
+        label: string;
+        kind: DisputeKind;
+        createdByUid: string;
+        createdByName: string;
+    }): Promise<{
+        reason: DisputeReasonDocument;
+        created: boolean;
+    }>;
+    /** Soft-retire. See the schema for why this is never a delete. */
+    retire(id: string): Promise<void>;
+}
+export declare const disputeReasonsRepository: DisputeReasonsRepository;

package/dist/features/dispute-reasons/repository/dispute-reasons.repository.js

@@ -0,0 +1,80 @@
+import { BaseRepository } from "../../../providers/db-firebase/index.js";
+import { slugify } from "../../../utils/string.formatter.js";
+import { DISPUTE_REASON_COLLECTION, DISPUTE_REASON_FIELDS, DISPUTE_REASON_LABEL_MAX, } from "../schemas/firestore.js";
+export class DisputeReasonsRepository extends BaseRepository {
+    constructor() {
+        super(DISPUTE_REASON_COLLECTION);
+    }
+    /**
+     * The picker's list, scoped to one kind.
+     *
+     * 🛑 Scoped by KIND, not merged. A buyer reporting a damaged item must not be
+     * offered "it never arrived" — that reason belongs to the other gate, and
+     * picking it would produce a dispute the gate then refuses, which reads to
+     * the buyer as the form being broken rather than as the wrong choice.
+     */
+    async listActiveByKind(kind, model) {
+        const baseQuery = this.getCollection()
+            .where(DISPUTE_REASON_FIELDS.IS_ACTIVE, "==", true)
+            .where(DISPUTE_REASON_FIELDS.KIND, "==", kind);
+        return this.sieveQuery(model, DisputeReasonsRepository.SIEVE_FIELDS, { baseQuery, defaultPageSize: 20, maxPageSize: 50 });
+    }
+    /**
+     * Add a reason. Staff only — enforced at the route, not here.
+     *
+     * 🛑 Keyed `dreason-<slug>`, so two agents cannot add the same wording twice.
+     * A colliding create returns the EXISTING row rather than overwriting it:
+     * that row has an author and may already be named on live disputes, and the
+     * second agent's intent ("there should be a reason for this") is satisfied by
+     * what exists. Same rule as the shipping-box presets.
+     */
+    async createReason(input) {
+        const label = input.label.trim().slice(0, DISPUTE_REASON_LABEL_MAX);
+        const id = `dreason-${slugify(label)}`;
+        const existing = await this.findById(id);
+        /*
+         * A retired row that someone re-adds is REACTIVATED rather than duplicated
+         * — otherwise the slug collides forever and the agent can never get their
+         * reason back. Reactivating keeps the original author, which is correct:
+         * they wrote the wording.
+         */
+        if (existing) {
+            if (!existing.isActive) {
+                await this.update(id, { isActive: true, updatedAt: new Date() });
+                return { reason: { ...existing, isActive: true }, created: false };
+            }
+            return { reason: existing, created: false };
+        }
+        const now = new Date();
+        const reason = {
+            id,
+            label,
+            kind: input.kind,
+            isActive: true,
+            createdByUid: input.createdByUid,
+            createdByName: input.createdByName,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.createWithId(id, reason);
+        return { reason, created: true };
+    }
+    /** Soft-retire. See the schema for why this is never a delete. */
+    async retire(id) {
+        await this.update(id, { isActive: false, updatedAt: new Date() });
+    }
+}
+DisputeReasonsRepository.SIEVE_FIELDS = {
+    /*
+     * 🛑 `label` must be here because `PaginatedSelect` SEARCHES it. An
+     * unallowlisted searched field does not raise — `sieve.ts` sets
+     * `throwExceptions: false`, so `findField` returns undefined, the clause is
+     * silently dropped, and the picker returns the WHOLE list while looking
+     * exactly like it filtered (Root Cause #62).
+     */
+    label: { canFilter: true, canSort: true },
+    kind: { canFilter: true, canSort: false },
+    isActive: { canFilter: true, canSort: false },
+    createdByUid: { canFilter: true, canSort: false },
+};
+export const disputeReasonsRepository = new DisputeReasonsRepository();

package/dist/features/dispute-reasons/schemas/firestore.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `disputeReasons` — the staff-curated list a buyer picks from when raising a
+ * dispute.
+ *
+ * ## What this is NOT
+ *
+ * 🛑 It is not policy. Every row carries a `kind`, and the GATE lives on the
+ * kind — see `_internal/shared/features/orders/dispute-reasons.ts`. A row can
+ * never introduce a new kind of claim, because a gate cannot branch on a
+ * user-created string.
+ *
+ * So this list is for TRIAGE and ANALYTICS: "what are buyers actually
+ * reporting", answered without reading free text. Staff (admin + employees)
+ * add rows as real gaps appear; buyers select only.
+ *
+ * ## Why staff-creatable rather than a closed enum
+ *
+ * Its sibling `RETURN_REASON` *is* a closed enum, and deliberately so: each
+ * member there decides whether a final sale can refuse the return, which is a
+ * money consequence that must be reviewed in code. Nothing here decides money.
+ * A support agent who keeps seeing "the courier left it at the wrong flat"
+ * should be able to add it without a release.
+ */
+import type { DisputeKind } from "../../../_internal/shared/features/orders/dispute-reasons";
+export declare const DISPUTE_REASON_COLLECTION = "disputeReasons";
+export interface DisputeReasonDocument {
+    /** `dreason-<slug of label>`, so the same reason cannot be added twice. */
+    id: string;
+    /** Buyer-facing. Shown verbatim in the picker. */
+    label: string;
+    /** Which gate this reason is subject to. Never free-form. */
+    kind: DisputeKind;
+    /**
+     * 🛑 Soft-retire, never delete.
+     *
+     * A past dispute names this reason. Deleting the row would orphan that
+     * record and take the author with it — and the order snapshots the LABEL
+     * precisely so history survives either way, but a deleted row still loses
+     * "who added this, and when" for anyone auditing the list itself.
+     */
+    isActive: boolean;
+    /** Display name, so a seller or agent can see whose wording this is. */
+    createdByName: string;
+    /** The uid, for moderation. Never rendered. */
+    createdByUid: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare const DISPUTE_REASON_FIELDS: {
+    readonly ID: "id";
+    readonly LABEL: "label";
+    readonly KIND: "kind";
+    readonly IS_ACTIVE: "isActive";
+    readonly CREATED_BY_UID: "createdByUid";
+    readonly CREATED_AT: "createdAt";
+};
+/**
+ * Bounds on a label.
+ *
+ * Short on purpose: this is a picker option, not the buyer's explanation. The
+ * detail goes in the free-text field on the dispute itself, which is where a
+ * buyer should describe what actually happened.
+ */
+export declare const DISPUTE_REASON_LABEL_MAX = 80;

package/dist/features/dispute-reasons/schemas/firestore.js

@@ -0,0 +1,40 @@
+/**
+ * `disputeReasons` — the staff-curated list a buyer picks from when raising a
+ * dispute.
+ *
+ * ## What this is NOT
+ *
+ * 🛑 It is not policy. Every row carries a `kind`, and the GATE lives on the
+ * kind — see `_internal/shared/features/orders/dispute-reasons.ts`. A row can
+ * never introduce a new kind of claim, because a gate cannot branch on a
+ * user-created string.
+ *
+ * So this list is for TRIAGE and ANALYTICS: "what are buyers actually
+ * reporting", answered without reading free text. Staff (admin + employees)
+ * add rows as real gaps appear; buyers select only.
+ *
+ * ## Why staff-creatable rather than a closed enum
+ *
+ * Its sibling `RETURN_REASON` *is* a closed enum, and deliberately so: each
+ * member there decides whether a final sale can refuse the return, which is a
+ * money consequence that must be reviewed in code. Nothing here decides money.
+ * A support agent who keeps seeing "the courier left it at the wrong flat"
+ * should be able to add it without a release.
+ */
+export const DISPUTE_REASON_COLLECTION = "disputeReasons";
+export const DISPUTE_REASON_FIELDS = {
+    ID: "id",
+    LABEL: "label",
+    KIND: "kind",
+    IS_ACTIVE: "isActive",
+    CREATED_BY_UID: "createdByUid",
+    CREATED_AT: "createdAt",
+};
+/**
+ * Bounds on a label.
+ *
+ * Short on purpose: this is a picker option, not the buyer's explanation. The
+ * detail goes in the free-text field on the dispute itself, which is where a
+ * buyer should describe what actually happened.
+ */
+export const DISPUTE_REASON_LABEL_MAX = 80;

package/dist/features/faq/components/FAQAccordion.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import type { FAQ, FAQCategory } from "../types";
+import { type PublishedValues } from "../../../_internal/shared/content/published-values";
 export interface FAQAccordionProps {
     faqs: FAQ[];
     className?: string;
@@ -8,8 +9,19 @@ export interface FAQAccordionProps {
     labels?: {
         noResults?: string;
     };
+    /**
+     * Phase 9 — resolved published values, for `{{token}}` substitution in
+     * answers. Build them with `resolvePublishedValues(settings?.commissions)`
+     * at the page level and pass them down.
+     *
+     * 🛑 Passed in rather than read here. This component renders on the server
+     * and in the client, and a settings read inside a presentational component
+     * would both make it unusable in half the places it is needed and fire one
+     * read per accordion on a page that has several.
+     */
+    publishedValues?: PublishedValues;
 }
-export declare function FAQAccordion({ faqs, className, renderExpandedFooter, labels, }: FAQAccordionProps): React.JSX.Element;
+export declare function FAQAccordion({ faqs, className, renderExpandedFooter, labels, publishedValues, }: FAQAccordionProps): React.JSX.Element;
 interface FAQCategoryTabsProps {
     categories: FAQCategory[];
     active?: FAQCategory | null;

package/dist/features/faq/components/FAQAccordion.js

@@ -2,16 +2,41 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Button, Div, RichText, Row, Span, Tabs, TabsList, TabsTrigger, Text } from "../../../ui/index.js";
+/* Phase 9 — `publishedCopyKey`'s first reader. See the 🛑 at the render site. */
+import { resolvePublishedCopy, resolvePublishedValues, } from "../../../_internal/shared/content/published-values.js";
 import { RecordOwnerQuickActions } from "../../admin/components/RecordOwnerQuickActions.js";
-function FAQAccordionItem({ faq, isOpen, onToggle, renderExpandedFooter, }) {
-    return (_jsxs(Div, { className: "border-b border-neutral-200 last:border-0", children: [_jsxs(Button, { variant: "ghost", onClick: onToggle, "aria-expanded": isOpen, justify: "between", className: "w-full gap-[1rem] py-[1rem] text-left text-[0.875rem] font-[500] text-[var(--appkit-color-text)] dark:text-[var(--appkit-color-text)] transition hover:text-primary", children: [_jsx(Span, { children: faq.question }), _jsx(Span, { className: `flex-shrink-0 transition-transform ${isOpen ? "rotate-180" : ""}`, children: _jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", "aria-hidden": "true", children: _jsx("path", { d: "M4 6l4 4 4-4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }) })] }), isOpen && (_jsxs(Div, { textSize: "sm", className: "text-[var(--appkit-color-text-muted)]", padding: "b-md", children: [faq.tags && faq.tags.length > 0 && (_jsx(Row, { wrap: true, gap: "sm", className: "mb-3", children: faq.tags.map((tag) => (_jsx(Span, { className: "bg-[var(--appkit-color-surface)] py-[0.25rem] text-[var(--appkit-color-text-muted)]", rounded: "md", padding: "x-xs", size: "xs", children: tag }, tag))) })), faq.answer.format === "html" ? (_jsx(RichText, { html: faq.answer.text, className: "prose-sm" })) : (_jsx(Text, { className: "whitespace-pre-line", children: faq.answer.text })), _jsx(Row, { justify: "end", className: "mt-3", children: _jsx(RecordOwnerQuickActions, { resource: "FAQ", recordId: faq.id, placement: "detail", recordLabel: faq.question }) }), renderExpandedFooter?.(faq)] }))] }));
+/**
+ * Code-derived values, resolved once at module scope.
+ *
+ * ## 🛑 Why a DEFAULT rather than a required prop
+ *
+ * `resolvePublishedValues()` with no settings argument is PURE over code
+ * constants — the obligation policies, `LANE_CHECKOUT_WINDOW_MS`,
+ * `POINTS_EARN_PERCENT`. It reads no Firestore and touches no settings, so
+ * calling it here costs one object at import and cannot leak anything.
+ *
+ * That matters because there are FOUR mount sites (the FAQ page, the
+ * searchable list, the category highlights section, and this file's own
+ * loop). Requiring the prop would mean threading it through four callers and
+ * their callers — and the one that got missed would render `{{…}}` to a
+ * visitor. A default that always resolves the code-derived numbers, with an
+ * override for the settings-driven money ones, gets every surface right
+ * immediately.
+ *
+ * A caller WITH settings in hand should still pass them: without them the
+ * money values fall back to the schema defaults, which is correct but is not
+ * the admin's current configuration.
+ */
+const CODE_DERIVED_VALUES = resolvePublishedValues();
+function FAQAccordionItem({ faq, isOpen, onToggle, renderExpandedFooter, publishedValues = CODE_DERIVED_VALUES, }) {
+    return (_jsxs(Div, { className: "border-b border-neutral-200 last:border-0", children: [_jsxs(Button, { variant: "ghost", onClick: onToggle, "aria-expanded": isOpen, justify: "between", className: "w-full gap-[1rem] py-[1rem] text-left text-[0.875rem] font-[500] text-[var(--appkit-color-text)] dark:text-[var(--appkit-color-text)] transition hover:text-primary", children: [_jsx(Span, { children: faq.question }), _jsx(Span, { className: `flex-shrink-0 transition-transform ${isOpen ? "rotate-180" : ""}`, children: _jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", "aria-hidden": "true", children: _jsx("path", { d: "M4 6l4 4 4-4", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }) })] }), isOpen && (_jsxs(Div, { textSize: "sm", className: "text-[var(--appkit-color-text-muted)]", padding: "b-md", children: [faq.tags && faq.tags.length > 0 && (_jsx(Row, { wrap: true, gap: "sm", className: "mb-3", children: faq.tags.map((tag) => (_jsx(Span, { className: "bg-[var(--appkit-color-surface)] py-[0.25rem] text-[var(--appkit-color-text-muted)]", rounded: "md", padding: "x-xs", size: "xs", children: tag }, tag))) })), faq.answer.format === "html" ? (_jsx(RichText, { html: resolvePublishedCopy(faq.answer.text, publishedValues), className: "prose-sm" })) : (_jsx(Text, { className: "whitespace-pre-line", children: resolvePublishedCopy(faq.answer.text, publishedValues) })), _jsx(Row, { justify: "end", className: "mt-3", children: _jsx(RecordOwnerQuickActions, { resource: "FAQ", recordId: faq.id, placement: "detail", recordLabel: faq.question }) }), renderExpandedFooter?.(faq)] }))] }));
 }
-export function FAQAccordion({ faqs, className = "", renderExpandedFooter, labels, }) {
+export function FAQAccordion({ faqs, className = "", renderExpandedFooter, labels, publishedValues, }) {
     const [openId, setOpenId] = useState(null);
     if (faqs.length === 0 && labels?.noResults) {
         return (_jsx(Div, { surface: "card", padding: "xl", className: "text-center", children: _jsx(Text, { className: "text-[var(--appkit-color-text-muted)]", children: labels.noResults }) }));
     }
-    return (_jsx(Div, { surface: "card", className: `divide-y divide-neutral-100 divide-[var(--appkit-color-border)] ${className}`, padding: "x-md", children: faqs.map((faq) => (_jsx(FAQAccordionItem, { faq: faq, isOpen: openId === faq.id, onToggle: () => setOpenId(openId === faq.id ? null : faq.id), renderExpandedFooter: renderExpandedFooter }, faq.id))) }));
+    return (_jsx(Div, { surface: "card", className: `divide-y divide-neutral-100 divide-[var(--appkit-color-border)] ${className}`, padding: "x-md", children: faqs.map((faq) => (_jsx(FAQAccordionItem, { faq: faq, isOpen: openId === faq.id, onToggle: () => setOpenId(openId === faq.id ? null : faq.id), renderExpandedFooter: renderExpandedFooter, publishedValues: publishedValues }, faq.id))) }));
 }
 const ALL_TAB_VALUE = "__all__";
 export function FAQCategoryTabs({ categories, active, onSelect, labels = {}, }) {