@mohasinac/appkit 4.52.5 → 4.53.1

package/dist/_internal/shared/features/cart/schema.js

@@ -1,3 +1,4 @@
+import { STANDARD_MAX_QTY_PER_LINE } from "../../checkout/rules/_limits.js";
 import { z } from "zod";
 const cartItemBaseSchema = z.object({
     productId: z.string().min(1),
@@ -7,7 +8,7 @@ const cartItemBaseSchema = z.object({
     currency: z.string().default("INR"),
     storeId: z.string(),
     storeName: z.string().default(""),
-    quantity: z.number().int().min(1).max(99).default(1),
+    quantity: z.number().int().min(1).max(STANDARD_MAX_QTY_PER_LINE).default(1),
     // SB1-G Phase 4 — canonical listing-kind snapshot.
     // SB-UNI-D — "bundle" removed from the listing-kind enum.
     /*
@@ -41,7 +42,7 @@ const cartItemBaseSchema = z.object({
 export const addToCartSchema = cartItemBaseSchema;
 export const updateCartItemSchema = z.object({
     productId: z.string().min(1),
-    quantity: z.number().int().min(1).max(99),
+    quantity: z.number().int().min(1).max(STANDARD_MAX_QTY_PER_LINE),
 });
 export const removeFromCartSchema = z.object({
     productId: z.string().min(1),

package/dist/_internal/shared/features/events/config.d.ts

@@ -3,3 +3,17 @@ export declare const EVENTS_UPCOMING_LIMIT = 10;
 export declare const EVENT_MAX_ENTRIES_DEFAULT = 500;
 export declare const EVENT_TITLE_MAX_LENGTH = 200;
 export declare const EVENT_DESCRIPTION_MAX_LENGTH = 5000;
+/**
+ * Entries one person may put into a raffle.
+ *
+ * One, because a raffle is one ticket per person and there is nothing to
+ * configure: `maxEntriesPerUser` exists on `SurveyConfig` only, and
+ * `EventDocument` has no `raffleConfig` at all.
+ *
+ * 🛑 Shared deliberately, by BOTH `enterEvent`'s server-side dedupe and the
+ * `EventRaffleEntryForm` prop that renders "you've used all N entry slots".
+ * Two mirrored literals is the shape that made this bug survive: the form
+ * already defaulted to 1 and displayed that sentence, while the server
+ * enforced nothing, so the UI claimed a limit that did not exist.
+ */
+export declare const RAFFLE_MAX_ENTRIES_PER_USER = 1;

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

@@ -3,3 +3,17 @@ export const EVENTS_UPCOMING_LIMIT = 10;
 export const EVENT_MAX_ENTRIES_DEFAULT = 500;
 export const EVENT_TITLE_MAX_LENGTH = 200;
 export const EVENT_DESCRIPTION_MAX_LENGTH = 5000;
+/**
+ * Entries one person may put into a raffle.
+ *
+ * One, because a raffle is one ticket per person and there is nothing to
+ * configure: `maxEntriesPerUser` exists on `SurveyConfig` only, and
+ * `EventDocument` has no `raffleConfig` at all.
+ *
+ * 🛑 Shared deliberately, by BOTH `enterEvent`'s server-side dedupe and the
+ * `EventRaffleEntryForm` prop that renders "you've used all N entry slots".
+ * Two mirrored literals is the shape that made this bug survive: the form
+ * already defaulted to 1 and displayed that sentence, while the server
+ * enforced nothing, so the UI claimed a limit that did not exist.
+ */
+export const RAFFLE_MAX_ENTRIES_PER_USER = 1;

package/dist/_internal/shared/features/notifications/action-url.js

@@ -97,6 +97,14 @@ export function resolveNotificationActionUrl(relatedType, relatedId, audience) {
             return audience === "admin"
                 ? String(ROUTES.ADMIN.STORE_DETAIL(relatedId))
                 : String(ROUTES.STORE.DASHBOARD);
+        case "event":
+            /*
+             * The public winner page — the same destination for everyone, like
+             * `product` and `review`. An admin who drew the raffle and the buyer who
+             * won it both want to see the announcement, and that announcement IS the
+             * public page; there is no admin-side winner view to send them to.
+             */
+            return String(ROUTES.PUBLIC.EVENT_WINNER(relatedId));
         case "conversation":
             // D9 — one universal inbox, reachable from any portal; there is no
             // admin-specific thread view (admins moderate via reports, not a

package/dist/_internal/shared/features/products/group-rules.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What a seller or admin may constrain about a self-assembled selection.
+ *
+ * 🛑 These are limits on the SELECTION, never on stock. Stock is independent
+ * per listing (there is no pool and no bill of materials) — a spare attack ring
+ * is one object the seller happens to have. These answer "what counts as a
+ * valid mix", which is a merchandising decision.
+ */
+export interface GroupRules {
+    /** Fewest DISTINCT members a valid selection may contain. */
+    groupMinMembers?: number;
+    /** Most distinct members. */
+    groupMaxMembers?: number;
+    /** Ceiling on units of any ONE member, independent of the line total. */
+    groupMaxUnitsPerMember?: number;
+    /** Product ids that must be present for the selection to be valid. */
+    groupRequiredMemberIds?: string[];
+    /**
+     * Percentage off the selection's subtotal, 0–100.
+     *
+     * 🛑 Carried here but NOT applied here, and that separation is deliberate.
+     * The discount has to land inside the repository's private `deriveLinePrice`,
+     * which runs on every `groupMembers` write and feeds
+     * `expandCartLineToOrderRows`' per-member GST proration via
+     * `allocateAcrossMembers`. Applying it in a second place is how the cart
+     * total comes to disagree with the invoice (Root Cause #75), so this module
+     * only ever REPORTS the figure.
+     */
+    groupDiscountPercent?: number;
+}
+export declare const EMPTY_GROUP_RULES: GroupRules;
+/** Whichever document the rules were read off. */
+export type GroupRuleSource = "product-group" | "grouped-listing";
+/**
+ * Read the rules off either home.
+ *
+ * Structurally typed on purpose: a product group's rules live on the PARENT
+ * product document and a grouped listing's on its own, and both are just
+ * objects carrying these optional keys. Taking `ProductDocument |
+ * GroupedListingDocument` here would drag two feature schemas into a shared
+ * module for no gain — and this module is imported by a client component.
+ */
+export declare function readGroupRules(doc: Partial<GroupRules> | null | undefined): GroupRules;
+export interface GroupRuleViolation {
+    code: "GROUP_TOO_FEW_MEMBERS" | "GROUP_TOO_MANY_MEMBERS" | "GROUP_MEMBER_QTY_EXCEEDED" | "GROUP_REQUIRED_MEMBER_MISSING";
+    /** Buyer-facing, already specific. Never a raw field name. */
+    message: string;
+}
+/** One chosen member: which product, and how many of it. */
+export interface GroupSelectionEntry {
+    productId: string;
+    quantity: number;
+    /** For the message. Falls back to the id when the caller has no title. */
+    title?: string;
+}
+/**
+ * Check a selection against the rules.
+ *
+ * Returns ALL violations rather than the first, because a picker shows them
+ * together and fixing one at a time is a worse experience than seeing the set.
+ * The server throws on the first; that is the caller's choice, not this
+ * function's.
+ *
+ * Entries at quantity 0 are ignored — the picker's stepper has `min={0}` and
+ * zero means "not chosen", so counting them would make an untouched member
+ * count toward `groupMinMembers`.
+ */
+export declare function checkGroupRules(rules: GroupRules, selection: readonly GroupSelectionEntry[]): GroupRuleViolation[];
+/**
+ * The rules in words, for the picker's header.
+ *
+ * Returns an empty array when nothing is restricted, so the caller renders
+ * nothing rather than an empty box saying "Rules:".
+ */
+export declare function describeGroupRules(rules: GroupRules): string[];

package/dist/_internal/shared/features/products/group-rules.js

@@ -0,0 +1,142 @@
+/*
+ * WHY: "Create your own bundle, with restrictions set by seller/admin" is the
+ *      feature. The restrictions have TWO homes — a product group is identified
+ *      by the parent product's slug, while a `groupedListing` is its own
+ *      document — and the picker, the cart-add and the checkout re-validation
+ *      all have to agree about them.
+ * WHAT: One shape, one resolver, one enforcer. Three readers, zero copies.
+ *
+ * 🛑 THE SAME RULES, FROM EITHER HOME. Resolving them at each call site is how
+ * a picker ends up permitting a selection the server then refuses (or worse,
+ * the reverse — a server-only rule reads as a broken button). `resolveGroupRules`
+ * is the only place the two homes are read, and `checkGroupRules` is the only
+ * place they are applied.
+ *
+ * 🛑 EVERY FIELD IS OPTIONAL AND ABSENT MEANS UNRESTRICTED. Every group that
+ * exists today has none of these, so a default that restricted anything would
+ * silently change what is buyable on live records.
+ *
+ * EXPORTS: GroupRules, GroupRuleSource, GroupRuleViolation, EMPTY_GROUP_RULES,
+ *          readGroupRules, checkGroupRules, describeGroupRules
+ *
+ * @tag domain:products
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:GroupMemberPicker,cart-actions,checkout
+ * @tag sideEffects:none
+ */
+export const EMPTY_GROUP_RULES = {};
+/**
+ * Read the rules off either home.
+ *
+ * Structurally typed on purpose: a product group's rules live on the PARENT
+ * product document and a grouped listing's on its own, and both are just
+ * objects carrying these optional keys. Taking `ProductDocument |
+ * GroupedListingDocument` here would drag two feature schemas into a shared
+ * module for no gain — and this module is imported by a client component.
+ */
+export function readGroupRules(doc) {
+    if (!doc)
+        return EMPTY_GROUP_RULES;
+    const out = {};
+    /*
+     * Copied field by field rather than spread. A spread of the whole parent
+     * PRODUCT document would carry ~90 unrelated fields into something named
+     * "rules", and the next reader would reasonably assume everything on it was
+     * a rule.
+     */
+    if (typeof doc.groupMinMembers === "number")
+        out.groupMinMembers = doc.groupMinMembers;
+    if (typeof doc.groupMaxMembers === "number")
+        out.groupMaxMembers = doc.groupMaxMembers;
+    if (typeof doc.groupMaxUnitsPerMember === "number") {
+        out.groupMaxUnitsPerMember = doc.groupMaxUnitsPerMember;
+    }
+    if (Array.isArray(doc.groupRequiredMemberIds) && doc.groupRequiredMemberIds.length > 0) {
+        out.groupRequiredMemberIds = [...doc.groupRequiredMemberIds];
+    }
+    if (typeof doc.groupDiscountPercent === "number") {
+        out.groupDiscountPercent = doc.groupDiscountPercent;
+    }
+    return out;
+}
+/**
+ * Check a selection against the rules.
+ *
+ * Returns ALL violations rather than the first, because a picker shows them
+ * together and fixing one at a time is a worse experience than seeing the set.
+ * The server throws on the first; that is the caller's choice, not this
+ * function's.
+ *
+ * Entries at quantity 0 are ignored — the picker's stepper has `min={0}` and
+ * zero means "not chosen", so counting them would make an untouched member
+ * count toward `groupMinMembers`.
+ */
+export function checkGroupRules(rules, selection) {
+    const chosen = selection.filter((e) => e.quantity > 0);
+    const out = [];
+    if (rules.groupMinMembers !== undefined && chosen.length < rules.groupMinMembers) {
+        out.push({
+            code: "GROUP_TOO_FEW_MEMBERS",
+            message: `Pick at least ${rules.groupMinMembers} different item${rules.groupMinMembers === 1 ? "" : "s"} from this group — you have ${chosen.length}.`,
+        });
+    }
+    if (rules.groupMaxMembers !== undefined && chosen.length > rules.groupMaxMembers) {
+        out.push({
+            code: "GROUP_TOO_MANY_MEMBERS",
+            message: `Pick at most ${rules.groupMaxMembers} different item${rules.groupMaxMembers === 1 ? "" : "s"} from this group — you have ${chosen.length}.`,
+        });
+    }
+    if (rules.groupMaxUnitsPerMember !== undefined) {
+        for (const entry of chosen) {
+            if (entry.quantity > rules.groupMaxUnitsPerMember) {
+                out.push({
+                    code: "GROUP_MEMBER_QTY_EXCEEDED",
+                    message: `At most ${rules.groupMaxUnitsPerMember} of "${entry.title ?? entry.productId}" per order.`,
+                });
+            }
+        }
+    }
+    if (rules.groupRequiredMemberIds) {
+        const present = new Set(chosen.map((e) => e.productId));
+        const missing = rules.groupRequiredMemberIds.filter((id) => !present.has(id));
+        if (missing.length > 0) {
+            /*
+             * Named by id when the caller has no title for it — which is the normal
+             * case, because a REQUIRED member the buyer has not chosen is not in
+             * their selection and so has no entry to read a title from. The picker
+             * passes titles it already has; the server does not have them and says
+             * so honestly rather than printing "undefined".
+             */
+            const titles = missing.map((id) => selection.find((e) => e.productId === id)?.title ?? id);
+            out.push({
+                code: "GROUP_REQUIRED_MEMBER_MISSING",
+                message: `This group requires ${titles.join(", ")} to be included.`,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The rules in words, for the picker's header.
+ *
+ * Returns an empty array when nothing is restricted, so the caller renders
+ * nothing rather than an empty box saying "Rules:".
+ */
+export function describeGroupRules(rules) {
+    const out = [];
+    if (rules.groupMinMembers !== undefined) {
+        out.push(`Pick at least ${rules.groupMinMembers}`);
+    }
+    if (rules.groupMaxMembers !== undefined) {
+        out.push(`Pick at most ${rules.groupMaxMembers}`);
+    }
+    if (rules.groupMaxUnitsPerMember !== undefined) {
+        out.push(`Max ${rules.groupMaxUnitsPerMember} of each`);
+    }
+    if (rules.groupDiscountPercent !== undefined && rules.groupDiscountPercent > 0) {
+        out.push(`${rules.groupDiscountPercent}% off the selection`);
+    }
+    return out;
+}

package/dist/_internal/shared/features/site-settings/types.d.ts

@@ -42,6 +42,17 @@ export interface PublicSiteSettings {
     chat?: {
         enabled: boolean;
     };
+    /**
+     * The browser-side search index kill switch. **ON by default** — the
+     * projection emits `indexEnabled: doc.search?.indexEnabled !== false`, so
+     * an unseeded settings document and an absent group both mean "search
+     * works". The property itself is optional only because an OLD cached
+     * `/api/site-settings` response predates the field; `useSearchIndex`
+     * therefore reads it as `!== false` a second time rather than `=== true`.
+     */
+    search?: {
+        indexEnabled: boolean;
+    };
     notificationChannels?: NotificationChannelConfig;
     announcementBar?: SiteSettingsDocument["announcementBar"];
     navConfig?: SiteSettingsDocument["navConfig"];

package/dist/_internal/shared/features/sticker-trace/codec.d.ts

@@ -0,0 +1,81 @@
+import type { DecodedRaster, EncodedImage, Rect } from "./types";
+export interface ProbeResult {
+    readonly width: number;
+    readonly height: number;
+    /**
+     * The density the FILE declares, unvalidated. Five of the nine reference
+     * scans say 72 or 96 — an encoder default, not a measurement — so a caller
+     * must treat this as a suggestion to confirm, never as truth.
+     */
+    readonly dpi?: number;
+}
+export interface DecodeOptions {
+    /**
+     * The memory cap, enforced INSIDE the codec.
+     *
+     * This is the single most important line in the seam. sharp downscales in
+     * native code during decode and canvas does it in `drawImage`, so a 34 MP
+     * source never materialises as a JS buffer. If a codec implementation ignores
+     * this and returns full-resolution pixels, every Float32Array downstream
+     * scales with it and the Function runs out of memory — with no error that
+     * points here.
+     */
+    readonly maxLongEdge: number;
+}
+export interface PreviewOptions {
+    readonly maxLongEdge: number;
+    readonly format: "png" | "webp";
+}
+export interface ImageCodec {
+    /** Header-only. Must not decode pixels — it runs on the full upload. */
+    probe(source: Uint8Array): Promise<ProbeResult>;
+    /**
+     * Decode, downscale to `maxLongEdge`, apply EXIF orientation, drop ICC.
+     *
+     * The last two matter for correctness, not tidiness: both codecs must hand
+     * back the SAME pixels for the same file, or a path tuned in the browser
+     * lands somewhere else when the Function re-renders it.
+     */
+    decode(source: Uint8Array, opts: DecodeOptions): Promise<DecodedRaster>;
+    /**
+     * Decode one tile at native resolution, for the `max` tier's tiled ridge pass.
+     *
+     * 🛑 Tiles must overlap by at least the ridge kernel radius. A cut line
+     * crossing a seam with insufficient overlap is detected on neither side and
+     * breaks silently — producing worse output than the cheaper `precise` tier,
+     * which is the one way that tier can quietly be a downgrade.
+     */
+    decodeTile(source: Uint8Array, tile: Rect): Promise<DecodedRaster>;
+    encodePng(raster: DecodedRaster): Promise<EncodedImage>;
+    /**
+     * Crop to `region` and apply `alpha` (length === region.width * region.height),
+     * in one call.
+     *
+     * One call rather than crop-then-composite so that neither codec needs its own
+     * pixel loop, and — the real reason — so a full-resolution part render never
+     * materialises a full-resolution RGBA buffer. The caller rasterises that one
+     * part's Bézier path into `alpha` over its own bounding box, and the codec
+     * reads only that box out of the source file. Sixty parts therefore cost
+     * sixty small allocations rather than one enormous one.
+     */
+    encodePngRegion(source: Uint8Array, region: Rect, alpha: Uint8Array): Promise<EncodedImage>;
+    /** The ≤1 MB review image the UI loads instead of the scan. */
+    encodePreview(source: Uint8Array, opts: PreviewOptions): Promise<EncodedImage>;
+    /**
+     * Pack already-encoded tiles into one sprite atlas.
+     *
+     * Exists because object COUNT is metered separately from bytes: sixty
+     * thumbnail objects per run spend the Class A/B allowance sixty times faster
+     * than one atlas of the same pixels, and the part list loads in one request
+     * rather than sixty.
+     */
+    encodeAtlas(tiles: readonly {
+        readonly raster: DecodedRaster;
+        readonly ordinal: number;
+    }[], opts: {
+        readonly maxLongEdge: number;
+    }): Promise<{
+        readonly image: EncodedImage;
+        readonly frames: Readonly<Record<number, Rect>>;
+    }>;
+}

package/dist/_internal/shared/features/sticker-trace/codec.js

@@ -0,0 +1,30 @@
+/*
+ * WHY: The tracing algorithm must be ONE implementation, but it has to run in a
+ *      browser (live threshold tuning, ~1s per tweak) and in a Firebase Function
+ *      (full-resolution render on save). Two implementations drift, and the one
+ *      that drifts is always the one you are not currently looking at
+ *      (CLAUDE.md Root Cause #59/#73). So the algorithm is shared and only the
+ *      pixel I/O differs — this file is that seam, and it is the whole of it.
+ * WHAT: The codec interface. Declaration only: no implementation, no imports, no
+ *       dependency on sharp, canvas, node:* or providers/*. Keeping this tree
+ *       import-free is what lets the browser bundle it at all (Root Cause #24),
+ *       and `audit-sticker-trace-purity` enforces it.
+ *
+ * The division of labour is deliberate and worth stating, because getting it
+ * wrong reintroduces the memory problem the design exists to avoid:
+ *
+ *   codec  — owns BYTES. Decodes, downscales, crops, encodes.
+ *   core   — owns MATHS. Takes a DecodedRaster, returns geometry. Never resizes
+ *            anything, never allocates at source resolution, never sees a file.
+ *
+ * EXPORTS:
+ *   ImageCodec, DecodeOptions, PreviewOptions, ProbeResult
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:port
+ * @tag access:isomorphic
+ * @tag consumers:canvas-codec,sharp-codec,run,coordinator,shard
+ * @tag sideEffects:none
+ */
+export {};

package/dist/_internal/shared/features/sticker-trace/config.d.ts

@@ -0,0 +1,81 @@
+import type { PrecisionTier, TraceParams } from "./types";
+/**
+ * The memory cap, and the reason the core never sees a 34 MP buffer.
+ *
+ * The downscale happens inside the CODEC, not here — sharp does it in native
+ * code, canvas in `drawImage` — so no Float32Array is ever allocated at source
+ * resolution. At 3000px long edge a mask is ~9 MB as Uint8 and a distance
+ * transform ~36 MB as Float32, with several live at once; that fits a 2 GiB
+ * Function with room. The `max` tier deliberately exceeds it and pays for that
+ * by tiling the ridge pass instead (see trace/tiling).
+ */
+export declare const WORKING_LONG_EDGE = 3000;
+/** The review image. Must stay ≤1 MB — the UI loads it on every sheet open. */
+export declare const PREVIEW_LONG_EDGE = 2000;
+/** Per-part review thumbnails, packed into ONE sprite atlas rather than N objects. */
+export declare const THUMB_LONG_EDGE = 220;
+/**
+ * Upload ceiling. Deliberately its own constant rather than the shared
+ * MAX_IMAGE_BYTES (10 MB), which is sized for product photography and must not
+ * be raised — a 4948x6955 scan is legitimately 80 MB.
+ */
+export declare const STICKER_SHEET_MAX_BYTES: number;
+/**
+ * A hard bound, not a tuning knob. A noise-dominated scan whose ridges survive
+ * hysteresis produces thousands of components, and without this the failure
+ * mode is thousands of Storage writes rather than an error message.
+ */
+export declare const MAX_PARTS_PER_SHEET = 400;
+/**
+ * Gap between physical sheets in one scan. Stickers on a sheet sit a few mm
+ * apart; separate sheets land centimetres apart, so the threshold has a wide
+ * safe margin either side.
+ */
+export declare const SHEET_CLUSTER_GAP_MM = 12;
+/**
+ * Cricut's documented minimum reliable detail / line spacing: 0.25 in. A part
+ * with an internal neck below this tears instead of cutting.
+ */
+export declare const CRICUT_MIN_FEATURE_MM = 6.35;
+/**
+ * Design Space degrades past roughly 50,000 nodes. The exporter re-simplifies
+ * to this budget INDEPENDENTLY of the trace tolerance — tying the two together
+ * would mean a more precise trace producing a file Design Space cannot open.
+ */
+export declare const CRICUT_NODE_BUDGET = 45000;
+interface TierPreset {
+    readonly workingLongEdge: number;
+    readonly prefilter: TraceParams["prefilter"];
+    readonly prefilterRadius: number;
+    readonly simplifyMm: number;
+    readonly smoothMm: number;
+    readonly subPixelContours: boolean;
+    readonly tiled: boolean;
+}
+/**
+ * `draft` exists for the browser's live loop and nothing else — 1200px traces
+ * in about a second, which is what makes threshold tuning feel like a slider
+ * rather than a job submission.
+ *
+ * `max` is the only tier that tiles. Its simplify tolerance is fine enough that
+ * the Cricut exporter will almost certainly have to re-simplify; that is
+ * expected and reported, not a misconfiguration.
+ */
+export declare const TIER_PRESETS: Readonly<Record<PrecisionTier, TierPreset>>;
+/**
+ * Defaults measured against the reference corpus, not guessed:
+ *
+ * - `ridgeHysteresisLow/High` — the cut line reads as a dark-trough/light-ridge
+ *   doublet at 10-20x scan noise on four sampled scanlines (−40/+27 against ±2
+ *   on yellow-on-yellow, +22 against ±1 on red-on-red). The low threshold sits
+ *   just above the worst measured noise floor (±7, a JPEG scan) so a faint but
+ *   continuous line links, while isolated speckle does not seed.
+ * - `quantiseWeight` below 1 on purpose: the colour channel REINFORCES a weak
+ *   ridge but must not invent a cut where only a colour change exists, or every
+ *   gradient band inside a sticker becomes an outline.
+ * - `bridgeMm` closes white channels narrower than 2x itself. It must sit
+ *   between the widest intra-sticker band and the narrowest real gap between
+ *   neighbours; 0.45 was measured on the Driger G sheet.
+ */
+export declare function paramsForTier(tier: PrecisionTier, overrides?: Partial<TraceParams>): TraceParams;
+export {};