apps/web/lib/api/bounties/get-bounty-submissions.ts (2)

21-21: Ensure undefined status is omitted, not treated as a filter.

Prisma typically ignores undefined in where, but be explicit to avoid accidental narrowing.

-      status,
+      ...(status ? { status } : {}),

---

43-55: Avoid spreading entire programEnrollment into partner payload.

This can leak unintended fields and diverge from BountySubmissionExtendedSchema (which expects only specific partner fields including groupId/status).

-        partner: {
-          ...partner,
-          ...programEnrollment,
-          id: partner.id,
-          status: programEnrollment?.status,
-        },
+        partner: {
+          ...partner,
+          id: partner.id,
+          groupId: programEnrollment?.groupId ?? null,
+          status: programEnrollment?.status ?? null,
+        },

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/bounty-action-button.tsx (1)

34-42: Load-safety for counts.

If the hook is still loading, totalSubmissions is 0 and the menu briefly appears enabled. Consider passing an isLoading flag from the hook to gate the menu, or render a loading state until counts arrive.

apps/web/lib/zod/schemas/bounties.ts (1)

111-112: booleanQuerySchema default.

Defaulting with "false" (string) is fine due to transform, but can be confusing. Consider default(false) post-transform for clarity.

apps/web/app/(ee)/api/bounties/route.ts (1)

48-95: Counting approach is correct; consider pre-indexing for O(n) aggregation.

Filtering the full groupBy array per bounty is O(B×S). Pre-index by bountyId once to reduce to O(B+S).

-    const aggregateSubmissionsCountForBounty = (bountyId: string) => {
-      if (!allBountiesSubmissionsCount) {
-        return null;
-      }
-      const bountySubmissions = allBountiesSubmissionsCount.filter(
-        (s) => s.bountyId === bountyId,
-      );
+    const countsByBounty = allBountiesSubmissionsCount
+      ? allBountiesSubmissionsCount.reduce<Record<string, typeof allBountiesSubmissionsCount>>(
+          (acc, row) => {
+            (acc[row.bountyId] ||= []).push(row);
+            return acc;
+          },
+          {},
+        )
+      : null;
+
+    const aggregateSubmissionsCountForBounty = (bountyId: string) => {
+      if (!countsByBounty) return null;
+      const bountySubmissions = countsByBounty[bountyId] ?? [];
       const total = bountySubmissions.reduce(
         (sum, s) => sum + s._count.status,
         0,
       );

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: devkiran
PR: dubinc/dub#2736
File: apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-info.tsx:45-56
Timestamp: 2025-08-25T17:39:38.965Z
Learning: In the bounty system, each partner can only submit to the same bounty once. This means totalSubmissions (pending + approved + rejected) equals the number of unique partners who have submitted, making UI text like "X of Y partners completed" accurate when using totalSubmissions.

apps/web/app/(ee)/api/partner-profile/programs/[programId]/bounties/route.ts (1)

10-11: Unused searchParams parameter.

The searchParams parameter is destructured but never used in the handler body. Based on the PR context mentioning includeSubmissionsCount being introduced in bounties APIs, this parameter may have been added to support that feature.

Please either:

1. Remove the unused parameter if it's not needed, or
2. Implement the expected functionality (e.g., includeSubmissionsCount query parameter support)

 export const GET = withPartnerProfile(
-  async ({ partner, params, searchParams }) => {
+  async ({ partner, params }) => {

Alternatively, if includeSubmissionsCount should be supported here, implement it similar to other bounties endpoints in this PR.

apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/bounties/partner-bounty-card.tsx (1)

15-16: Simplify the boolean expression.

The ternary operator returning boolean literals is redundant since the expression already evaluates to a boolean.

Apply this diff to simplify:

-  const expiredBounty =
-    bounty.endsAt && new Date(bounty.endsAt) < new Date() ? true : false;
+  const expiredBounty = !!bounty.endsAt && new Date(bounty.endsAt) < new Date();

apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/bounties/page-client.tsx (6)

14-23: Type-safety for tab ids.
Derive a TabId type from tabs to keep state and usages in sync as tabs evolve.

Add near the tabs declaration:

type TabId = (typeof tabs)[number]["id"];

---

26-26: Use the derived TabId for state to avoid drift.
Keeps state constrained to the tabs’ ids.

- const [activeTab, setActiveTab] = useState<"active" | "expired">("active");
+ const [activeTab, setActiveTab] = useState<TabId>("active");

---

29-44: Harden date handling (Invalid Date/UTC edges) and avoid duplicate parsing.
Parse once to ms and guard against NaN; this also avoids repeated Date allocations.

Please confirm the shape of bounty.endsAt (ISO with timezone vs date-only like YYYY-MM-DD). If date-only, we may need to interpret it in a specific timezone or as end-of-day to avoid off-by-hours.

Add a small helper near the top of the file:

const isExpiredAt = (
  endsAt: string | null | undefined,
  nowMs: number,
): boolean => {
  if (!endsAt) return false;
  const ms = Date.parse(endsAt);
  return Number.isFinite(ms) && ms <= nowMs;
};

Then update the memo:

-  const filteredBounties = useMemo(() => {
+  const filteredBounties = useMemo(() => {
     if (!bounties) return [];
-
-    const now = new Date();
-    return bounties.filter((bounty) => {
-      const isExpired = bounty.endsAt && new Date(bounty.endsAt) <= now;
+    const nowMs = Date.now();
+    return bounties.filter(({ endsAt }) => {
+      const isExpired = isExpiredAt(endsAt, nowMs);
       if (activeTab === "active") {
         return !isExpired;
       } else {
         return isExpired;
       }
     });
   }, [bounties, activeTab]);

---

45-59: DRY up expiry logic in counts to match filtering.
Reuse the same helper to keep behavior consistent and avoid parsing twice.

-  const tabCounts = useMemo(() => {
+  const tabCounts = useMemo(() => {
     if (!bounties) return { active: 0, expired: 0 };
-
-    const now = new Date();
-    return bounties.reduce(
-      (counts, bounty) => {
-        const isExpired = bounty.endsAt && new Date(bounty.endsAt) <= now;
+    const nowMs = Date.now();
+    return bounties.reduce(
+      (counts, { endsAt }) => {
+        const isExpired = isExpiredAt(endsAt, nowMs);
         counts[isExpired ? "expired" : "active"]++;
         return counts;
       },
       { active: 0, expired: 0 },
     );
   }, [bounties]);

---

62-92: Make the toggle an accessible tablist and add Arrow key navigation.
Improves screen reader and keyboard UX without changing visuals.

-      <div className="mb-6 grid grid-cols-2 gap-2">
+      <div
+        role="tablist"
+        aria-label="Bounties"
+        className="mb-6 grid grid-cols-2 gap-2"
+        onKeyDown={(e) => {
+          if (e.key === "ArrowLeft" || e.key === "ArrowRight") {
+            e.preventDefault();
+            const i = tabs.findIndex((t) => t.id === activeTab);
+            const next =
+              e.key === "ArrowLeft"
+                ? (i - 1 + tabs.length) % tabs.length
+                : (i + 1) % tabs.length;
+            setActiveTab(tabs[next].id);
+            document
+              .getElementById(`bounties-tab-${tabs[next].id}`)
+              ?.focus();
+          }
+        }}
+      >
         {tabs.map((tab) => {
           const isActive = activeTab === tab.id;
 
           return (
             <button
+              id={`bounties-tab-${tab.id}`}
+              role="tab"
+              aria-selected={isActive}
+              aria-controls="bounties-panel"
+              tabIndex={isActive ? 0 : -1}
               key={tab.id}
               type="button"
               className={cn(
                 "border-border-subtle flex flex-col gap-1 rounded-lg border p-4 text-left transition-colors duration-100",
                 isActive
                   ? "border-black ring-1 ring-black"
                   : "hover:bg-bg-muted",
               )}
               onClick={() => setActiveTab(tab.id)}
             >

---

93-131: Wrap content in a tabpanel and simplify the condition.
Improves a11y semantics and readability.

-      {filteredBounties?.length !== 0 || isLoading ? (
-        <div className="grid grid-cols-1 gap-6 md:grid-cols-2 xl:grid-cols-3">
+      <div
+        role="tabpanel"
+        id="bounties-panel"
+        aria-labelledby={`bounties-tab-${activeTab}`}
+      >
+      {filteredBounties.length > 0 || isLoading ? (
+        <div className="grid grid-cols-1 gap-6 md:grid-cols-2 xl:grid-cols-3">
           {filteredBounties?.length
             ? filteredBounties?.map((bounty) => (
                 <PartnerBountyCard key={bounty.id} bounty={bounty} />
               ))
             : Array.from({ length: 3 }, (_, index) => (
                 <PartnerBountyCardSkeleton key={index} />
               ))}
         </div>
       ) : (
         <AnimatedEmptyState
           title="No bounties to collect"
@@
         />
-      )}
+      )}
+      </div>

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-submission-details-sheet.tsx (3)

48-50: Post-approve navigation and reject callback wiring.
Passing onNext into useRejectBountySubmissionModal as onReject is appropriate; invoking onNext on approve success is consistent. Be aware that if onNext does not close the current sheet, you may end up with two sheets; consider closing first then navigating if that’s a risk in callers.

Also applies to: 59-61

---

154-180: Add accessible labels to icon-only header buttons.
The nav chevrons and close button are icon-only; add aria-label (and optionally title) for screen readers.

-              <Button
+              <Button
+                aria-label="Previous submission"
+                title="Previous (←)"
                 type="button"
                 disabled={!onPrevious}
                 onClick={onPrevious}
                 variant="secondary"
                 className="size-9 rounded-l-lg rounded-r-none p-0"
                 icon={<ChevronLeft className="size-3.5" />}
               />
-              <Button
+              <Button
+                aria-label="Next submission"
+                title="Next (→)"
                 type="button"
                 disabled={!onNext}
                 onClick={onNext}
                 variant="secondary"
                 className="-ml-px size-9 rounded-l-none rounded-r-lg p-0"
                 icon={<ChevronRight className="size-3.5" />}
               />
...
-              <Button
+              <Button
+                aria-label="Close"
+                title="Close"
                 variant="outline"
                 icon={<X className="size-5" />}
                 className="h-auto w-fit p-1"
               />

---

399-433: Approve button should be type="button"; shortcut labels look good.
Using type="submit" outside a form can cause accidental submits if nesting changes. Switch to button.

-                  <Button
-                    type="submit"
+                  <Button
+                    type="button"
                     variant="primary"
                     text="Approve"
                     shortcut="A"
                     loading={isApprovingBountySubmission}
                     onClick={() => setShowApproveBountySubmissionModal(true)}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: TWilson023
PR: dubinc/dub#2858
File: apps/web/ui/partners/partner-application-sheet.tsx:262-266
Timestamp: 2025-09-18T17:03:06.200Z
Learning: The useKeyboardShortcut hook with context options like {sheet: true, modal: true} requires ALL specified contexts to be present simultaneously. The shortcut will only trigger when both existingSheetBackdrop and existingModalBackdrop are present, using strict equality matching in the implementation.

apps/web/lib/api/bounties/get-bounty-submissions.ts (1)

35-36: Sorting still ignores other schema-allowed sortBy values. Map all, not just completedAt/performanceCount.

Requests for "leads", "conversions", "saleAmount", "commissions" won’t sort as expected. Provide an explicit mapping to real columns/relations.

-    orderBy: {
-      [sortBy === "completedAt" ? "completedAt" : "performanceCount"]:
-        sortOrder,
-    },
+    orderBy:
+      sortBy === "completedAt"
+        ? { completedAt: sortOrder }
+        : sortBy === "performanceCount"
+        ? { performanceCount: sortOrder }
+        : sortBy === "commissions"
+        ? { commission: { earnings: sortOrder } } // or "amount" if that’s the correct field
+        : sortBy === "saleAmount"
+        ? { commission: { amount: sortOrder } }
+        : sortBy === "leads"
+        ? { leads: sortOrder } // ensure this column exists or join/aggregate accordingly
+        : sortBy === "conversions"
+        ? { conversions: sortOrder } // ensure this column exists or join/aggregate accordingly
+        : { completedAt: sortOrder }, // sane default

If some fields aren’t on BountySubmission, either join/aggregate them here or remove them from the zod enum to keep schema and DB in sync. Based on learnings

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-submission-details-sheet.tsx (1)

74-75: Conflict: "A" opens modal and also confirms it → double-trigger risk.

With confirmShortcut: "a" (scoped { sheet: true, modal: true }) and a sheet-level "a" binding that opens the modal with { sheet: true }, pressing "A" while the confirm modal is open can trigger both handlers simultaneously. This causes double-triggering and potential duplicate actions.

Based on learnings.

Apply one of these fixes:

Option A (preferred): Change the modal confirm to Enter:

     confirmText: "Approve",
-    confirmShortcut: "a",
-    confirmShortcutOptions: { sheet: true, modal: true },
+    confirmShortcut: "Enter",
+    confirmShortcutOptions: { modal: true },

Option B: Change the sheet-level opener to a different key (e.g., Shift+A) or add a guard to check if the modal is already open before triggering.

Also applies to: 111-119

apps/web/app/(ee)/api/bounties/route.ts (2)

48-95: Constrain groupBy to fetched bountyIds; guard partner group filter against null.

• Today, groupBy scans all submissions in the program. For large programs, filter by the current bounty ids to cut I/O and CPU.
• Avoid passing a possibly null groupId into groups.some; compute it and include the clause only when present.

Apply this refactor:

-    const [bounties, allBountiesSubmissionsCount] = await Promise.all([
-      prisma.bounty.findMany({
+    const allowedGroupId =
+      programEnrollment?.groupId ??
+      programEnrollment?.program.defaultGroupId;
+
+    const bounties = await prisma.bounty.findMany({
         where: {
           programId,
           // Filter only bounties the specified partner is eligible for
           ...(programEnrollment && {
             OR: [
               {
                 groups: {
                   none: {},
                 },
               },
-              {
-                groups: {
-                  some: {
-                    groupId:
-                      programEnrollment.groupId ||
-                      programEnrollment.program.defaultGroupId,
-                  },
-                },
-              },
+              ...(allowedGroupId
+                ? [
+                    {
+                      groups: {
+                        some: {
+                          groupId: allowedGroupId,
+                        },
+                      },
+                    },
+                  ]
+                : []),
             ],
           }),
         },
         include: {
           groups: {
             select: {
               groupId: true,
             },
           },
         },
-      }),
-      includeSubmissionsCount
-        ? prisma.bountySubmission.groupBy({
-            by: ["bountyId", "status"],
-            where: {
-              programId,
-              status: {
-                in: ["submitted", "approved"],
-              },
-            },
-            _count: {
-              status: true,
-            },
-          })
-        : null,
-    ]);
+      });
+
+    const allBountiesSubmissionsCount = includeSubmissionsCount
+      ? await prisma.bountySubmission.groupBy({
+          by: ["bountyId", "status"],
+          where: {
+            programId,
+            bountyId: { in: bounties.map((b) => b.id) },
+            status: { in: ["submitted", "approved"] },
+          },
+          _count: { status: true },
+        })
+      : null;

Add/confirm an index to support the query:

• Prisma schema: @@index([programId, bountyId, status], name: "idx_bountySubmission_program_bounty_status")

---

96-118: Avoid O(B*S) by pre-aggregating into a Map.

Current approach filters and reduces for every bounty. Precompute once, then O(1) lookups.

Apply:

-    const aggregateSubmissionsCountForBounty = (bountyId: string) => {
-      if (!allBountiesSubmissionsCount) {
-        return null;
-      }
-      const bountySubmissions = allBountiesSubmissionsCount.filter(
-        (s) => s.bountyId === bountyId,
-      );
-      const total = bountySubmissions.reduce(
-        (sum, s) => sum + s._count.status,
-        0,
-      );
-      const submitted =
-        bountySubmissions.find((s) => s.status === "submitted")?._count
-          .status ?? 0;
-      const approved =
-        bountySubmissions.find((s) => s.status === "approved")?._count.status ??
-        0;
-      return {
-        total,
-        submitted,
-        approved,
-      };
-    };
+    const countsByBounty = new Map<
+      string,
+      { total: number; submitted: number; approved: number }
+    >();
+    if (allBountiesSubmissionsCount) {
+      for (const row of allBountiesSubmissionsCount) {
+        const cur =
+          countsByBounty.get(row.bountyId) ?? {
+            total: 0,
+            submitted: 0,
+            approved: 0,
+          };
+        cur.total += row._count.status;
+        if (row.status === "submitted") cur.submitted += row._count.status;
+        else if (row.status === "approved") cur.approved += row._count.status;
+        countsByBounty.set(row.bountyId, cur);
+      }
+    }
+
+    const aggregateSubmissionsCountForBounty = (bountyId: string) => {
+      if (!allBountiesSubmissionsCount) return null;
+      return (
+        countsByBounty.get(bountyId) ?? {
+          total: 0,
+          submitted: 0,
+          approved: 0,
+        }
+      );
+    };

apps/web/ui/partners/reject-bounty-submission-modal.tsx (1)

57-57: Use optional chaining for cleaner callback invocation.

Simplify to avoid a ternary.

-        onReject ? onReject() : null;
+        onReject?.();

apps/web/ui/layout/sidebar/partners-sidebar-nav.tsx (2)

287-290: Also return loading state from the hook to avoid “New” badge when count is 0.

Destructure isLoading from usePartnerProgramBounties so you can pass undefined while loading/not enrolled. This prevents showing “New” when there are actually 0 active bounties.

-  const { bountiesCount } = usePartnerProgramBounties({
+  const { bountiesCount, isLoading: bountiesLoading } = usePartnerProgramBounties({
     enabled: isEnrolledProgramPage,
   });

Then, couple with the change below (Line 311). Verify visually that badges render as intended across: loading, 0, small (<100), large (>=100).

---

311-312: Pass undefined while loading to align badge semantics.

So NAV_AREAS can treat undefined = “New”, 0 = no badge.

-        programBountiesCount: bountiesCount.active,
+        programBountiesCount: bountiesLoading ? undefined : bountiesCount.active,

Additionally (outside this diff), adjust NAV_AREAS badge logic to only show “New” when programBountiesCount is undefined:

badge:
  programBountiesCount === undefined
    ? "New"
    : programBountiesCount > 99
    ? "99+"
    : programBountiesCount || undefined

apps/web/lib/swr/use-partner-program-bounties.ts (1)

29-39: Compute “now” once per memo; avoid new Date() per item and use getTime().

Tiny perf/readability win for large lists.

-  const bountiesCount = useMemo(() => {
-    if (!bounties) return { active: 0, expired: 0 };
-    return bounties.reduce(
-      (counts, bounty) => {
-        const isExpired = bounty.endsAt && new Date(bounty.endsAt) < new Date();
-        counts[isExpired ? "expired" : "active"]++;
-        return counts;
-      },
-      { active: 0, expired: 0 },
-    );
-  }, [bounties]);
+  const bountiesCount = useMemo(() => {
+    if (!bounties) return { active: 0, expired: 0 };
+    const now = Date.now();
+    return bounties.reduce(
+      (counts, bounty) => {
+        const isExpired =
+          bounty.endsAt && new Date(bounty.endsAt).getTime() < now;
+        counts[isExpired ? "expired" : "active"]++;
+        return counts;
+      },
+      { active: 0, expired: 0 },
+    );
+  }, [bounties]);

apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/bounties/partner-bounty-card.tsx (1)

25-30: Add aria-disabled for better a11y on disabled button.

Button is disabled visually and functionally; aria-disabled improves screen reader clarity.

-      <button
+      <button
         type="button"
         onClick={() => setShowClaimBountyModal(true)}
         disabled={expiredBounty}
+        aria-disabled={expiredBounty}
         className={cn(
           "border-border-subtle group relative flex cursor-pointer flex-col gap-5 overflow-hidden rounded-xl border bg-white p-5 text-left",
           expiredBounty
             ? "cursor-not-allowed"
             : "hover:border-border-default transition-all hover:shadow-lg",
         )}
       >

Also applies to: 37-43, 55-58, 73-80

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/bounty-action-button.tsx (1)

115-119: A11y: label the icon-only button

Add an accessible label and title.

-          <Button
+          <Button
             type="button"
             className={buttonClassName || "w-auto px-1.5"}
             variant="secondary"
             icon={<ThreeDots className="h-4 w-4 shrink-0" />}
+            aria-label="Bounty actions"
+            title="Bounty actions"
           />

apps/web/lib/api/bounties/get-bounty-with-details.ts (1)

81-96: Tighten types for groups

Explicitly type the parsed groups to avoid any and skip the null filter if JSON_ARRAY() default is guaranteed.

-    groups: bounty.groups.filter((group) => group !== null) ?? [],
+    groups: (bounty.groups as Array<{ id: string }> | null) ?? [],

apps/web/app/(ee)/partners.dub.co/(dashboard)/programs/[programSlug]/(enrolled)/bounties/page-client.tsx (1)

51-63: A11y: Tabs should expose pressed/selected state

Expose ARIA to assistive tech.

             <button
               key={tab.id}
               type="button"
               className={cn(
                 "border-border-subtle flex flex-col gap-1 rounded-lg border p-4 text-left transition-colors duration-100",
                 isActive
                   ? "border-black ring-1 ring-black"
                   : "hover:bg-bg-muted",
               )}
+              role="tab"
+              aria-selected={isActive}
+              aria-controls={`panel-${tab.id}`}
               onClick={() => setActiveTab(tab.id)}
             >

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/bounty-card.tsx (1)

55-61: Prevent badge overlap with “Ended” badge

Both badges render at left-2 top-2; they’ll overlap when a bounty ended but still has submitted items.

-    <div className="absolute left-2 top-2 z-10">
+    <div className="absolute left-2 top-8 z-10">

Or conditionally hide submissions badge when ended.

apps/web/lib/zod/schemas/bounties.ts (1)

107-115: Consider making submissionsCountData non-optional with a default

Removes many optional chains in UI and ensures a stable shape.

-export const BountyListSchema = BountySchema.extend({
-  submissionsCountData: z
-    .object({
-      total: z.number().default(0),
-      submitted: z.number().default(0),
-      approved: z.number().default(0),
-    })
-    .optional(),
-});
+export const BountyListSchema = BountySchema.extend({
+  submissionsCountData: z
+    .object({
+      total: z.number().default(0),
+      submitted: z.number().default(0),
+      approved: z.number().default(0),
+    })
+    .default({ total: 0, submitted: 0, approved: 0 }),
+});

apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-submissions-table.tsx (1)

249-249: Inconsistent column identifier naming.

The column id is "performanceCount" but it's conditionally added based on showColumns.includes("performanceMetrics"). This naming mismatch creates unnecessary confusion.

Apply this diff to align the naming:

-              id: "performanceCount",
+              id: "performanceMetrics",

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: devkiran
PR: dubinc/dub#2736
File: apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/bounties/[bountyId]/bounty-info.tsx:45-56
Timestamp: 2025-08-25T17:39:38.965Z
Learning: In the bounty system, each partner can only submit to the same bounty once. This means totalSubmissions (pending + approved + rejected) equals the number of unique partners who have submitted, making UI text like "X of Y partners completed" accurate when using totalSubmissions.

Learnt from: TWilson023
PR: dubinc/dub#2858
File: apps/web/ui/partners/partner-application-sheet.tsx:262-266
Timestamp: 2025-09-18T17:03:06.200Z
Learning: The useKeyboardShortcut hook with context options like {sheet: true, modal: true} requires ALL specified contexts to be present simultaneously. The shortcut will only trigger when both existingSheetBackdrop and existingModalBackdrop are present, using strict equality matching in the implementation.