From c1510394cb88d6f7a05cf8828381d2833a71cd4d Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 09:59:43 -0700
Subject: [PATCH 01/23] Create new tests

---
 .../v1/old-name/create-purchase-url.test.ts   | 317 ++++++
 .../endpoints/api/v1/old-name/items.test.ts   | 472 +++++++++
 .../api/v1/old-name/purchase-session.test.ts  | 917 ++++++++++++++++++
 .../api/v1/old-name/validate-code.test.ts     | 254 +++++
 4 files changed, 1960 insertions(+)
 create mode 100644 apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts
 create mode 100644 apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
 create mode 100644 apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts
 create mode 100644 apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts

diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts
new file mode 100644
index 0000000000..c09c22c5ac
--- /dev/null
+++ b/apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts
@@ -0,0 +1,317 @@
+import { it } from "../../../../../helpers";
+import { Auth, Project, User, niceBackendFetch, Payments } from "../../../../backend-helpers";
+import { generateUuid } from "@stackframe/stack-shared/dist/utils/uuids";
+
+it("should not be able to create purchase URL without offer_id or offer_inline", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: generateUuid(),
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+      NiceResponse {
+        "status": 400,
+        "body": "Must specify either offer_id or offer_inline!",
+        "headers": Headers { <some fields may have been hidden> },
+      }
+    `);
+});
+
+it("should error for non-existent offer_id", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            "monthly": {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: generateUuid(),
+      offer_id: "non-existent-offer",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+      NiceResponse {
+        "status": 400,
+        "body": {
+          "code": "OFFER_DOES_NOT_EXIST",
+          "details": {
+            "access_type": "client",
+            "offer_id": "non-existent-offer",
+          },
+          "error": "Offer with ID \\"non-existent-offer\\" does not exist or you don't have permissions to access it.",
+        },
+        "headers": Headers {
+          "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+          <some fields may have been hidden>,
+        },
+      }
+    `);
+});
+
+it("should error for invalid customer_id", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            "monthly": {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  await Auth.Otp.signIn();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "team",
+      customer_id: generateUuid(),
+      offer_id: "test-offer",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": {
+        "code": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "details": {
+          "actual_customer_type": "team",
+          "customer_id": "<stripped UUID>",
+          "offer_customer_type": "user",
+          "offer_id": "test-offer",
+        },
+        "error": "The team with ID \\"<stripped UUID>\\" is not a valid customer for the inline offer that has been passed in. The offer is configured to only be available for user customers, but the customer is a team.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("should error for no connected stripe account", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            "monthly": {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: user.userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+      NiceResponse {
+        "status": 400,
+        "body": "Payments are not set up in this Stack Auth project. Please go to the Stack Auth dashboard and complete the Payments onboarding.",
+        "headers": Headers { <some fields may have been hidden> },
+      }
+    `);
+});
+
+
+it("should not allow offer_inline when calling from client", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+
+  const { userId } = await Auth.Otp.signIn();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_inline: {
+        display_name: "Inline Test Offer",
+        customer_type: "user",
+        server_only: true,
+        prices: {
+          "monthly": {
+            USD: "1000",
+            interval: [1, "month"],
+          },
+        },
+        included_items: {},
+      },
+    },
+  });
+  expect(response.body).toMatchInlineSnapshot(`"Cannot specify offer_inline when calling from client! Please call with a server API key, or use the offer_id parameter."`);
+});
+
+it("should error for server-only offer when calling from client", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: true,
+          stackable: false,
+          prices: {
+            "monthly": {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": {
+        "code": "OFFER_DOES_NOT_EXIST",
+        "details": {
+          "access_type": "client",
+          "offer_id": "test-offer",
+        },
+        "error": "Offer with ID \\"test-offer\\" does not exist or you don't have permissions to access it.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("should allow offer_inline when calling from server", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+
+  const { userId } = await Auth.Otp.signIn();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "server",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_inline: {
+        display_name: "Inline Test Offer",
+        customer_type: "user",
+        server_only: true,
+        prices: {
+          "monthly": {
+            USD: "1000",
+            interval: [1, "month"],
+          },
+        },
+        included_items: {},
+      },
+    },
+  });
+  expect(response.status).toBe(200);
+  expect(response.body.url).toMatch(/^https?:\/\/localhost:8101\/purchase\/[a-z0-9-_]+$/);
+});
+
+it("should allow valid offer_id", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            "monthly": {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(response.status).toBe(200);
+  const body = response.body as { url: string };
+  expect(body.url).toMatch(/^https?:\/\/localhost:8101\/purchase\/[a-z0-9-_]+$/);
+});
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
new file mode 100644
index 0000000000..793b462a65
--- /dev/null
+++ b/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
@@ -0,0 +1,472 @@
+import { describe, expect } from "vitest";
+import { it } from "../../../../../helpers";
+import { Auth, InternalProjectKeys, Project, User, backendContext, createMailbox, niceBackendFetch } from "../../../../backend-helpers";
+
+async function updateConfig(config: any) {
+  const response = await niceBackendFetch(`/api/latest/internal/config/override`, {
+    accessType: "admin",
+    method: "PATCH",
+    body: { config_override_string: JSON.stringify(config) },
+  });
+  expect(response.status).toBe(200);
+}
+
+describe("without authentication", () => {
+  it("should not be able to get item without access type", async ({ expect }) => {
+    await Project.createAndSwitch();
+
+    const response = await niceBackendFetch("/api/latest/payments/items/user/user-123/test-item");
+    expect(response).toMatchInlineSnapshot(`
+        NiceResponse {
+          "status": 400,
+          "body": {
+            "code": "ACCESS_TYPE_REQUIRED",
+            "error": deindent\`
+              You must specify an access level for this Stack project. Make sure project API keys are provided (eg. x-stack-publishable-client-key) and you set the x-stack-access-type header to 'client', 'server', or 'admin'.
+              
+              For more information, see the docs on REST API authentication: https://docs.stack-auth.com/rest-api/overview#authentication
+            \`,
+          },
+          "headers": Headers {
+            "x-stack-known-error": "ACCESS_TYPE_REQUIRED",
+            <some fields may have been hidden>,
+          },
+        }
+      `);
+  });
+});
+
+it("should be able to get item information with valid customer and item IDs", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(response).toMatchInlineSnapshot(`
+        NiceResponse {
+          "status": 200,
+          "body": {
+            "display_name": "Test Item",
+            "id": "test-item",
+            "quantity": 0,
+          },
+          "headers": Headers { <some fields may have been hidden> },
+        }
+      `);
+});
+
+it("should return ItemNotFound error for non-existent item", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/non-existent-item`, {
+    accessType: "client",
+  });
+  expect(response).toMatchInlineSnapshot(`
+        NiceResponse {
+          "status": 404,
+          "body": {
+            "code": "ITEM_NOT_FOUND",
+            "details": { "item_id": "non-existent-item" },
+            "error": "Item with ID \\\"non-existent-item\\\" not found.",
+          },
+          "headers": Headers {
+            "x-stack-known-error": "ITEM_NOT_FOUND",
+            <some fields may have been hidden>,
+          },
+        }
+      `);
+});
+
+it("should return ItemCustomerTypeDoesNotMatch error for user accessing team item", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "team",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(response).toMatchInlineSnapshot(`
+      NiceResponse {
+        "status": 400,
+        "body": {
+          "code": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
+          "details": {
+            "actual_customer_type": "user",
+            "customer_id": "<stripped UUID>",
+            "item_customer_type": "team",
+            "item_id": "test-item",
+          },
+          "error": "The user with ID \\"<stripped UUID>\\" is not a valid customer for the item with ID \\"test-item\\". The item is configured to only be available for team customers, but the customer is a user.",
+        },
+        "headers": Headers {
+          "x-stack-known-error": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
+          <some fields may have been hidden>,
+        },
+      }
+    `);
+});
+
+it("creates an item quantity change and returns id", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      delta: 3,
+      description: "manual grant",
+    },
+  });
+
+  expect(response.status).toBe(200);
+  expect(response.body).toMatchObject({ id: expect.any(String) });
+});
+
+it("aggregates item quantity changes in item quantity", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  const post1 = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: 2 },
+  });
+  expect(post1.status).toBe(200);
+
+  const get1 = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(get1.status).toBe(200);
+  expect(get1.body.quantity).toBe(2);
+});
+
+it("ignores expired changes", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  const post = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: 4, expires_at: new Date(Date.now() - 1000).toISOString() },
+  });
+  expect(post.status).toBe(200);
+
+  const get = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(get.status).toBe(200);
+  expect(get.body.quantity).toBe(0);
+});
+
+it("sums multiple non-expired changes", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  for (const q of [2, -1, 5]) {
+    const r = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
+      method: "POST",
+      accessType: "admin",
+      body: { delta: q },
+    });
+    expect(r.status).toBe(200);
+  }
+
+  const get = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(get.status).toBe(200);
+  expect(get.body.quantity).toBe(6);
+});
+
+it("validates item and customer type", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "team-item": {
+          displayName: "Team Item",
+          customerType: "team",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/team-item/update-quantity?allow_negative=true`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: 1 },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": {
+        "code": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "details": {
+          "actual_customer_type": "user",
+          "customer_id": "<stripped UUID>",
+          "item_customer_type": "team",
+          "item_id": "team-item",
+        },
+        "error": "The user with ID \\"<stripped UUID>\\" is not a valid customer for the item with ID \\"team-item\\". The item is configured to only be available for team customers, but the customer is a user.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("should error when deducting more quantity than available", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: -1 },
+  });
+
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": {
+        "code": "ITEM_QUANTITY_INSUFFICIENT_AMOUNT",
+        "details": {
+          "customer_id": "<stripped UUID>",
+          "item_id": "test-item",
+          "quantity": -1,
+        },
+        "error": "The item with ID \\"test-item\\" has an insufficient quantity for the customer with ID \\"<stripped UUID>\\". An attempt was made to charge -1 credits.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "ITEM_QUANTITY_INSUFFICIENT_AMOUNT",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("allows team admins to be added when item quantity is increased", async ({ expect }) => {
+  backendContext.set({ projectKeys: InternalProjectKeys });
+  await Auth.Otp.signIn();
+  const { createProjectResponse } = await Project.create();
+  const ownerTeamId: string = createProjectResponse.body.owner_team_id;
+
+  await niceBackendFetch(`/api/v1/payments/items/team/${ownerTeamId}/dashboard_admins/update-quantity?allow_negative=true`, {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      delta: 1,
+    },
+  });
+
+  const mailboxB = createMailbox();
+  const sendInvitationResponse = await niceBackendFetch("/api/v1/team-invitations/send-code", {
+    method: "POST",
+    accessType: "server",
+    body: {
+      email: mailboxB.emailAddress,
+      team_id: ownerTeamId,
+      callback_url: "http://localhost:12345/some-callback-url",
+    },
+  });
+  expect(sendInvitationResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {
+        "id": "<stripped UUID>",
+        "success": true,
+      },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+
+  backendContext.set({ mailbox: mailboxB });
+  await Auth.Otp.signIn();
+
+  const acceptResponse = await niceBackendFetch("/api/v1/team-invitations/accept", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      code: (await mailboxB.fetchMessages()).findLast((m) => m.subject.includes("join"))?.body?.text.match(/http:\/\/localhost:12345\/some-callback-url\?code=([a-zA-Z0-9]+)/)?.[1],
+    },
+  });
+
+  expect(acceptResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {},
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should allow negative quantity changes when allow_negative is true", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+    },
+  });
+
+  const user = await User.create();
+
+  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=true`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: -3 },
+  });
+
+  expect(response.status).toBe(200);
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "id": "<stripped UUID>" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+
+  const getItemResponse = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(getItemResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {
+        "display_name": "Test Item",
+        "id": "test-item",
+        "quantity": -3,
+      },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("supports custom customer type for items (GET and update-quantity)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await updateConfig({
+    payments: {
+      items: {
+        "custom-item": {
+          displayName: "Custom Item",
+          customerType: "custom",
+        },
+      },
+    },
+  });
+
+  const customCustomerId = "custom-xyz";
+
+  const getBefore = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item`, {
+    accessType: "client",
+  });
+  expect(getBefore.status).toBe(200);
+  expect(getBefore.body.quantity).toBe(0);
+
+  const postChange = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item/update-quantity?allow_negative=false`, {
+    method: "POST",
+    accessType: "admin",
+    body: { delta: 3, description: "grant" },
+  });
+  expect(postChange.status).toBe(200);
+
+  const getAfter = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item`, {
+    accessType: "client",
+  });
+  expect(getAfter.status).toBe(200);
+  expect(getAfter.body.quantity).toBe(3);
+});
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts
new file mode 100644
index 0000000000..9c028e6007
--- /dev/null
+++ b/apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts
@@ -0,0 +1,917 @@
+import { it } from "../../../../../helpers";
+import { Auth, Payments, Project, User, niceBackendFetch } from "../../../../backend-helpers";
+
+it("should error on invalid code", async ({ expect }) => {
+  await Project.createAndSwitch();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: "invalid-code",
+      price_id: "monthly",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 404,
+      "body": {
+        "code": "VERIFICATION_CODE_NOT_FOUND",
+        "error": "The verification code does not exist for this project.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "VERIFICATION_CODE_NOT_FOUND",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("should error on invalid price_id", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "invalid-price-id",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "Price not found on offer associated with this purchase code",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should properly create subscription", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should return client secret for one-time price (no interval)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "ot-offer": {
+          displayName: "One Time Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: true,
+          prices: {
+            one: {
+              USD: "1500",
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "ot-offer",
+    },
+  });
+  expect(urlRes.status).toBe(200);
+  const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
+
+  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "one",
+      quantity: 2,
+    },
+  });
+  expect(res.status).toBe(200);
+  expect(res.body).toEqual({ client_secret: expect.any(String) });
+});
+
+it("should error on one-time price quantity > 1 when offer is not stackable", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "ot-non-stack": {
+          displayName: "One Time Non-Stackable",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            one: { USD: "1200" },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "ot-non-stack",
+    },
+  });
+  expect(urlRes.status).toBe(200);
+  const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
+
+  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "one",
+      quantity: 2,
+    },
+  });
+  expect(res).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "This offer is not stackable; quantity must be 1",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should return client secret for one-time price even if a conflicting group subscription exists (DB-only)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      groups: { grp: { displayName: "Test Group" } },
+      offers: {
+        subOffer: {
+          displayName: "Sub Offer",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: { monthly: { USD: "1000", interval: [1, "month"] } },
+          includedItems: {},
+        },
+        oneTime: {
+          displayName: "One Time",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: true,
+          prices: { one: { USD: "500" } },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+
+  // Create test-mode DB-only subscription for subOffer
+  const createUrlRespA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "subOffer",
+    },
+  });
+  expect(createUrlRespA.status).toBe(200);
+  const codeA = (createUrlRespA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
+  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: { full_code: codeA, price_id: "monthly", quantity: 1 },
+  });
+  expect(testModeRes.status).toBe(200);
+
+  // Now purchase one-time offer in same group; should succeed and return client secret
+  const createUrlRespB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "oneTime",
+    },
+  });
+  expect(createUrlRespB.status).toBe(200);
+  const codeB = (createUrlRespB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
+
+  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: codeB, price_id: "one", quantity: 1 },
+  });
+  expect(res).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "pi_1PgafyB7WZ01zgkWSjxsAJo3_secret_Dm43xiq1k0ywrRRjDoi8y1gkM" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("test-mode should error on one-time price quantity > 1 when offer is not stackable", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        tmOneTime: {
+          displayName: "TM One Time",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: { one: { USD: "800" } },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "tmOneTime" },
+  });
+  expect(urlRes.status).toBe(200);
+  const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
+
+  const res = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: { full_code: code, price_id: "one", quantity: 2 },
+  });
+  expect(res).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "This offer is not stackable; quantity must be 1",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should create purchase URL, validate code, and create purchase session", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+      quantity: 2,
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "This offer is not stackable; quantity must be 1",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should create purchase URL with inline offer, validate code, and create purchase session", async ({ expect }) => {
+  await Project.createAndSwitch({ config: { magic_link_enabled: true } });
+  await Payments.setup();
+
+  const { userId } = await Auth.Otp.signIn();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "server",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_inline: {
+        display_name: "Inline Test Offer",
+        customer_type: "user",
+        server_only: true,
+        prices: {
+          "monthly-test": {
+            USD: "1000",
+            interval: [1, "month"],
+          },
+        },
+        included_items: {},
+      },
+    },
+  });
+  expect(response.status).toBe(200);
+  const body = response.body as { url: string };
+  expect(body.url).toMatch(/^https?:\/\/localhost:8101\/purchase\/[a-z0-9-_]+$/);
+  const codeMatch = body.url.match(/\/purchase\/([a-z0-9-_]+)/);
+  const code = codeMatch ? codeMatch[1] : undefined;
+  expect(code).toBeDefined();
+
+  const purchaseSessionResponse = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "monthly-test",
+    },
+  });
+  expect(purchaseSessionResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should error when admin tenancy differs from code tenancy", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  await Project.createAndSwitch();
+
+  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+    },
+  });
+
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "Tenancy id does not match value from code data",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("creates subscription in test mode and increases included item quantity", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {
+            "test-item": { quantity: 2 },
+          },
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const createUrlResponse = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(createUrlResponse.status).toBe(200);
+  const body = createUrlResponse.body as { url: string };
+  const codeMatch = body.url.match(/\/purchase\/([a-z0-9-_]+)/);
+  const code = codeMatch ? codeMatch[1] : undefined;
+  expect(code).toBeDefined();
+
+  const getBefore = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(getBefore.status).toBe(200);
+  expect(getBefore.body.quantity).toBe(0);
+
+  const purchaseSessionResponse = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+    },
+  });
+  expect(purchaseSessionResponse.status).toBe(200);
+  expect(purchaseSessionResponse.body).toEqual({ success: true });
+
+  const getAfter = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(getAfter.status).toBe(200);
+  expect(getAfter.body.quantity).toBe(2);
+});
+
+it("test-mode should error when access type is not admin", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 401,
+      "body": {
+        "code": "INSUFFICIENT_ACCESS_TYPE",
+        "details": {
+          "actual_access_type": "client",
+          "allowed_access_types": ["admin"],
+        },
+        "error": "The x-stack-access-type header must be 'admin', but was 'client'.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "INSUFFICIENT_ACCESS_TYPE",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("test-mode should error on invalid code", async ({ expect }) => {
+  await Project.createAndSwitch();
+  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: "invalid-code",
+      price_id: "monthly",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 404,
+      "body": {
+        "code": "VERIFICATION_CODE_NOT_FOUND",
+        "error": "The verification code does not exist for this project.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "VERIFICATION_CODE_NOT_FOUND",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("test-mode should error on invalid price_id", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: code,
+      price_id: "invalid-price-id",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "Price not found on offer associated with this purchase code",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("allows stackable quantity in test mode and multiplies included items", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      items: {
+        "test-item": {
+          displayName: "Test Item",
+          customerType: "user",
+        },
+      },
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: true,
+          prices: {
+            monthly: {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {
+            "test-item": { quantity: 2 },
+          },
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  const createUrlResponse = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(createUrlResponse.status).toBe(200);
+  const body = createUrlResponse.body as { url: string };
+  const codeMatch = body.url.match(/\/purchase\/([a-z0-9-_]+)/);
+  const code = codeMatch ? codeMatch[1] : undefined;
+  expect(code).toBeDefined();
+
+  const getBefore = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(getBefore.status).toBe(200);
+  expect(getBefore.body.quantity).toBe(0);
+
+  const purchaseSessionResponse = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: code,
+      price_id: "monthly",
+      quantity: 3,
+    },
+  });
+  expect(purchaseSessionResponse.status).toBe(200);
+  expect(purchaseSessionResponse.body).toEqual({ success: true });
+
+  const getAfter = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+    accessType: "client",
+  });
+  expect(getAfter.status).toBe(200);
+  expect(getAfter.body.quantity).toBe(6);
+});
+
+it("should update existing stripe subscription when switching offers within a group (non test-mode)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      groups: {
+        grp: { displayName: "Test Group" },
+      },
+      offers: {
+        offerA: {
+          displayName: "Offer A",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+        offerB: {
+          displayName: "Offer B",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "2000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+
+  // First purchase: Offer A
+  const createUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "offerA",
+    },
+  });
+  expect(createUrlA.status).toBe(200);
+  const codeA = (createUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeA).toBeDefined();
+
+  const purchaseA = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: codeA,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(purchaseA).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+
+  // Second purchase: Offer B in same group (should update existing Stripe subscription)
+  const createUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "offerB",
+    },
+  });
+  expect(createUrlB.status).toBe(200);
+  const codeB = (createUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeB).toBeDefined();
+
+  const purchaseB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: codeB,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(purchaseB).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should cancel DB-only subscription then create Stripe subscription when switching from test-mode (same group)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      groups: {
+        grp: { displayName: "Test Group" },
+      },
+      offers: {
+        offerA: {
+          displayName: "Offer A",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+        offerB: {
+          displayName: "Offer B",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "2000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+
+  // Create test-mode DB-only subscription for offerA
+  const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "offerA",
+    },
+  });
+  expect(resUrlA.status).toBe(200);
+  const codeA = (resUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeA).toBeDefined();
+
+  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: codeA,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(testModeRes.status).toBe(200);
+
+  // Now purchase offerB in non test-mode; should cancel DB-only sub and create Stripe subscription
+  const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "offerB",
+    },
+  });
+  expect(resUrlB.status).toBe(200);
+  const codeB = (resUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeB).toBeDefined();
+
+  const purchaseB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: codeB,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(purchaseB).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": { "client_secret": "" },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should block one-time purchase for same offer after prior one-time purchase (test-mode persisted)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        ot: {
+          displayName: "One Time Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: true,
+          prices: { one: { USD: "500" } },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  // First: create code and complete in TEST_MODE (persists OneTimePurchase)
+  const createUrl1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
+  });
+  expect(createUrl1.status).toBe(200);
+  const code1 = (createUrl1.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(code1).toBeDefined();
+
+  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: { full_code: code1, price_id: "one", quantity: 1 },
+  });
+  expect(testModeRes.status).toBe(200);
+
+  // Second: attempt another purchase for same offer (should be blocked by OneTimePurchase)
+  const createUrl2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
+  });
+  expect(createUrl2.status).toBe(200);
+  const code2 = (createUrl2.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(code2).toBeDefined();
+
+  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: code2, price_id: "one", quantity: 1 },
+  });
+  expect(res.status).toBe(400);
+  expect(String(res.body)).toContain("one-time purchase for this offer");
+});
+
+it("should block one-time purchase in same group after prior one-time purchase in that group (test-mode persisted)", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      groups: { grp: { displayName: "Group" } },
+      offers: {
+        offerA: {
+          displayName: "Offer A",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: true,
+          prices: { one: { USD: "500" } },
+          includedItems: {},
+        },
+        offerB: {
+          displayName: "Offer B",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: true,
+          prices: { one: { USD: "700" } },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  // Purchase offerA in TEST_MODE (persists OneTimePurchase)
+  const urlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
+  });
+  expect(urlA.status).toBe(200);
+  const codeA = (urlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeA).toBeDefined();
+
+  const tmRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: { full_code: codeA, price_id: "one", quantity: 1 },
+  });
+  expect(tmRes.status).toBe(200);
+
+  // Attempt to purchase offerB in same group (should be blocked)
+  const urlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
+  });
+  expect(urlB.status).toBe(200);
+  const codeB = (urlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeB).toBeDefined();
+
+  const resB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: codeB, price_id: "one", quantity: 1 },
+  });
+  expect(resB.status).toBe(400);
+  expect(String(resB.body)).toContain("one-time purchase in this offer group");
+});
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts
new file mode 100644
index 0000000000..7b78026a63
--- /dev/null
+++ b/apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts
@@ -0,0 +1,254 @@
+import { it } from "../../../../../helpers";
+import { Payments, Project, User, niceBackendFetch } from "../../../../backend-helpers";
+
+
+it("should error on invalid code", async ({ expect }) => {
+  await Project.createAndSwitch();
+  const response = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      full_code: "invalid-code",
+    },
+  });
+  expect(response).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 404,
+      "body": {
+        "code": "VERIFICATION_CODE_NOT_FOUND",
+        "error": "The verification code does not exist for this project.",
+      },
+      "headers": Headers {
+        "x-stack-known-error": "VERIFICATION_CODE_NOT_FOUND",
+        <some fields may have been hidden>,
+      },
+    }
+  `);
+});
+
+it("should allow valid code and return offer data", async ({ expect }) => {
+  const { code } = await Payments.createPurchaseUrlAndGetCode();
+  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: code },
+  });
+  expect(validateResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {
+        "already_bought_non_stackable": false,
+        "conflicting_group_offers": [],
+        "offer": {
+          "customer_type": "user",
+          "display_name": "Test Offer",
+          "prices": {
+            "monthly": {
+              "USD": "1000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
+        "project_id": "<stripped UUID>",
+        "stripe_account_id": <stripped field 'stripe_account_id'>,
+      },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should set already_bought_non_stackable when user already owns non-stackable offer", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      offers: {
+        "test-offer": {
+          displayName: "Test Offer",
+          customerType: "user",
+          serverOnly: false,
+          stackable: false,
+          prices: {
+            monthly: {
+              USD: "1000",
+              interval: [1, "month"],
+            },
+          },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+  // Create a code for test-offer and purchase it in test mode (creates DB subscription)
+  const createUrlRes1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(createUrlRes1.status).toBe(200);
+  const code1 = (createUrlRes1.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(code1).toBeDefined();
+
+  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: {
+      full_code: code1,
+      price_id: "monthly",
+      quantity: 1,
+    },
+  });
+  expect(testModeRes.status).toBe(200);
+
+  // Create a second code for the same offer and validate; should report already_bought_non_stackable
+  const createUrlRes2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: {
+      customer_type: "user",
+      customer_id: userId,
+      offer_id: "test-offer",
+    },
+  });
+  expect(createUrlRes2.status).toBe(200);
+  const code2 = (createUrlRes2.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(code2).toBeDefined();
+
+  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: code2 },
+  });
+  expect(validateResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {
+        "already_bought_non_stackable": true,
+        "conflicting_group_offers": [],
+        "offer": {
+          "customer_type": "user",
+          "display_name": "Test Offer",
+          "prices": {
+            "monthly": {
+              "USD": "1000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
+        "project_id": "<stripped UUID>",
+        "stripe_account_id": <stripped field 'stripe_account_id'>,
+      },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});
+
+it("should include conflicting_group_offers when switching within the same group", async ({ expect }) => {
+  await Project.createAndSwitch();
+  await Payments.setup();
+  await Project.updateConfig({
+    payments: {
+      groups: { grp: { displayName: "Group" } },
+      offers: {
+        offerA: {
+          displayName: "Offer A",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: { monthly: { USD: "1000", interval: [1, "month"] } },
+          includedItems: {},
+        },
+        offerB: {
+          displayName: "Offer B",
+          customerType: "user",
+          serverOnly: false,
+          groupId: "grp",
+          stackable: false,
+          prices: { monthly: { USD: "2000", interval: [1, "month"] } },
+          includedItems: {},
+        },
+      },
+    },
+  });
+
+  const { userId } = await User.create();
+
+  // Subscribe to offerA in test mode
+  const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
+  });
+  expect(resUrlA.status).toBe(200);
+  const codeA = (resUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeA).toBeDefined();
+
+  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+    method: "POST",
+    accessType: "admin",
+    body: { full_code: codeA, price_id: "monthly", quantity: 1 },
+  });
+  expect(testModeRes.status).toBe(200);
+
+  // Now validate code for offerB; should report conflict with offerA
+  const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+    method: "POST",
+    accessType: "client",
+    body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
+  });
+  expect(resUrlB.status).toBe(200);
+  const codeB = (resUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
+  expect(codeB).toBeDefined();
+
+  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+    method: "POST",
+    accessType: "client",
+    body: { full_code: codeB },
+  });
+  expect(validateResponse).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 200,
+      "body": {
+        "already_bought_non_stackable": false,
+        "conflicting_group_offers": [
+          {
+            "display_name": "Offer A",
+            "offer_id": "offerA",
+          },
+        ],
+        "offer": {
+          "customer_type": "user",
+          "display_name": "Offer B",
+          "prices": {
+            "monthly": {
+              "USD": "2000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
+        "project_id": "<stripped UUID>",
+        "stripe_account_id": <stripped field 'stripe_account_id'>,
+      },
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
+});

From e162ec4c677ce285b5c7a4c56d683dd5c0963429 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 10:03:24 -0700
Subject: [PATCH 02/23] s/offer/product

---
 apps/backend/prisma/schema.prisma             |   8 +-
 apps/backend/prisma/seed.ts                   |   2 +-
 .../integrations/stripe/webhooks/route.tsx    |  10 +-
 .../test-mode-purchase-session/route.tsx      |  12 +-
 .../internal/payments/transactions/route.tsx  |  22 +-
 .../purchases/create-purchase-url/route.ts    |  18 +-
 .../purchases/purchase-session/route.tsx      |  18 +-
 .../payments/purchases/validate-code/route.ts |  50 +--
 .../purchases/verification-code-handler.tsx   |   6 +-
 apps/backend/src/lib/payments.test.tsx        | 116 ++---
 apps/backend/src/lib/payments.tsx             | 154 +++----
 apps/backend/src/lib/stripe.tsx               |   6 +-
 .../projects/page-client.tsx                  |   2 +-
 .../payments/offers/create-group-dialog.tsx   |   4 +-
 .../payments/offers/dummy-data.tsx            |   2 +-
 .../payments/offers/included-item-dialog.tsx  |  12 +-
 .../payments/offers/offer-dialog.tsx          | 170 +++----
 .../offers/page-client-catalogs-view.tsx      | 422 +++++++++---------
 .../payments/offers/page-client-list-view.tsx | 344 +++++++-------
 .../payments/offers/price-dialog.tsx          |   8 +-
 .../projects/[projectId]/payments/page.tsx    |   2 +-
 .../projects/[projectId]/sidebar-layout.tsx   |  68 +--
 .../[projectId]/workflows/workflow-list.tsx   |   2 +-
 .../(main)/purchase/[code]/page-client.tsx    |  42 +-
 .../data-table/payment-item-table.tsx         |   8 +-
 .../data-table/payment-offer-table.tsx        |  32 +-
 .../data-table/transaction-table.tsx          |   8 +-
 .../payments/create-checkout-dialog.tsx       |  32 +-
 .../src/components/payments/offer-dialog.tsx  |  30 +-
 .../src/components/payments/price-editor.tsx  |  12 +-
 apps/e2e/tests/backend/backend-helpers.ts     |   8 +-
 .../api/v1/internal/transactions.test.ts      |  30 +-
 .../v1/payments/create-purchase-url.test.ts   |  94 ++--
 .../api/v1/payments/purchase-session.test.ts  | 138 +++---
 .../api/v1/payments/validate-code.test.ts     |  60 +--
 .../endpoints/api/v1/stripe-webhooks.test.ts  |  44 +-
 docs/src/app/api/chat/route.ts                |   2 +-
 docs/templates-api/overview.mdx               |   2 +-
 docs/templates/concepts/user-onboarding.mdx   |   2 +-
 .../customization/internationalization.mdx    |   2 +-
 .../customization/page-examples/sign-in.mdx   |   2 +-
 .../customization/page-examples/sign-up.mdx   |   2 +-
 docs/templates/others/self-host.mdx           |   2 +-
 docs/templates/overview.mdx                   |   2 +-
 docs/templates/rest-api/overview.mdx          |   2 +-
 examples/e-commerce/src/app/page.tsx          |   4 +-
 packages/stack-shared/src/config/schema.ts    |  26 +-
 .../src/interface/client-interface.ts         |  12 +-
 .../src/interface/crud/transactions.ts        |   6 +-
 packages/stack-shared/src/known-errors.tsx    |  30 +-
 packages/stack-shared/src/schema-fields.ts    |  14 +-
 .../apps/implementations/client-app-impl.ts   |   4 +-
 .../apps/implementations/server-app-impl.ts   |  14 +-
 .../src/lib/stack-app/customers/index.ts      |   8 +-
 54 files changed, 1066 insertions(+), 1066 deletions(-)

diff --git a/apps/backend/prisma/schema.prisma b/apps/backend/prisma/schema.prisma
index 156fd07c1e..b0505448e6 100644
--- a/apps/backend/prisma/schema.prisma
+++ b/apps/backend/prisma/schema.prisma
@@ -763,9 +763,9 @@ model Subscription {
   tenancyId    String       @db.Uuid
   customerId   String
   customerType CustomerType
-  offerId      String?
+  productId    String?
   priceId      String?
-  offer        Json
+  product      Json
   quantity     Int          @default(1)
 
   stripeSubscriptionId String?
@@ -802,9 +802,9 @@ model OneTimePurchase {
   tenancyId             String                 @db.Uuid
   customerId            String
   customerType          CustomerType
-  offerId               String?
+  productId             String?
   priceId               String?
-  offer                 Json
+  product               Json
   quantity              Int
   stripePaymentIntentId String?
   createdAt             DateTime               @default(now())
diff --git a/apps/backend/prisma/seed.ts b/apps/backend/prisma/seed.ts
index 446dc2b462..b7cf165f85 100644
--- a/apps/backend/prisma/seed.ts
+++ b/apps/backend/prisma/seed.ts
@@ -103,7 +103,7 @@ async function seed() {
             displayName: "Plans",
           }
         },
-        offers: {
+        products: {
           team: {
             groupId: "plans",
             displayName: "Team",
diff --git a/apps/backend/src/app/api/latest/integrations/stripe/webhooks/route.tsx b/apps/backend/src/app/api/latest/integrations/stripe/webhooks/route.tsx
index fc959604be..1fba69c1f6 100644
--- a/apps/backend/src/app/api/latest/integrations/stripe/webhooks/route.tsx
+++ b/apps/backend/src/app/api/latest/integrations/stripe/webhooks/route.tsx
@@ -53,7 +53,7 @@ async function processStripeWebhookEvent(event: Stripe.Event): Promise<void> {
       throw new StackAssertionError("Tenancy not found", { event });
     }
     const prisma = await getPrismaClientForTenancy(tenancy);
-    const offer = JSON.parse(metadata.offer || "{}");
+    const product = JSON.parse(metadata.product || "{}");
     const qty = Math.max(1, Number(metadata.purchaseQuantity || 1));
     const stripePaymentIntentId = event.data.object.id;
     if (!metadata.customerId || !metadata.customerType) {
@@ -73,17 +73,17 @@ async function processStripeWebhookEvent(event: Stripe.Event): Promise<void> {
         tenancyId: tenancy.id,
         customerId: metadata.customerId,
         customerType: typedToUppercase(metadata.customerType),
-        offerId: metadata.offerId || null,
+        productId: metadata.productId || null,
         priceId: metadata.priceId || null,
         stripePaymentIntentId,
-        offer,
+        product,
         quantity: qty,
         creationSource: "PURCHASE_PAGE",
       },
       update: {
-        offerId: metadata.offerId || null,
+        productId: metadata.productId || null,
         priceId: metadata.priceId || null,
-        offer,
+        product,
         quantity: qty,
       }
     });
diff --git a/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx b/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
index aaf6653987..5e5a4e1575 100644
--- a/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
+++ b/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
@@ -53,10 +53,10 @@ export const POST = createSmartRouteHandler({
         data: {
           tenancyId: auth.tenancy.id,
           customerId: data.customerId,
-          customerType: typedToUppercase(data.offer.customerType),
-          offerId: data.offerId,
+          customerType: typedToUppercase(data.product.customerType),
+          productId: data.productId,
           priceId: price_id,
-          offer: data.offer,
+          product: data.product,
           quantity,
           creationSource: "TEST_MODE",
         },
@@ -85,11 +85,11 @@ export const POST = createSmartRouteHandler({
         data: {
           tenancyId: auth.tenancy.id,
           customerId: data.customerId,
-          customerType: typedToUppercase(data.offer.customerType),
+          customerType: typedToUppercase(data.product.customerType),
           status: "active",
-          offerId: data.offerId,
+          productId: data.productId,
           priceId: price_id,
-          offer: data.offer,
+          product: data.product,
           quantity,
           currentPeriodStart: new Date(),
           currentPeriodEnd: addInterval(new Date(), selectedPrice.interval!),
diff --git a/apps/backend/src/app/api/latest/internal/payments/transactions/route.tsx b/apps/backend/src/app/api/latest/internal/payments/transactions/route.tsx
index 00fa49b7d7..bbf8bc71ee 100644
--- a/apps/backend/src/app/api/latest/internal/payments/transactions/route.tsx
+++ b/apps/backend/src/app/api/latest/internal/payments/transactions/route.tsx
@@ -8,15 +8,15 @@ import { typedToLowercase, typedToUppercase } from "@stackframe/stack-shared/dis
 
 
 type SelectedPrice = NonNullable<AdminTransaction['price']>;
-type OfferWithPrices = {
+type ProductWithPrices = {
   displayName?: string,
   prices?: Record<string, SelectedPrice & { serverOnly?: unknown, freeTrial?: unknown }> | "include-by-default",
 } | null | undefined;
 
-function resolveSelectedPriceFromOffer(offer: OfferWithPrices, priceId?: string | null): SelectedPrice | null {
-  if (!offer) return null;
+function resolveSelectedPriceFromProduct(product: ProductWithPrices, priceId?: string | null): SelectedPrice | null {
+  if (!product) return null;
   if (!priceId) return null;
-  const prices = offer.prices;
+  const prices = product.prices;
   if (!prices || prices === "include-by-default") return null;
   const selected = prices[priceId as keyof typeof prices] as (SelectedPrice & { serverOnly?: unknown, freeTrial?: unknown }) | undefined;
   if (!selected) return null;
@@ -24,8 +24,8 @@ function resolveSelectedPriceFromOffer(offer: OfferWithPrices, priceId?: string
   return rest as SelectedPrice;
 }
 
-function getOfferDisplayName(offer: OfferWithPrices): string | null {
-  return offer?.displayName ?? null;
+function getProductDisplayName(product: ProductWithPrices): string | null {
+  return product?.displayName ?? null;
 }
 
 
@@ -137,8 +137,8 @@ export const GET = createSmartRouteHandler({
       customer_id: s.customerId,
       quantity: s.quantity,
       test_mode: s.creationSource === 'TEST_MODE',
-      offer_display_name: getOfferDisplayName(s.offer as OfferWithPrices),
-      price: resolveSelectedPriceFromOffer(s.offer as OfferWithPrices, s.priceId ?? null),
+      product_display_name: getProductDisplayName(s.product as ProductWithPrices),
+      price: resolveSelectedPriceFromProduct(s.product as ProductWithPrices, s.priceId ?? null),
       status: s.status,
     }));
 
@@ -153,7 +153,7 @@ export const GET = createSmartRouteHandler({
         customer_id: i.customerId,
         quantity: i.quantity,
         test_mode: false,
-        offer_display_name: null,
+        product_display_name: null,
         price: null,
         status: null,
         item_id: i.itemId,
@@ -170,8 +170,8 @@ export const GET = createSmartRouteHandler({
       customer_id: o.customerId,
       quantity: o.quantity,
       test_mode: o.creationSource === 'TEST_MODE',
-      offer_display_name: getOfferDisplayName(o.offer as OfferWithPrices),
-      price: resolveSelectedPriceFromOffer(o.offer as OfferWithPrices, o.priceId ?? null),
+      product_display_name: getProductDisplayName(o.product as ProductWithPrices),
+      price: resolveSelectedPriceFromProduct(o.product as ProductWithPrices, o.priceId ?? null),
       status: null,
     }));
 
diff --git a/apps/backend/src/app/api/latest/payments/purchases/create-purchase-url/route.ts b/apps/backend/src/app/api/latest/payments/purchases/create-purchase-url/route.ts
index cdd4faa16b..07fef0f3ab 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/create-purchase-url/route.ts
+++ b/apps/backend/src/app/api/latest/payments/purchases/create-purchase-url/route.ts
@@ -1,10 +1,10 @@
-import { ensureOfferIdOrInlineOffer } from "@/lib/payments";
+import { ensureProductIdOrInlineProduct } from "@/lib/payments";
 import { getStripeForAccount } from "@/lib/stripe";
 import { globalPrismaClient } from "@/prisma-client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
 import { CustomerType } from "@prisma/client";
 import { KnownErrors } from "@stackframe/stack-shared/dist/known-errors";
-import { adaptSchema, clientOrHigherAuthTypeSchema, inlineOfferSchema, yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
+import { adaptSchema, clientOrHigherAuthTypeSchema, inlineProductSchema, yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
 import { getEnvVariable } from "@stackframe/stack-shared/dist/utils/env";
 import { throwErr } from "@stackframe/stack-shared/dist/utils/errors";
 import { purchaseUrlVerificationCodeHandler } from "../verification-code-handler";
@@ -22,8 +22,8 @@ export const POST = createSmartRouteHandler({
     body: yupObject({
       customer_type: yupString().oneOf(["user", "team", "custom"]).defined(),
       customer_id: yupString().defined(),
-      offer_id: yupString().optional(),
-      offer_inline: inlineOfferSchema.optional(),
+      product_id: yupString().optional(),
+      product_inline: inlineProductSchema.optional(),
     }),
   }),
   response: yupObject({
@@ -36,10 +36,10 @@ export const POST = createSmartRouteHandler({
   handler: async (req) => {
     const { tenancy } = req.auth;
     const stripe = await getStripeForAccount({ tenancy });
-    const offerConfig = await ensureOfferIdOrInlineOffer(tenancy, req.auth.type, req.body.offer_id, req.body.offer_inline);
-    const customerType = offerConfig.customerType;
+    const productConfig = await ensureProductIdOrInlineProduct(tenancy, req.auth.type, req.body.product_id, req.body.product_inline);
+    const customerType = productConfig.customerType;
     if (req.body.customer_type !== customerType) {
-      throw new KnownErrors.OfferCustomerTypeDoesNotMatch(req.body.offer_id, req.body.customer_id, customerType, req.body.customer_type);
+      throw new KnownErrors.ProductCustomerTypeDoesNotMatch(req.body.product_id, req.body.customer_id, customerType, req.body.customer_type);
     }
 
     const stripeCustomerSearch = await stripe.customers.search({
@@ -66,8 +66,8 @@ export const POST = createSmartRouteHandler({
       data: {
         tenancyId: tenancy.id,
         customerId: req.body.customer_id,
-        offerId: req.body.offer_id,
-        offer: offerConfig,
+        productId: req.body.product_id,
+        product: productConfig,
         stripeCustomerId: stripeCustomer.id,
         stripeAccountId: project?.stripeAccountId ?? throwErr("Stripe account not configured"),
       },
diff --git a/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx b/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
index 1ca9f23e4c..9226adfa00 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
+++ b/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
@@ -51,7 +51,7 @@ export const POST = createSmartRouteHandler({
       if (conflicting.stripeSubscriptionId) {
         const existingStripeSub = await stripe.subscriptions.retrieve(conflicting.stripeSubscriptionId);
         const existingItem = existingStripeSub.items.data[0];
-        const product = await stripe.products.create({ name: data.offer.displayName ?? "Subscription" });
+        const product = await stripe.products.create({ name: data.product.displayName ?? "Subscription" });
         if (selectedPrice.interval) {
           const updated = await stripe.subscriptions.update(conflicting.stripeSubscriptionId, {
             payment_behavior: 'default_incomplete',
@@ -71,8 +71,8 @@ export const POST = createSmartRouteHandler({
               quantity,
             }],
             metadata: {
-              offerId: data.offerId ?? null,
-              offer: JSON.stringify(data.offer),
+              productId: data.productId ?? null,
+              product: JSON.stringify(data.product),
               priceId: price_id,
             },
           });
@@ -108,10 +108,10 @@ export const POST = createSmartRouteHandler({
         customer: data.stripeCustomerId,
         automatic_payment_methods: { enabled: true },
         metadata: {
-          offerId: data.offerId || "",
-          offer: JSON.stringify(data.offer),
+          productId: data.productId || "",
+          product: JSON.stringify(data.product),
           customerId: data.customerId,
-          customerType: data.offer.customerType,
+          customerType: data.product.customerType,
           purchaseQuantity: String(quantity),
           purchaseKind: "ONE_TIME",
           tenancyId: data.tenancyId,
@@ -127,7 +127,7 @@ export const POST = createSmartRouteHandler({
     }
 
     const product = await stripe.products.create({
-      name: data.offer.displayName ?? "Subscription",
+      name: data.product.displayName ?? "Subscription",
     });
     const created = await stripe.subscriptions.create({
       customer: data.stripeCustomerId,
@@ -147,8 +147,8 @@ export const POST = createSmartRouteHandler({
         quantity,
       }],
       metadata: {
-        offerId: data.offerId ?? null,
-        offer: JSON.stringify(data.offer),
+        productId: data.productId ?? null,
+        product: JSON.stringify(data.product),
         priceId: price_id,
       },
     });
diff --git a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
index 1807b101f7..d8615e5265 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
+++ b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
@@ -2,14 +2,14 @@ import { getSubscriptions, isActiveSubscription } from "@/lib/payments";
 import { getTenancy } from "@/lib/tenancies";
 import { getPrismaClientForTenancy } from "@/prisma-client";
 import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
-import { inlineOfferSchema, yupArray, yupBoolean, yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
+import { inlineProductSchema, yupArray, yupBoolean, yupNumber, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
 import { SUPPORTED_CURRENCIES } from "@stackframe/stack-shared/dist/utils/currency-constants";
 import { StackAssertionError } from "@stackframe/stack-shared/dist/utils/errors";
 import { filterUndefined, getOrUndefined, typedEntries, typedFromEntries } from "@stackframe/stack-shared/dist/utils/objects";
 import * as yup from "yup";
 import { purchaseUrlVerificationCodeHandler } from "../verification-code-handler";
 
-const offerDataSchema = inlineOfferSchema
+const productDataSchema = inlineProductSchema
   .omit(["server_only", "included_items"])
   .concat(yupObject({
     stackable: yupBoolean().defined(),
@@ -28,12 +28,12 @@ export const POST = createSmartRouteHandler({
     statusCode: yupNumber().oneOf([200]).defined(),
     bodyType: yupString().oneOf(["json"]).defined(),
     body: yupObject({
-      offer: offerDataSchema,
+      product: productDataSchema,
       stripe_account_id: yupString().defined(),
       project_id: yupString().defined(),
       already_bought_non_stackable: yupBoolean().defined(),
-      conflicting_group_offers: yupArray(yupObject({
-        offer_id: yupString().defined(),
+      conflicting_group_products: yupArray(yupObject({
+        product_id: yupString().defined(),
         display_name: yupString().defined(),
       }).defined()).defined(),
     }).defined(),
@@ -44,12 +44,12 @@ export const POST = createSmartRouteHandler({
     if (!tenancy) {
       throw new StackAssertionError(`No tenancy found for given tenancyId`);
     }
-    const offer = verificationCode.data.offer;
-    const offerData: yup.InferType<typeof offerDataSchema> = {
-      display_name: offer.displayName ?? "Offer",
-      customer_type: offer.customerType,
-      stackable: offer.stackable === true,
-      prices: offer.prices === "include-by-default" ? {} : typedFromEntries(typedEntries(offer.prices).map(([key, value]) => [key, filterUndefined({
+    const product = verificationCode.data.product;
+    const productData: yup.InferType<typeof productDataSchema> = {
+      display_name: product.displayName ?? "Product",
+      customer_type: product.customerType,
+      stackable: product.stackable === true,
+      prices: product.prices === "include-by-default" ? {} : typedFromEntries(typedEntries(product.prices).map(([key, value]) => [key, filterUndefined({
         ...typedFromEntries(SUPPORTED_CURRENCIES.map(c => [c.code, getOrUndefined(value, c.code)])),
         interval: value.interval,
         free_trial: value.freeTrial,
@@ -61,28 +61,28 @@ export const POST = createSmartRouteHandler({
     const subscriptions = await getSubscriptions({
       prisma,
       tenancy,
-      customerType: offer.customerType,
+      customerType: product.customerType,
       customerId: verificationCode.data.customerId,
     });
 
-    const alreadyBoughtNonStackable = !!(subscriptions.find((s) => s.offerId === verificationCode.data.offerId) && offer.stackable !== true);
+    const alreadyBoughtNonStackable = !!(subscriptions.find((s) => s.productId === verificationCode.data.productId) && product.stackable !== true);
 
     const groups = tenancy.config.payments.groups;
-    const groupId = Object.keys(groups).find((g) => offer.groupId === g);
-    let conflictingGroupOffers: { offer_id: string, display_name: string }[] = [];
+    const groupId = Object.keys(groups).find((g) => product.groupId === g);
+    let conflictingGroupProducts: { product_id: string, display_name: string }[] = [];
     if (groupId) {
-      const isSubscribable = offer.prices !== "include-by-default" && Object.values(offer.prices).some((p: any) => p && p.interval);
+      const isSubscribable = product.prices !== "include-by-default" && Object.values(product.prices).some((p: any) => p && p.interval);
       if (isSubscribable) {
         const conflicts = subscriptions.filter((subscription) => (
-          subscription.offerId &&
-          subscription.offer.groupId === groupId &&
+          subscription.productId &&
+          subscription.product.groupId === groupId &&
           isActiveSubscription(subscription) &&
-          subscription.offer.prices !== "include-by-default" &&
-          (!offer.isAddOnTo || !Object.keys(offer.isAddOnTo).includes(subscription.offerId))
+          subscription.product.prices !== "include-by-default" &&
+          (!product.isAddOnTo || !Object.keys(product.isAddOnTo).includes(subscription.productId))
         ));
-        conflictingGroupOffers = conflicts.map((s) => ({
-          offer_id: s.offerId!,
-          display_name: s.offer.displayName ?? s.offerId!,
+        conflictingGroupProducts = conflicts.map((s) => ({
+          product_id: s.productId!,
+          display_name: s.product.displayName ?? s.productId!,
         }));
       }
     }
@@ -91,11 +91,11 @@ export const POST = createSmartRouteHandler({
       statusCode: 200,
       bodyType: "json",
       body: {
-        offer: offerData,
+        product: productData,
         stripe_account_id: verificationCode.data.stripeAccountId,
         project_id: tenancy.project.id,
         already_bought_non_stackable: alreadyBoughtNonStackable,
-        conflicting_group_offers: conflictingGroupOffers,
+        conflicting_group_products: conflictingGroupProducts,
       },
     };
   },
diff --git a/apps/backend/src/app/api/latest/payments/purchases/verification-code-handler.tsx b/apps/backend/src/app/api/latest/payments/purchases/verification-code-handler.tsx
index f20e9f684b..1339821c13 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/verification-code-handler.tsx
+++ b/apps/backend/src/app/api/latest/payments/purchases/verification-code-handler.tsx
@@ -1,6 +1,6 @@
 import { createVerificationCodeHandler } from "@/route-handlers/verification-code-handler";
 import { VerificationCodeType } from "@prisma/client";
-import { offerSchema, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
+import { productSchema, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
 
 export const purchaseUrlVerificationCodeHandler = createVerificationCodeHandler({
   type: VerificationCodeType.PURCHASE_URL,
@@ -8,8 +8,8 @@ export const purchaseUrlVerificationCodeHandler = createVerificationCodeHandler(
   data: yupObject({
     tenancyId: yupString().defined(),
     customerId: yupString().defined(),
-    offerId: yupString(),
-    offer: offerSchema,
+    productId: yupString(),
+    product: productSchema,
     stripeCustomerId: yupString().defined(),
     stripeAccountId: yupString().defined(),
   }),
diff --git a/apps/backend/src/lib/payments.test.tsx b/apps/backend/src/lib/payments.test.tsx
index 7db9cb30aa..b3efbc7670 100644
--- a/apps/backend/src/lib/payments.test.tsx
+++ b/apps/backend/src/lib/payments.test.tsx
@@ -56,7 +56,7 @@ describe('getItemQuantityForCustomer - manual changes (no subscription)', () =>
           customerType: 'custom',
         },
       },
-      offers: {},
+      products: {},
       groups: {},
     });
 
@@ -100,7 +100,7 @@ describe('getItemQuantityForCustomer - manual changes (no subscription)', () =>
           customerType: 'custom',
         },
       },
-      offers: {},
+      products: {},
       groups: {},
     });
 
@@ -147,7 +147,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         off1: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -160,7 +160,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'off1',
+          productId: 'off1',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-02-28T23:59:59.000Z'),
           quantity: 2,
@@ -185,7 +185,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offW: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -198,7 +198,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offW',
+          productId: 'offW',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -224,7 +224,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offW: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -237,7 +237,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offW',
+          productId: 'offW',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -263,7 +263,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offR: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -276,7 +276,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offR',
+          productId: 'offR',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -302,7 +302,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offN: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -315,7 +315,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offN',
+          productId: 'offN',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 3,
@@ -337,7 +337,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offRC: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -350,7 +350,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offRC',
+          productId: 'offRC',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -380,7 +380,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offRR: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -398,7 +398,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
           const start = inFirstPeriod ? new Date('2025-02-01T00:00:00.000Z') : new Date('2025-03-01T00:00:00.000Z');
           const end = inFirstPeriod ? new Date('2025-03-01T00:00:00.000Z') : new Date('2025-04-01T00:00:00.000Z');
           return [{
-            offerId: 'offRR',
+            productId: 'offRR',
             currentPeriodStart: start,
             currentPeriodEnd: end,
             quantity: 1,
@@ -429,7 +429,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offMD: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -442,7 +442,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offMD',
+          productId: 'offMD',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -477,7 +477,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'S', customerType: 'user' } },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offBF: {
           displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -490,7 +490,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offBF',
+          productId: 'offBF',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 1,
@@ -525,7 +525,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'S', customerType: 'user' } },
       groups: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } },
-      offers: {
+      products: {
         off1: {
           displayName: 'O1', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -545,14 +545,14 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       subscription: {
         findMany: async () => [
           {
-            offerId: 'off1',
+            productId: 'off1',
             currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
             currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
             quantity: 3,
             status: 'active',
           },
           {
-            offerId: 'off2',
+            productId: 'off2',
             currentPeriodStart: new Date('2025-01-15T00:00:00.000Z'),
             currentPeriodEnd: new Date('2025-03-15T00:00:00.000Z'),
             quantity: 5,
@@ -576,7 +576,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemA]: { displayName: 'A', customerType: 'user' }, [itemB]: { displayName: 'B', customerType: 'user' } },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offBundle: {
           displayName: 'OB', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -592,7 +592,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offBundle',
+          productId: 'offBundle',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 2,
@@ -616,7 +616,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'T', customerType: 'user' } },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offT: {
           displayName: 'OT', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -629,7 +629,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offT',
+          productId: 'offT',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 3,
@@ -651,7 +651,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'C', customerType: 'user' } },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offC: {
           displayName: 'OC', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -664,7 +664,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offC',
+          productId: 'offC',
           currentPeriodStart: new Date('2024-12-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-01-01T00:00:00.000Z'),
           quantity: 1,
@@ -678,7 +678,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     vi.useRealTimers();
   });
 
-  it('ungrouped offer works without tenancy groups', async () => {
+  it('ungrouped product works without tenancy groups', async () => {
     const now = new Date('2025-02-10T00:00:00.000Z');
     vi.setSystemTime(now);
     const itemId = 'ungroupedItem';
@@ -686,7 +686,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'U', customerType: 'user' } },
       groups: {},
-      offers: {
+      products: {
         offU: {
           displayName: 'OU',
           groupId: undefined,
@@ -704,7 +704,7 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const prisma = createMockPrisma({
       subscription: {
         findMany: async () => [{
-          offerId: 'offU',
+          productId: 'offU',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 2,
@@ -725,15 +725,15 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
     const itemId = 'otpItemA';
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'I', customerType: 'custom' } },
-      offers: {},
+      products: {},
       groups: {},
     });
 
     const prisma = createMockPrisma({
       oneTimePurchase: {
         findMany: async () => [{
-          offerId: 'off-otp',
-          offer: { includedItems: { [itemId]: { quantity: 5 } } },
+          productId: 'off-otp',
+          product: { includedItems: { [itemId]: { quantity: 5 } } },
           quantity: 2,
           createdAt: new Date('2025-02-10T00:00:00.000Z'),
         }],
@@ -750,19 +750,19 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
     expect(qty).toBe(10);
   });
 
-  it('aggregates multiple one-time purchases across different offers', async () => {
+  it('aggregates multiple one-time purchases across different products', async () => {
     const itemId = 'otpItemB';
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'I', customerType: 'custom' } },
-      offers: {},
+      products: {},
       groups: {},
     });
 
     const prisma = createMockPrisma({
       oneTimePurchase: {
         findMany: async () => [
-          { offerId: 'off-1', offer: { includedItems: { [itemId]: { quantity: 3 } } }, quantity: 1, createdAt: new Date('2025-02-10T00:00:00.000Z') },
-          { offerId: 'off-2', offer: { includedItems: { [itemId]: { quantity: 5 } } }, quantity: 2, createdAt: new Date('2025-02-11T00:00:00.000Z') },
+          { productId: 'off-1', product: { includedItems: { [itemId]: { quantity: 3 } } }, quantity: 1, createdAt: new Date('2025-02-10T00:00:00.000Z') },
+          { productId: 'off-2', product: { includedItems: { [itemId]: { quantity: 5 } } }, quantity: 2, createdAt: new Date('2025-02-11T00:00:00.000Z') },
         ],
       },
     } as any);
@@ -780,11 +780,11 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
 
 
 describe('validatePurchaseSession - one-time purchase rules', () => {
-  it('blocks duplicate one-time purchase for same offerId', async () => {
-    const tenancy = createMockTenancy({ items: {}, offers: {}, groups: {} });
+  it('blocks duplicate one-time purchase for same productId', async () => {
+    const tenancy = createMockTenancy({ items: {}, products: {}, groups: {} });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ offerId: 'offer-dup', offer: { groupId: undefined }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'product-dup', product: { groupId: undefined }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -795,8 +795,8 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       codeData: {
         tenancyId: tenancy.id,
         customerId: 'cust-1',
-        offerId: 'offer-dup',
-        offer: {
+        productId: 'product-dup',
+        product: {
           displayName: 'X',
           groupId: undefined,
           customerType: 'custom',
@@ -810,14 +810,14 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       },
       priceId: 'price-any',
       quantity: 1,
-    })).rejects.toThrowError('Customer already has a one-time purchase for this offer');
+    })).rejects.toThrowError('Customer already has a one-time purchase for this product');
   });
 
   it('blocks one-time purchase when another one exists in the same group', async () => {
-    const tenancy = createMockTenancy({ items: {}, offers: {}, groups: { g1: { displayName: 'G1' } } });
+    const tenancy = createMockTenancy({ items: {}, products: {}, groups: { g1: { displayName: 'G1' } } });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ offerId: 'other-offer', offer: { groupId: 'g1' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'other-product', product: { groupId: 'g1' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -828,8 +828,8 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       codeData: {
         tenancyId: tenancy.id,
         customerId: 'cust-1',
-        offerId: 'offer-y',
-        offer: {
+        productId: 'product-y',
+        product: {
           displayName: 'Y',
           groupId: 'g1',
           customerType: 'custom',
@@ -843,14 +843,14 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       },
       priceId: 'price-any',
       quantity: 1,
-    })).rejects.toThrowError('Customer already has a one-time purchase in this offer group');
+    })).rejects.toThrowError('Customer already has a one-time purchase in this product group');
   });
 
   it('allows purchase when existing one-time is in a different group', async () => {
-    const tenancy = createMockTenancy({ items: {}, offers: {}, groups: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } } });
+    const tenancy = createMockTenancy({ items: {}, products: {}, groups: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } } });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ offerId: 'other-offer', offer: { groupId: 'g2' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'other-product', product: { groupId: 'g2' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -861,8 +861,8 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       codeData: {
         tenancyId: tenancy.id,
         customerId: 'cust-1',
-        offerId: 'offer-z',
-        offer: {
+        productId: 'product-z',
+        product: {
           displayName: 'Z',
           groupId: 'g1',
           customerType: 'custom',
@@ -891,7 +891,7 @@ describe('combined sources - one-time purchases + manual changes + subscriptions
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'Combo', customerType: 'user' } },
       groups: { g1: { displayName: 'G' } },
-      offers: {
+      products: {
         offSub: {
           displayName: 'Sub', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
@@ -911,13 +911,13 @@ describe('combined sources - one-time purchases + manual changes + subscriptions
       },
       oneTimePurchase: {
         findMany: async () => [
-          { offerId: 'offA', offer: { includedItems: { [itemId]: { quantity: 4 } } }, quantity: 1, createdAt: new Date('2025-02-09T00:00:00.000Z') },
-          { offerId: 'offB', offer: { includedItems: { [itemId]: { quantity: 2 } } }, quantity: 3, createdAt: new Date('2025-02-11T00:00:00.000Z') },
+          { productId: 'offA', product: { includedItems: { [itemId]: { quantity: 4 } } }, quantity: 1, createdAt: new Date('2025-02-09T00:00:00.000Z') },
+          { productId: 'offB', product: { includedItems: { [itemId]: { quantity: 2 } } }, quantity: 3, createdAt: new Date('2025-02-11T00:00:00.000Z') },
         ],
       },
       subscription: {
         findMany: async () => [{
-          offerId: 'offSub',
+          productId: 'offSub',
           currentPeriodStart: new Date('2025-02-01T00:00:00.000Z'),
           currentPeriodEnd: new Date('2025-03-01T00:00:00.000Z'),
           quantity: 2,
diff --git a/apps/backend/src/lib/payments.tsx b/apps/backend/src/lib/payments.tsx
index c9f4b3a5f5..4c8d1b1720 100644
--- a/apps/backend/src/lib/payments.tsx
+++ b/apps/backend/src/lib/payments.tsx
@@ -1,9 +1,9 @@
 import { PrismaClientTransaction } from "@/prisma-client";
 import { SubscriptionStatus } from "@prisma/client";
 import { KnownErrors } from "@stackframe/stack-shared";
-import type { inlineOfferSchema, offerSchema } from "@stackframe/stack-shared/dist/schema-fields";
+import type { inlineProductSchema, productSchema } from "@stackframe/stack-shared/dist/schema-fields";
 import { SUPPORTED_CURRENCIES } from "@stackframe/stack-shared/dist/utils/currency-constants";
-import { addInterval, FAR_FUTURE_DATE, getIntervalsElapsed } from "@stackframe/stack-shared/dist/utils/dates";
+import { FAR_FUTURE_DATE, addInterval, getIntervalsElapsed } from "@stackframe/stack-shared/dist/utils/dates";
 import { StackAssertionError, StatusError, throwErr } from "@stackframe/stack-shared/dist/utils/errors";
 import { getOrUndefined, typedEntries, typedFromEntries, typedKeys } from "@stackframe/stack-shared/dist/utils/objects";
 import { typedToUppercase } from "@stackframe/stack-shared/dist/utils/strings";
@@ -12,48 +12,48 @@ import Stripe from "stripe";
 import * as yup from "yup";
 import { Tenancy } from "./tenancies";
 
-const DEFAULT_OFFER_START_DATE = new Date("1973-01-01T12:00:00.000Z"); // monday
+const DEFAULT_PRODUCT_START_DATE = new Date("1973-01-01T12:00:00.000Z"); // monday
 
-export async function ensureOfferIdOrInlineOffer(
+export async function ensureProductIdOrInlineProduct(
   tenancy: Tenancy,
   accessType: "client" | "server" | "admin",
-  offerId: string | undefined,
-  inlineOffer: yup.InferType<typeof inlineOfferSchema> | undefined
-): Promise<Tenancy["config"]["payments"]["offers"][string]> {
-  if (offerId && inlineOffer) {
-    throw new StatusError(400, "Cannot specify both offer_id and offer_inline!");
+  productId: string | undefined,
+  inlineProduct: yup.InferType<typeof inlineProductSchema> | undefined
+): Promise<Tenancy["config"]["payments"]["products"][string]> {
+  if (productId && inlineProduct) {
+    throw new StatusError(400, "Cannot specify both product_id and product_inline!");
   }
-  if (inlineOffer && accessType === "client") {
-    throw new StatusError(400, "Cannot specify offer_inline when calling from client! Please call with a server API key, or use the offer_id parameter.");
+  if (inlineProduct && accessType === "client") {
+    throw new StatusError(400, "Cannot specify product_inline when calling from client! Please call with a server API key, or use the product_id parameter.");
   }
-  if (!offerId && !inlineOffer) {
-    throw new StatusError(400, "Must specify either offer_id or offer_inline!");
+  if (!productId && !inlineProduct) {
+    throw new StatusError(400, "Must specify either product_id or product_inline!");
   }
-  if (offerId) {
-    const offer = getOrUndefined(tenancy.config.payments.offers, offerId);
-    if (!offer || (offer.serverOnly && accessType === "client")) {
-      throw new KnownErrors.OfferDoesNotExist(offerId, accessType);
+  if (productId) {
+    const product = getOrUndefined(tenancy.config.payments.products, productId);
+    if (!product || (product.serverOnly && accessType === "client")) {
+      throw new KnownErrors.ProductDoesNotExist(productId, accessType);
     }
-    return offer;
+    return product;
   } else {
-    if (!inlineOffer) {
-      throw new StackAssertionError("Inline offer does not exist, this should never happen", { inlineOffer, offerId });
+    if (!inlineProduct) {
+      throw new StackAssertionError("Inline product does not exist, this should never happen", { inlineProduct, productId });
     }
     return {
       groupId: undefined,
       isAddOnTo: false,
-      displayName: inlineOffer.display_name,
-      customerType: inlineOffer.customer_type,
-      freeTrial: inlineOffer.free_trial,
-      serverOnly: inlineOffer.server_only,
+      displayName: inlineProduct.display_name,
+      customerType: inlineProduct.customer_type,
+      freeTrial: inlineProduct.free_trial,
+      serverOnly: inlineProduct.server_only,
       stackable: false,
-      prices: Object.fromEntries(Object.entries(inlineOffer.prices).map(([key, value]) => [key, {
+      prices: Object.fromEntries(Object.entries(inlineProduct.prices).map(([key, value]) => [key, {
         ...typedFromEntries(SUPPORTED_CURRENCIES.map(c => [c.code, getOrUndefined(value, c.code)])),
         interval: value.interval,
         freeTrial: value.free_trial,
         serverOnly: true,
       }])),
-      includedItems: typedFromEntries(Object.entries(inlineOffer.included_items).map(([key, value]) => [key, {
+      includedItems: typedFromEntries(Object.entries(inlineProduct.included_items).map(([key, value]) => [key, {
         repeat: value.repeat ?? "never",
         quantity: value.quantity ?? 0,
         expires: value.expires ?? "never",
@@ -169,8 +169,8 @@ export async function getItemQuantityForCustomer(options: {
     },
   });
   for (const p of oneTimePurchases) {
-    const offer = p.offer as yup.InferType<typeof offerSchema>;
-    const inc = getOrUndefined(offer.includedItems, options.itemId);
+    const product = p.product as yup.InferType<typeof productSchema>;
+    const inc = getOrUndefined(product.includedItems, options.itemId);
     if (!inc) continue;
     const baseQty = inc.quantity * p.quantity;
     if (baseQty <= 0) continue;
@@ -189,8 +189,8 @@ export async function getItemQuantityForCustomer(options: {
     customerId: options.customerId,
   });
   for (const s of subscriptions) {
-    const offer = s.offer;
-    const inc = getOrUndefined(offer.includedItems, options.itemId);
+    const product = s.product;
+    const inc = getOrUndefined(product.includedItems, options.itemId);
     if (!inc) continue;
     const baseQty = inc.quantity * s.quantity;
     if (baseQty <= 0) continue;
@@ -242,14 +242,14 @@ type Subscription = {
    */
   id: string | null,
   /**
-   * `null` for inline offers
+   * `null` for inline products
    */
-  offerId: string | null,
+  productId: string | null,
   /**
-   * `null` for test mode purchases and group default offers
+   * `null` for test mode purchases and group default products
    */
   stripeSubscriptionId: string | null,
-  offer: yup.InferType<typeof offerSchema>,
+  product: yup.InferType<typeof productSchema>,
   quantity: number,
   currentPeriodStart: Date,
   currentPeriodEnd: Date | null,
@@ -268,7 +268,7 @@ export async function getSubscriptions(options: {
   customerId: string,
 }) {
   const groups = options.tenancy.config.payments.groups;
-  const offers = options.tenancy.config.payments.offers;
+  const products = options.tenancy.config.payments.products;
   const subscriptions: Subscription[] = [];
   const dbSubscriptions = await options.prisma.subscription.findMany({
     where: {
@@ -280,12 +280,12 @@ export async function getSubscriptions(options: {
 
   const groupsWithDbSubscriptions = new Set<string>();
   for (const s of dbSubscriptions) {
-    const offer = s.offerId ? getOrUndefined(offers, s.offerId) : s.offer as yup.InferType<typeof offerSchema>;
-    if (!offer) continue;
+    const product = s.productId ? getOrUndefined(products, s.productId) : s.product as yup.InferType<typeof productSchema>;
+    if (!product) continue;
     subscriptions.push({
       id: s.id,
-      offerId: s.offerId,
-      offer,
+      productId: s.productId,
+      product,
       quantity: s.quantity,
       currentPeriodStart: s.currentPeriodStart,
       currentPeriodEnd: s.currentPeriodEnd,
@@ -293,25 +293,25 @@ export async function getSubscriptions(options: {
       createdAt: s.createdAt,
       stripeSubscriptionId: s.stripeSubscriptionId,
     });
-    if (offer.groupId !== undefined) {
-      groupsWithDbSubscriptions.add(offer.groupId);
+    if (product.groupId !== undefined) {
+      groupsWithDbSubscriptions.add(product.groupId);
     }
   }
 
   for (const groupId of Object.keys(groups)) {
     if (groupsWithDbSubscriptions.has(groupId)) continue;
-    const offersInGroup = typedEntries(offers).filter(([_, offer]) => offer.groupId === groupId);
-    const defaultGroupOffer = offersInGroup.find(([_, offer]) => offer.prices === "include-by-default");
-    if (defaultGroupOffer) {
+    const productsInGroup = typedEntries(products).filter(([_, product]) => product.groupId === groupId);
+    const defaultGroupProduct = productsInGroup.find(([_, product]) => product.prices === "include-by-default");
+    if (defaultGroupProduct) {
       subscriptions.push({
         id: null,
-        offerId: defaultGroupOffer[0],
-        offer: defaultGroupOffer[1],
+        productId: defaultGroupProduct[0],
+        product: defaultGroupProduct[1],
         quantity: 1,
-        currentPeriodStart: DEFAULT_OFFER_START_DATE,
+        currentPeriodStart: DEFAULT_PRODUCT_START_DATE,
         currentPeriodEnd: null,
         status: SubscriptionStatus.active,
-        createdAt: DEFAULT_OFFER_START_DATE,
+        createdAt: DEFAULT_PRODUCT_START_DATE,
         stripeSubscriptionId: null,
       });
     }
@@ -359,8 +359,8 @@ export async function ensureCustomerExists(options: {
   }
 }
 
-type Offer = yup.InferType<typeof offerSchema>;
-type SelectedPrice = Exclude<Offer["prices"], "include-by-default">[string];
+type Product = yup.InferType<typeof productSchema>;
+type SelectedPrice = Exclude<Product["prices"], "include-by-default">[string];
 
 export async function validatePurchaseSession(options: {
   prisma: PrismaClientTransaction,
@@ -368,8 +368,8 @@ export async function validatePurchaseSession(options: {
   codeData: {
     tenancyId: string,
     customerId: string,
-    offerId?: string,
-    offer: Offer,
+    productId?: string,
+    product: Product,
   },
   priceId: string,
   quantity: number,
@@ -380,24 +380,24 @@ export async function validatePurchaseSession(options: {
   conflictingGroupSubscriptions: Subscription[],
 }> {
   const { prisma, tenancy, codeData, priceId, quantity } = options;
-  const offer = codeData.offer;
+  const product = codeData.product;
   await ensureCustomerExists({
     prisma,
     tenancyId: tenancy.id,
-    customerType: offer.customerType,
+    customerType: product.customerType,
     customerId: codeData.customerId,
   });
 
   let selectedPrice: SelectedPrice | undefined = undefined;
-  if (offer.prices !== "include-by-default") {
-    const pricesMap = new Map(typedEntries(offer.prices));
+  if (product.prices !== "include-by-default") {
+    const pricesMap = new Map(typedEntries(product.prices));
     selectedPrice = pricesMap.get(priceId);
     if (!selectedPrice) {
-      throw new StatusError(400, "Price not found on offer associated with this purchase code");
+      throw new StatusError(400, "Price not found on product associated with this purchase code");
     }
   }
-  if (quantity !== 1 && offer.stackable !== true) {
-    throw new StatusError(400, "This offer is not stackable; quantity must be 1");
+  if (quantity !== 1 && product.stackable !== true) {
+    throw new StatusError(400, "This product is not stackable; quantity must be 1");
   }
 
   // Block based on prior one-time purchases for same customer and customerType
@@ -405,39 +405,39 @@ export async function validatePurchaseSession(options: {
     where: {
       tenancyId: tenancy.id,
       customerId: codeData.customerId,
-      customerType: typedToUppercase(offer.customerType),
+      customerType: typedToUppercase(product.customerType),
     },
   });
 
-  if (codeData.offerId && existingOneTimePurchases.some((p) => p.offerId === codeData.offerId)) {
-    throw new StatusError(400, "Customer already has a one-time purchase for this offer");
+  if (codeData.productId && existingOneTimePurchases.some((p) => p.productId === codeData.productId)) {
+    throw new StatusError(400, "Customer already has a one-time purchase for this product");
   }
 
   const subscriptions = await getSubscriptions({
     prisma,
     tenancy,
-    customerType: offer.customerType,
+    customerType: product.customerType,
     customerId: codeData.customerId,
   });
-  if (subscriptions.find((s) => s.offerId === codeData.offerId) && offer.stackable !== true) {
-    throw new StatusError(400, "Customer already has a subscription for this offer; this offer is not stackable");
+  if (subscriptions.find((s) => s.productId === codeData.productId) && product.stackable !== true) {
+    throw new StatusError(400, "Customer already has a subscription for this product; this product is not stackable");
   }
-  const addOnOfferIds = offer.isAddOnTo ? typedKeys(offer.isAddOnTo) : [];
-  if (offer.isAddOnTo && !subscriptions.some((s) => s.offerId && addOnOfferIds.includes(s.offerId))) {
-    throw new StatusError(400, "This offer is an add-on to an offer that the customer does not have");
+  const addOnProductIds = product.isAddOnTo ? typedKeys(product.isAddOnTo) : [];
+  if (product.isAddOnTo && !subscriptions.some((s) => s.productId && addOnProductIds.includes(s.productId))) {
+    throw new StatusError(400, "This product is an add-on to an product that the customer does not have");
   }
 
   const groups = tenancy.config.payments.groups;
-  const groupId = typedKeys(groups).find((g) => offer.groupId === g);
+  const groupId = typedKeys(groups).find((g) => product.groupId === g);
 
-  // Block purchasing any offer in the same group if a one-time purchase exists in that group
+  // Block purchasing any product in the same group if a one-time purchase exists in that group
   if (groupId) {
     const hasOneTimeInGroup = existingOneTimePurchases.some((p) => {
-      const offer = p.offer as yup.InferType<typeof offerSchema>;
-      return offer.groupId === groupId;
+      const product = p.product as yup.InferType<typeof productSchema>;
+      return product.groupId === groupId;
     });
     if (hasOneTimeInGroup) {
-      throw new StatusError(400, "Customer already has a one-time purchase in this offer group");
+      throw new StatusError(400, "Customer already has a one-time purchase in this product group");
     }
   }
 
@@ -445,11 +445,11 @@ export async function validatePurchaseSession(options: {
   if (groupId) {
     conflictingGroupSubscriptions = subscriptions.filter((subscription) => (
       subscription.id &&
-      subscription.offerId &&
-      subscription.offer.groupId === groupId &&
+      subscription.productId &&
+      subscription.product.groupId === groupId &&
       isActiveSubscription(subscription) &&
-      subscription.offer.prices !== "include-by-default" &&
-      (!offer.isAddOnTo || !addOnOfferIds.includes(subscription.offerId))
+      subscription.product.prices !== "include-by-default" &&
+      (!product.isAddOnTo || !addOnProductIds.includes(subscription.productId))
     ));
   }
 
diff --git a/apps/backend/src/lib/stripe.tsx b/apps/backend/src/lib/stripe.tsx
index f452228fd7..3ab57d2844 100644
--- a/apps/backend/src/lib/stripe.tsx
+++ b/apps/backend/src/lib/stripe.tsx
@@ -89,7 +89,7 @@ export async function syncStripeSubscriptions(stripe: Stripe, stripeAccountId: s
       },
       update: {
         status: subscription.status,
-        offer: JSON.parse(subscription.metadata.offer),
+        product: JSON.parse(subscription.metadata.product),
         quantity: item.quantity ?? 1,
         currentPeriodEnd: new Date(item.current_period_end * 1000),
         currentPeriodStart: new Date(item.current_period_start * 1000),
@@ -100,9 +100,9 @@ export async function syncStripeSubscriptions(stripe: Stripe, stripeAccountId: s
         tenancyId: tenancy.id,
         customerId,
         customerType,
-        offerId: subscription.metadata.offerId,
+        productId: subscription.metadata.productId,
         priceId: priceId ?? null,
-        offer: JSON.parse(subscription.metadata.offer),
+        product: JSON.parse(subscription.metadata.product),
         quantity: item.quantity ?? 1,
         stripeSubscriptionId: subscription.id,
         status: subscription.status,
diff --git a/apps/dashboard/src/app/(main)/(protected)/(outside-dashboard)/projects/page-client.tsx b/apps/dashboard/src/app/(main)/(protected)/(outside-dashboard)/projects/page-client.tsx
index 2ab066e7fa..5333a69fa7 100644
--- a/apps/dashboard/src/app/(main)/(protected)/(outside-dashboard)/projects/page-client.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/(outside-dashboard)/projects/page-client.tsx
@@ -134,7 +134,7 @@ function TeamAddUserDialog(props: {
   const onSubmit = async (values: yup.InferType<typeof inviteFormSchema>) => {
     if (users.length + 1 > quantity) {
       alert("You have reached the maximum number of dashboard admins. Please upgrade your plan to add more admins.");
-      const checkoutUrl = await props.team.createCheckoutUrl({ offerId: "team" });
+      const checkoutUrl = await props.team.createCheckoutUrl({ productId: "team" });
       window.open(checkoutUrl, "_blank", "noopener");
       return "prevent-close-and-prevent-reset";
     }
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
index 2d6ebf9fb6..ce9402b963 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
@@ -54,9 +54,9 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
     <Dialog open={open} onOpenChange={handleClose}>
       <DialogContent className="sm:max-w-[425px]">
         <DialogHeader>
-          <DialogTitle>Create Offer Group</DialogTitle>
+          <DialogTitle>Create Product Group</DialogTitle>
           <DialogDescription>
-            Offer groups allow you to organize related offers. Customers can only have one active offer from each group at a time (except for add-ons).
+            Product groups allow you to organize related products. Customers can only have one active product from each group at a time (except for add-ons).
           </DialogDescription>
         </DialogHeader>
 
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx
index 64438ba473..cf2f5948aa 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx
@@ -6,7 +6,7 @@ export const DUMMY_PAYMENTS_CONFIG: any = {
     "enterprise": { displayName: "Enterprise" },
     "add-ons": { displayName: "Add-ons" },
   },
-  offers: {
+  products: {
     "free-trial": {
       displayName: "Free Trial",
       customerType: "user" as const,
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx
index c3739d14a1..1cbb74816a 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx
@@ -8,9 +8,9 @@ import { useState } from "react";
 type Interval = [number, 'day' | 'week' | 'month' | 'year'] | 'never';
 type ExpiresOption = 'never' | 'when-purchase-expires' | 'when-repeated';
 
-type Offer = CompleteConfig['payments']['offers'][string];
-type IncludedItem = Offer['includedItems'][string];
-type Price = (Offer['prices'] & object)[string];
+type Product = CompleteConfig['payments']['products'][string];
+type IncludedItem = Product['includedItems'][string];
+type Price = (Product['prices'] & object)[string];
 
 type IncludedItemDialogProps = {
   open: boolean,
@@ -77,7 +77,7 @@ export function IncludedItemDialog({
     if (!selectedItemId) {
       newErrors.itemId = "Please select an item";
     } else if (!editingItem && existingIncludedItemIds.includes(selectedItemId)) {
-      newErrors.itemId = "This item is already included in the offer";
+      newErrors.itemId = "This item is already included in the product";
     }
 
     // Validate quantity
@@ -135,7 +135,7 @@ export function IncludedItemDialog({
         <DialogHeader>
           <DialogTitle>{editingItem ? "Edit Included Item" : "Add Included Item"}</DialogTitle>
           <DialogDescription>
-            Configure which items are included with this offer and how they behave.
+            Configure which items are included with this product and how they behave.
           </DialogDescription>
         </DialogHeader>
 
@@ -143,7 +143,7 @@ export function IncludedItemDialog({
           {/* Item Selection */}
           <div className="grid gap-2">
             <Label htmlFor="item-select">
-              <SimpleTooltip tooltip="Choose which item to include with this offer">
+              <SimpleTooltip tooltip="Choose which item to include with this product">
                 Select Item
               </SimpleTooltip>
             </Label>
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx
index d67b995ae8..2a1f91b12c 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx
@@ -12,23 +12,23 @@ import { PriceDialog } from "./price-dialog";
 
 type Template = 'one-time' | 'subscription' | 'addon' | 'scratch';
 
-type Offer = CompleteConfig['payments']['offers'][string];
-type IncludedItem = Offer['includedItems'][string];
-type Price = (Offer['prices'] & object)[string];
+type Product = CompleteConfig['payments']['products'][string];
+type IncludedItem = Product['includedItems'][string];
+type Price = (Product['prices'] & object)[string];
 
-type OfferDialogProps = {
+type ProductDialogProps = {
   open: boolean,
   onOpenChange: (open: boolean) => void,
-  onSave: (offerId: string, offer: Offer) => Promise<void>,
-  editingOfferId?: string,
-  editingOffer?: Offer,
-  existingOffers: Array<{ id: string, displayName: string, groupId?: string, customerType: string }>,
+  onSave: (productId: string, product: Product) => Promise<void>,
+  editingProductId?: string,
+  editingProduct?: Product,
+  existingProducts: Array<{ id: string, displayName: string, groupId?: string, customerType: string }>,
   existingGroups: Record<string, { displayName: string }>,
   existingItems: Array<{ id: string, displayName: string, customerType: string }>,
   onCreateNewItem?: () => void,
 };
 
-const TEMPLATE_CONFIGS: Record<Template, Partial<Offer>> = {
+const TEMPLATE_CONFIGS: Record<Template, Partial<Product>> = {
   'one-time': {
     displayName: 'One-Time Purchase',
     stackable: false,
@@ -45,32 +45,32 @@ const TEMPLATE_CONFIGS: Record<Template, Partial<Offer>> = {
   'scratch': {}
 };
 
-export function OfferDialog({
+export function ProductDialog({
   open,
   onOpenChange,
   onSave,
-  editingOfferId,
-  editingOffer,
-  existingOffers,
+  editingProductId,
+  editingProduct,
+  existingProducts,
   existingGroups,
   existingItems,
   onCreateNewItem
-}: OfferDialogProps) {
-  const [currentStep, setCurrentStep] = useState(editingOffer ? 1 : 0);
+}: ProductDialogProps) {
+  const [currentStep, setCurrentStep] = useState(editingProduct ? 1 : 0);
 
   // Form state
-  const [offerId, setOfferId] = useState(editingOfferId ?? "");
-  const [displayName, setDisplayName] = useState(editingOffer?.displayName || "");
-  const [customerType, setCustomerType] = useState<'user' | 'team' | 'custom'>(editingOffer?.customerType || 'user');
-  const [groupId, setGroupId] = useState(editingOffer?.groupId || "");
-  const [isAddOn, setIsAddOn] = useState(!!editingOffer?.isAddOnTo);
-  const [isAddOnTo, setIsAddOnTo] = useState<string[]>(editingOffer?.isAddOnTo !== false ? Object.keys(editingOffer?.isAddOnTo || {}) : []);
-  const [stackable, setStackable] = useState(editingOffer?.stackable || false);
-  const [freeByDefault, setFreeByDefault] = useState(editingOffer?.prices === "include-by-default" || false);
-  const [prices, setPrices] = useState<Record<string, Price>>(editingOffer?.prices === "include-by-default" ? {} : editingOffer?.prices || {});
-  const [includedItems, setIncludedItems] = useState<Offer['includedItems']>(editingOffer?.includedItems || {});
-  const [freeTrial, setFreeTrial] = useState<Offer['freeTrial']>(editingOffer?.freeTrial || undefined);
-  const [serverOnly, setServerOnly] = useState(editingOffer?.serverOnly || false);
+  const [productId, setProductId] = useState(editingProductId ?? "");
+  const [displayName, setDisplayName] = useState(editingProduct?.displayName || "");
+  const [customerType, setCustomerType] = useState<'user' | 'team' | 'custom'>(editingProduct?.customerType || 'user');
+  const [groupId, setGroupId] = useState(editingProduct?.groupId || "");
+  const [isAddOn, setIsAddOn] = useState(!!editingProduct?.isAddOnTo);
+  const [isAddOnTo, setIsAddOnTo] = useState<string[]>(editingProduct?.isAddOnTo !== false ? Object.keys(editingProduct?.isAddOnTo || {}) : []);
+  const [stackable, setStackable] = useState(editingProduct?.stackable || false);
+  const [freeByDefault, setFreeByDefault] = useState(editingProduct?.prices === "include-by-default" || false);
+  const [prices, setPrices] = useState<Record<string, Price>>(editingProduct?.prices === "include-by-default" ? {} : editingProduct?.prices || {});
+  const [includedItems, setIncludedItems] = useState<Product['includedItems']>(editingProduct?.includedItems || {});
+  const [freeTrial, setFreeTrial] = useState<Product['freeTrial']>(editingProduct?.freeTrial || undefined);
+  const [serverOnly, setServerOnly] = useState(editingProduct?.serverOnly || false);
 
   // Dialog states
   const [showGroupDialog, setShowGroupDialog] = useState(false);
@@ -117,12 +117,12 @@ export function OfferDialog({
   const validateGeneralInfo = () => {
     const newErrors: Record<string, string> = {};
 
-    if (!offerId.trim()) {
-      newErrors.offerId = "Offer ID is required";
-    } else if (!/^[a-z0-9-]+$/.test(offerId)) {
-      newErrors.offerId = "Offer ID must contain only lowercase letters, numbers, and hyphens";
-    } else if (!editingOffer && existingOffers.some(o => o.id === offerId)) {
-      newErrors.offerId = "This offer ID already exists";
+    if (!productId.trim()) {
+      newErrors.productId = "Product ID is required";
+    } else if (!/^[a-z0-9-]+$/.test(productId)) {
+      newErrors.productId = "Product ID must contain only lowercase letters, numbers, and hyphens";
+    } else if (!editingProduct && existingProducts.some(o => o.id === productId)) {
+      newErrors.productId = "This product ID already exists";
     }
 
     if (!displayName.trim()) {
@@ -130,15 +130,15 @@ export function OfferDialog({
     }
 
     if (isAddOn && isAddOnTo.length === 0) {
-      newErrors.isAddOnTo = "Please select at least one offer this is an add-on to";
+      newErrors.isAddOnTo = "Please select at least one product this is an add-on to";
     }
 
     if (isAddOn && isAddOnTo.length > 0) {
       const addOnGroups = new Set(
-        isAddOnTo.map(offerId => existingOffers.find(o => o.id === offerId)?.groupId)
+        isAddOnTo.map(productId => existingProducts.find(o => o.id === productId)?.groupId)
       );
       if (addOnGroups.size > 1) {
-        newErrors.isAddOnTo = "All selected offers must be in the same group";
+        newErrors.isAddOnTo = "All selected products must be in the same group";
       }
     }
 
@@ -159,11 +159,11 @@ export function OfferDialog({
   };
 
   const handleBack = () => {
-    setCurrentStep(prev => Math.max(prev - 1, editingOffer ? 1 : 0));
+    setCurrentStep(prev => Math.max(prev - 1, editingProduct ? 1 : 0));
   };
 
   const handleSave = async () => {
-    const offer: Offer = {
+    const product: Product = {
       displayName,
       customerType,
       groupId: groupId || undefined,
@@ -175,15 +175,15 @@ export function OfferDialog({
       freeTrial,
     };
 
-    await onSave(offerId, offer);
+    await onSave(productId, product);
     handleClose();
   };
 
   const handleClose = () => {
     // Reset form
-    if (!editingOffer) {
+    if (!editingProduct) {
       setCurrentStep(0);
-      setOfferId("");
+      setProductId("");
       setDisplayName("");
       setCustomerType('user');
       setGroupId("");
@@ -265,15 +265,15 @@ export function OfferDialog({
     return display;
   };
 
-  const isFirstOffer = existingOffers.length === 0;
+  const isFirstProduct = existingProducts.length === 0;
 
   return (
     <>
       <Dialog open={open} onOpenChange={handleClose}>
         <DialogContent className="max-w-2xl">
           <Stepper currentStep={currentStep} onStepChange={setCurrentStep} className="min-h-[400px]">
-            {/* Step 0: Template Selection (only for new offers) */}
-            {!editingOffer && (
+            {/* Step 0: Template Selection (only for new products) */}
+            {!editingProduct && (
               <StepperPage>
                 <div className="space-y-4">
                   <div>
@@ -322,7 +322,7 @@ export function OfferDialog({
                       </CardHeader>
                     </Card>
 
-                    {!isFirstOffer && <Card
+                    {!isFirstProduct && <Card
                       className="cursor-pointer hover:border-primary transition-colors"
                       onClick={() => applyTemplate('addon')}
                     >
@@ -334,7 +334,7 @@ export function OfferDialog({
                           <div>
                             <CardTitle className="text-base">Add-on</CardTitle>
                             <CardDescription className="text-sm mt-1">
-                              Additional features that complement existing offers
+                              Additional features that complement existing products
                             </CardDescription>
                           </div>
                         </div>
@@ -353,7 +353,7 @@ export function OfferDialog({
                           <div>
                             <CardTitle className="text-base">Create from Scratch</CardTitle>
                             <CardDescription className="text-sm mt-1">
-                              Start with a blank offer and configure everything yourself
+                              Start with a blank product and configure everything yourself
                             </CardDescription>
                           </div>
                         </div>
@@ -370,38 +370,38 @@ export function OfferDialog({
                 <div>
                   <DialogTitle>General Information</DialogTitle>
                   <Typography type="p" className="text-muted-foreground mt-1">
-                    Configure the basic details of your offer
+                    Configure the basic details of your product
                   </Typography>
                 </div>
 
                 <div className="grid gap-4 mt-6">
-                  {/* Offer ID */}
+                  {/* Product ID */}
                   <div className="grid gap-2">
-                    <Label htmlFor="offer-id">Offer ID</Label>
+                    <Label htmlFor="product-id">Product ID</Label>
                     <Input
-                      id="offer-id"
-                      value={offerId}
+                      id="product-id"
+                      value={productId}
                       onChange={(e) => {
-                        setOfferId(e.target.value);
-                        if (errors.offerId) {
+                        setProductId(e.target.value);
+                        if (errors.productId) {
                           setErrors(prev => {
                             const newErrors = { ...prev };
-                            delete newErrors.offerId;
+                            delete newErrors.productId;
                             return newErrors;
                           });
                         }
                       }}
                       placeholder="e.g., pro-plan"
-                      disabled={!!editingOffer}
-                      className={errors.offerId ? "border-destructive" : ""}
+                      disabled={!!editingProduct}
+                      className={errors.productId ? "border-destructive" : ""}
                     />
-                    {errors.offerId ? (
+                    {errors.productId ? (
                       <Typography type="label" className="text-destructive">
-                        {errors.offerId}
+                        {errors.productId}
                       </Typography>
                     ) : (
                       <Typography type="label" className="text-muted-foreground">
-                        Unique identifier used to reference this offer in code
+                        Unique identifier used to reference this product in code
                       </Typography>
                     )}
                   </div>
@@ -431,7 +431,7 @@ export function OfferDialog({
                       </Typography>
                     ) : (
                       <Typography type="label" className="text-muted-foreground">
-                        How this offer will be displayed to customers
+                        How this product will be displayed to customers
                       </Typography>
                     )}
                   </div>
@@ -450,13 +450,13 @@ export function OfferDialog({
                       </SelectContent>
                     </Select>
                     <Typography type="label" className="text-muted-foreground">
-                      The type of customer this offer is for
+                      The type of customer this product is for
                     </Typography>
                   </div>
 
                   {/* Group */}
                   <div className="grid gap-2">
-                    <Label htmlFor="group">Offer Group (Optional)</Label>
+                    <Label htmlFor="group">Product Group (Optional)</Label>
                     <Select
                       value={groupId || 'no-group'}
                       onValueChange={(value) => {
@@ -485,7 +485,7 @@ export function OfferDialog({
                       </SelectContent>
                     </Select>
                     <Typography type="label" className="text-muted-foreground">
-                      Customers can only have one active offer per group (except add-ons)
+                      Customers can only have one active product per group (except add-ons)
                     </Typography>
                   </div>
 
@@ -501,11 +501,11 @@ export function OfferDialog({
                     </Label>
                   </div>
                   <Typography type="label" className="text-muted-foreground -mt-2">
-                    Allow customers to purchase this offer multiple times
+                    Allow customers to purchase this product multiple times
                   </Typography>
 
-                  {/* Add-on (only if not the first offer) */}
-                  {!isFirstOffer && (
+                  {/* Add-on (only if not the first product) */}
+                  {!isFirstProduct && (
                     <>
                       <div className="flex items-center space-x-2">
                         <Checkbox
@@ -532,18 +532,18 @@ export function OfferDialog({
 
                       {isAddOn && (
                         <div className="grid gap-2">
-                          <Label>Add-on to offers</Label>
+                          <Label>Add-on to products</Label>
                           <div className="space-y-2 max-h-40 overflow-y-auto border rounded-lg p-2">
-                            {existingOffers.filter(o => !o.id.startsWith('addon')).map(offer => (
-                              <div key={offer.id} className="flex items-center space-x-2">
+                            {existingProducts.filter(o => !o.id.startsWith('addon')).map(product => (
+                              <div key={product.id} className="flex items-center space-x-2">
                                 <Checkbox
-                                  id={`addon-to-${offer.id}`}
-                                  checked={isAddOnTo.includes(offer.id)}
+                                  id={`addon-to-${product.id}`}
+                                  checked={isAddOnTo.includes(product.id)}
                                   onCheckedChange={(checked) => {
                                     if (checked) {
-                                      setIsAddOnTo(prev => [...prev, offer.id]);
+                                      setIsAddOnTo(prev => [...prev, product.id]);
                                     } else {
-                                      setIsAddOnTo(prev => prev.filter(id => id !== offer.id));
+                                      setIsAddOnTo(prev => prev.filter(id => id !== product.id));
                                     }
                                     if (errors.isAddOnTo) {
                                       setErrors(prev => {
@@ -554,11 +554,11 @@ export function OfferDialog({
                                     }
                                   }}
                                 />
-                                <Label htmlFor={`addon-to-${offer.id}`} className="cursor-pointer text-sm">
-                                  {offer.displayName} ({offer.id})
-                                  {offer.groupId && (
+                                <Label htmlFor={`addon-to-${product.id}`} className="cursor-pointer text-sm">
+                                  {product.displayName} ({product.id})
+                                  {product.groupId && (
                                     <span className="text-muted-foreground ml-1">
-                                      • {existingGroups[offer.groupId].displayName || offer.groupId}
+                                      • {existingGroups[product.groupId].displayName || product.groupId}
                                     </span>
                                   )}
                                 </Label>
@@ -571,7 +571,7 @@ export function OfferDialog({
                             </Typography>
                           )}
                           <Typography type="label" className="text-muted-foreground">
-                            Customers must have one of these offers to purchase this add-on
+                            Customers must have one of these products to purchase this add-on
                           </Typography>
                         </div>
                       )}
@@ -587,7 +587,7 @@ export function OfferDialog({
                 <div>
                   <DialogTitle>Pricing</DialogTitle>
                   <Typography type="p" className="text-muted-foreground mt-1">
-                    Configure how customers will pay for this offer
+                    Configure how customers will pay for this product
                   </Typography>
                 </div>
 
@@ -609,7 +609,7 @@ export function OfferDialog({
                     </Label>
                   </div>
                   <Typography type="label" className="text-muted-foreground -mt-2">
-                    This offer will be automatically included for all customers at no cost
+                    This product will be automatically included for all customers at no cost
                   </Typography>
 
                   {/* Prices list */}
@@ -679,7 +679,7 @@ export function OfferDialog({
                 <div>
                   <DialogTitle>Included Items</DialogTitle>
                   <Typography type="p" className="text-muted-foreground mt-1">
-                    Select which items customers receive with this offer
+                    Select which items customers receive with this product
                   </Typography>
                 </div>
 
@@ -695,7 +695,7 @@ export function OfferDialog({
                       <div className="p-8 text-center text-muted-foreground">
                         <Typography type="p">No items included yet</Typography>
                         <Typography type="p" className="text-sm mt-1">
-                          Click the + button to include items with this offer
+                          Click the + button to include items with this product
                         </Typography>
                       </div>
                     ) : (
@@ -742,7 +742,7 @@ export function OfferDialog({
 
           <DialogFooter className="flex justify-between">
             <div className="flex gap-2">
-              {currentStep > (editingOffer ? 1 : 0) && (
+              {currentStep > (editingProduct ? 1 : 0) && (
                 <Button variant="outline" onClick={handleBack}>
                   <ArrowLeft className="h-4 w-4 mr-2" />
                   Back
@@ -760,7 +760,7 @@ export function OfferDialog({
                 </Button>
               ) : (
                 <Button onClick={handleSave}>
-                  {editingOffer ? "Save Changes" : "Create Offer"}
+                  {editingProduct ? "Save Changes" : "Create Product"}
                 </Button>
               )}
             </div>}
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
index eb500d8ca9..5dedd76670 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
@@ -9,31 +9,31 @@ import { prettyPrintWithMagnitudes } from "@stackframe/stack-shared/dist/utils/n
 import { typedEntries } from "@stackframe/stack-shared/dist/utils/objects";
 import { stringCompare } from "@stackframe/stack-shared/dist/utils/strings";
 import {
-  ActionDialog,
-  Button,
-  Collapsible,
-  CollapsibleContent,
-  CollapsibleTrigger,
-  DropdownMenu,
-  DropdownMenuCheckboxItem,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-  Input,
-  Label,
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-  Separator,
-  SimpleTooltip,
-  Switch,
-  toast
+    ActionDialog,
+    Button,
+    Collapsible,
+    CollapsibleContent,
+    CollapsibleTrigger,
+    DropdownMenu,
+    DropdownMenuCheckboxItem,
+    DropdownMenuContent,
+    DropdownMenuItem,
+    DropdownMenuSeparator,
+    DropdownMenuTrigger,
+    Input,
+    Label,
+    Popover,
+    PopoverContent,
+    PopoverTrigger,
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+    Separator,
+    SimpleTooltip,
+    Switch,
+    toast
 } from "@stackframe/stack-ui";
 import { Check, ChevronDown, ChevronsUpDown, Layers, MoreVertical, Pencil, PencilIcon, Plus, Puzzle, Server, Trash2, X } from "lucide-react";
 import { Fragment, useEffect, useId, useMemo, useRef, useState } from "react";
@@ -42,11 +42,11 @@ import { PageLayout } from "../../page-layout";
 import { useAdminApp } from "../../use-admin-app";
 import { DUMMY_PAYMENTS_CONFIG } from "./dummy-data";
 import { ItemDialog } from "./item-dialog";
-import { OfferDialog } from "./offer-dialog";
+import { ProductDialog } from "./product-dialog";
 
-type Offer = CompleteConfig['payments']['offers'][keyof CompleteConfig['payments']['offers']];
-type Price = (Offer['prices'] & object)[string];
-type PricesObject = Exclude<Offer['prices'], 'include-by-default'>;
+type Product = CompleteConfig['payments']['products'][keyof CompleteConfig['payments']['products']];
+type Price = (Product['prices'] & object)[string];
+type PricesObject = Exclude<Product['prices'], 'include-by-default'>;
 
 
 function intervalLabel(tuple: DayInterval | undefined): string | null {
@@ -244,7 +244,7 @@ function IntervalPopover({
 }
 
 
-function OfferPriceRow({
+function ProductPriceRow({
   priceId,
   price,
   readOnly,
@@ -254,10 +254,10 @@ function OfferPriceRow({
   existingPriceIds,
 }: {
   priceId: string,
-  price: (Offer['prices'] & object)[string],
+  price: (Product['prices'] & object)[string],
   readOnly?: boolean,
   startEditing?: boolean,
-  onSave: (newId: string | undefined, price: (Offer['prices'] & object)[string]) => void,
+  onSave: (newId: string | undefined, price: (Product['prices'] & object)[string]) => void,
   onRemove?: () => void,
   existingPriceIds: string[],
 }) {
@@ -361,7 +361,7 @@ function OfferPriceRow({
   );
 }
 
-const EXPIRES_OPTIONS: Array<{ value: Offer["includedItems"][string]["expires"], label: string, description: string }> = [
+const EXPIRES_OPTIONS: Array<{ value: Product["includedItems"][string]["expires"], label: string, description: string }> = [
   {
     value: 'never' as const,
     label: 'Never expires',
@@ -379,7 +379,7 @@ const EXPIRES_OPTIONS: Array<{ value: Offer["includedItems"][string]["expires"],
   }
 ];
 
-function OfferItemRow({
+function ProductItemRow({
   activeType,
   itemId,
   item,
@@ -395,11 +395,11 @@ function OfferItemRow({
 }: {
   activeType: 'user' | 'team' | 'custom',
   itemId: string,
-  item: Offer['includedItems'][string],
+  item: Product['includedItems'][string],
   itemDisplayName: string,
   readOnly?: boolean,
   startEditing?: boolean,
-  onSave: (itemId: string, item: Offer['includedItems'][string]) => void,
+  onSave: (itemId: string, item: Product['includedItems'][string]) => void,
   onRemove?: () => void,
   allItems: Array<{ id: string, displayName: string, customerType: string }>,
   existingIncludedItemIds: string[],
@@ -431,7 +431,7 @@ function OfferItemRow({
 
   const updateParent = (raw: string) => {
     const normalized = raw === '' ? 0 : parseInt(raw, 10);
-    const updated: Offer['includedItems'][string] = { ...item, quantity: Number.isNaN(normalized) ? 0 : normalized };
+    const updated: Product['includedItems'][string] = { ...item, quantity: Number.isNaN(normalized) ? 0 : normalized };
     onSave(itemId, updated);
   };
 
@@ -519,7 +519,7 @@ function OfferItemRow({
             noneLabel="one time"
             onChange={(interval) => {
               if (readOnly) return;
-              const updated: Offer['includedItems'][string] = {
+              const updated: Product['includedItems'][string] = {
                 ...item,
                 repeat: interval ? interval : 'never',
               };
@@ -621,34 +621,34 @@ function OfferItemRow({
 }
 
 
-type OfferCardProps = {
+type ProductCardProps = {
   id: string,
   activeType: 'user' | 'team' | 'custom',
-  offer: Offer,
-  allOffers: Array<{ id: string, offer: Offer }>,
+  product: Product,
+  allProducts: Array<{ id: string, product: Product }>,
   existingItems: Array<{ id: string, displayName: string, customerType: string }>,
-  onSave: (id: string, offer: Offer) => Promise<void>,
+  onSave: (id: string, product: Product) => Promise<void>,
   onDelete: (id: string) => Promise<void>,
-  onDuplicate: (offer: Offer) => void,
+  onDuplicate: (product: Product) => void,
   onCreateNewItem: () => void,
-  onOpenDetails: (offer: Offer) => void,
+  onOpenDetails: (product: Product) => void,
   isDraft?: boolean,
   onCancelDraft?: () => void,
 };
 
-function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, onDelete, onDuplicate, onCreateNewItem, onOpenDetails, isDraft, onCancelDraft }: OfferCardProps) {
+function ProductCard({ id, activeType, product, allProducts, existingItems, onSave, onDelete, onDuplicate, onCreateNewItem, onOpenDetails, isDraft, onCancelDraft }: ProductCardProps) {
   const [isEditing, setIsEditing] = useState(!!isDraft);
-  const [draft, setDraft] = useState<Offer>(offer);
+  const [draft, setDraft] = useState<Product>(product);
   const [showDeleteDialog, setShowDeleteDialog] = useState(false);
   const [editingPriceId, setEditingPriceId] = useState<string | undefined>(undefined);
   const cardRef = useRef<HTMLDivElement | null>(null);
   const [hasAutoScrolled, setHasAutoScrolled] = useState(false);
-  const [localOfferId, setLocalOfferId] = useState<string>(id);
+  const [localProductId, setLocalProductId] = useState<string>(id);
 
   useEffect(() => {
-    setDraft(offer);
-    setLocalOfferId(id);
-  }, [offer, id]);
+    setDraft(product);
+    setLocalProductId(id);
+  }, [product, id]);
 
   useEffect(() => {
     if (isDraft && !hasAutoScrolled && cardRef.current) {
@@ -659,8 +659,8 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
 
   const pricesObject: PricesObject = typeof draft.prices === 'object' ? draft.prices : {};
 
-  const canSaveOffer = draft.prices === 'include-by-default' || (typeof draft.prices === 'object' && Object.keys(pricesObject).length > 0);
-  const saveDisabledReason = canSaveOffer ? undefined : "Add at least one price or set Include by default";
+  const canSaveProduct = draft.prices === 'include-by-default' || (typeof draft.prices === 'object' && Object.keys(pricesObject).length > 0);
+  const saveDisabledReason = canSaveProduct ? undefined : "Add at least one price or set Include by default";
 
   const handleRemovePrice = (priceId: string) => {
     setDraft(prev => {
@@ -672,7 +672,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
     if (editingPriceId === priceId) setEditingPriceId(undefined);
   };
 
-  const handleAddOrEditIncludedItem = (itemId: string, item: Offer['includedItems'][string]) => {
+  const handleAddOrEditIncludedItem = (itemId: string, item: Product['includedItems'][string]) => {
     setDraft(prev => ({
       ...prev,
       includedItems: {
@@ -684,7 +684,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
 
   const handleRemoveIncludedItem = (itemId: string) => {
     setDraft(prev => {
-      const next: Offer['includedItems'] = { ...prev.includedItems };
+      const next: Product['includedItems'] = { ...prev.includedItems };
       delete next[itemId];
       return { ...prev, includedItems: next };
     });
@@ -704,7 +704,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
       <div className="space-y-3 shrink-0">
         {entries.map(([pid, price], index) => (
           <Fragment key={pid}>
-            <OfferPriceRow
+            <ProductPriceRow
               key={pid}
               priceId={pid}
               price={price}
@@ -741,13 +741,13 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
 
   const itemsList = Object.entries(draft.includedItems);
 
-  const couldBeAddOnTo = allOffers.filter(o => o.offer.groupId === draft.groupId && o.id !== id);
-  const isAddOnTo = allOffers.filter(o => draft.isAddOnTo && o.id in draft.isAddOnTo);
+  const couldBeAddOnTo = allProducts.filter(o => o.product.groupId === draft.groupId && o.id !== id);
+  const isAddOnTo = allProducts.filter(o => draft.isAddOnTo && o.id in draft.isAddOnTo);
 
-  const OFFER_TOGGLE_OPTIONS = [{
+  const PRODUCT_TOGGLE_OPTIONS = [{
     key: 'serverOnly' as const,
     label: 'Server only',
-    description: "Restricts this offer to only be purchased from server-side calls",
+    description: "Restricts this product to only be purchased from server-side calls",
     active: !!draft.serverOnly,
     visible: true,
     icon: <Server size={16} />,
@@ -756,7 +756,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
   }, {
     key: 'stackable' as const,
     label: 'Stackable',
-    description: "Allow customers to purchase this offer multiple times",
+    description: "Allow customers to purchase this product multiple times",
     active: !!draft.stackable,
     visible: true,
     icon: <Layers size={16} />,
@@ -765,7 +765,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
   }, {
     key: 'addon' as const,
     label: 'Add-on',
-    description: "Make this offer an add-on. An add-on can be purchased along with the offer(s) it is an add-on to.",
+    description: "Make this product an add-on. An add-on can be purchased along with the product(s) it is an add-on to.",
     visible: draft.isAddOnTo !== false || couldBeAddOnTo.length > 0,
     active: draft.isAddOnTo !== false,
     icon: <Puzzle size={16} />,
@@ -776,22 +776,22 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
           {button}
         </DropdownMenuTrigger>
         <DropdownMenuContent>
-          {couldBeAddOnTo.map(offer => (
+          {couldBeAddOnTo.map(product => (
             <DropdownMenuCheckboxItem
-              checked={isAddOnTo.some(o => o.id === offer.id)}
-              key={offer.id}
+              checked={isAddOnTo.some(o => o.id === product.id)}
+              key={product.id}
               onCheckedChange={(checked) => setDraft(prev => {
                 const newIsAddOnTo = { ...prev.isAddOnTo || {} };
                 if (checked) {
-                  newIsAddOnTo[offer.id] = true;
+                  newIsAddOnTo[product.id] = true;
                 } else {
-                  delete newIsAddOnTo[offer.id];
+                  delete newIsAddOnTo[product.id];
                 }
                 return { ...prev, isAddOnTo: Object.keys(newIsAddOnTo).length > 0 ? newIsAddOnTo : false };
               })}
               className="cursor-pointer"
             >
-              {offer.offer.displayName} ({offer.id})
+              {product.product.displayName} ({product.id})
             </DropdownMenuCheckboxItem>
           ))}
         </DropdownMenuContent>
@@ -809,9 +809,9 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
           <div className="flex flex-col gap-2 w-full">
             <div className="flex items-center gap-2">
               <div className="grow flex flex-row justify-end">
-                <SimpleTooltip tooltip={saveDisabledReason} disabled={canSaveOffer}>
+                <SimpleTooltip tooltip={saveDisabledReason} disabled={canSaveProduct}>
                   <Button size="icon" variant="ghost" onClick={async () => {
-                    const trimmed = localOfferId.trim();
+                    const trimmed = localProductId.trim();
                     const validId = trimmed && /^[a-z0-9-]+$/.test(trimmed) ? trimmed : id;
                     if (validId !== id) {
                       await onSave(validId, draft);
@@ -821,7 +821,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
                     }
                     setIsEditing(false);
                     setEditingPriceId(undefined);
-                  }} disabled={!canSaveOffer}>
+                  }} disabled={!canSaveProduct}>
                     <Check className="text-green-500" />
                   </Button>
                 </SimpleTooltip>
@@ -834,7 +834,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
                       return;
                     }
                     setIsEditing(false);
-                    setDraft(offer);
+                    setDraft(product);
                     setEditingPriceId(undefined);
                   }}
                   aria-label="Cancel edit"
@@ -847,25 +847,25 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
         )}
         <div className="flex justify-center flex-col items-center w-full">
           <EditableInput
-            value={localOfferId}
-            onUpdate={async (value) => setLocalOfferId(value)}
+            value={localProductId}
+            onUpdate={async (value) => setLocalProductId(value)}
             readOnly={!isDraft || !isEditing}
-            placeholder={"Offer ID"}
+            placeholder={"Product ID"}
             inputClassName="text-xs font-mono text-center text-muted-foreground"
           />
           <EditableInput
             value={draft.displayName || ""}
             onUpdate={async (value) => setDraft(prev => ({ ...prev, displayName: value }))}
             readOnly={!isEditing}
-            placeholder={"Offer display name"}
+            placeholder={"Product display name"}
             inputClassName="text-lg font-bold text-center w-full"
           />
         </div>
         {!isEditing && (
           <div className="absolute top-4 right-4 opacity-0 group-hover:opacity-100 transition-opacity">
-            <button className="h-7 w-7 inline-flex items-center justify-center rounded hover:bg-muted" aria-label="Edit offer" onClick={() => {
+            <button className="h-7 w-7 inline-flex items-center justify-center rounded hover:bg-muted" aria-label="Edit product" onClick={() => {
               setIsEditing(true);
-              setDraft(offer);
+              setDraft(product);
             }}>
               <PencilIcon className="h-4 w-4" />
             </button>
@@ -878,11 +878,11 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
               <DropdownMenuContent align="end" className="min-w-[160px]">
                 <DropdownMenuItem onClick={() => {
                   setIsEditing(true);
-                  setDraft(offer);
+                  setDraft(product);
                 }}>
                   Edit
                 </DropdownMenuItem>
-                <DropdownMenuItem onClick={() => { onDuplicate(offer); }}>
+                <DropdownMenuItem onClick={() => { onDuplicate(product); }}>
                   Duplicate
                 </DropdownMenuItem>
                 <DropdownMenuSeparator />
@@ -896,7 +896,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
       </div>
       {/* Toggles row */}
       <div className="px-4 pb-3 pt-1 flex flex-wrap gap-2 justify-center text-muted-foreground">
-        {OFFER_TOGGLE_OPTIONS.filter(b => b.visible !== false).filter(b => isEditing || b.active).map((b) => (
+        {PRODUCT_TOGGLE_OPTIONS.filter(b => b.visible !== false).filter(b => isEditing || b.active).map((b) => (
           <SimpleTooltip tooltip={b.description} key={b.key}>
             {(isEditing ? b.wrapButton : ((x: any) => x))(
               <button
@@ -908,7 +908,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
                 onClick={isEditing ? b.onToggle : undefined}
               >
                 {b.icon}
-                {b.key === "addon" && isAddOnTo.length > 0 ? `Add-on to ${isAddOnTo.map(o => o.offer.displayName).join(", ")}` : b.label}
+                {b.key === "addon" && isAddOnTo.length > 0 ? `Add-on to ${isAddOnTo.map(o => o.product.displayName).join(", ")}` : b.label}
               </button>
             )}
           </SimpleTooltip>
@@ -950,7 +950,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
               const itemMeta = existingItems.find(i => i.id === itemId);
               const itemLabel = itemMeta ? (itemMeta.displayName || itemMeta.id) : 'Select item';
               return (
-                <OfferItemRow
+                <ProductItemRow
                   key={itemId}
                   activeType={activeType}
                   itemId={itemId}
@@ -967,7 +967,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
                         toast({ title: "Item already included" });
                         return prev;
                       }
-                      const next: Offer['includedItems'] = { ...prev.includedItems };
+                      const next: Product['includedItems'] = { ...prev.includedItems };
                       const value = next[itemId];
                       delete next[itemId];
                       next[newItemId] = value;
@@ -991,7 +991,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
               onClick={() => {
                 const available = existingItems.find(i => !Object.prototype.hasOwnProperty.call(draft.includedItems, i.id));
                 const newItemId = available?.id || `__new_item__${Date.now().toString(36).slice(2, 8)}`;
-                const newItem: Offer['includedItems'][string] = { quantity: 1, repeat: 'never', expires: 'never' };
+                const newItem: Product['includedItems'][string] = { quantity: 1, repeat: 'never', expires: 'never' };
                 setDraft(prev => ({
                   ...prev,
                   includedItems: {
@@ -1009,7 +1009,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
         <div className="border-t p-4">
           <CodeBlock
             language="typescript"
-            content={`const checkoutUrl = await ${activeType === "user" ? "user" : "team"}.createCheckoutUrl({ offerId: "${id}" });\nwindow.open(checkoutUrl, "_blank");`}
+            content={`const checkoutUrl = await ${activeType === "user" ? "user" : "team"}.createCheckoutUrl({ productId: "${id}" });\nwindow.open(checkoutUrl, "_blank");`}
             title="Checkout"
             icon="code"
             compact
@@ -1020,7 +1020,7 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
       <ActionDialog
         open={showDeleteDialog}
         onOpenChange={setShowDeleteDialog}
-        title="Delete offer"
+        title="Delete product"
         danger
         okButton={{
           label: "Delete",
@@ -1031,38 +1031,38 @@ function OfferCard({ id, activeType, offer, allOffers, existingItems, onSave, on
         }}
         cancelButton
       >
-        Are you sure you want to delete this offer?
+        Are you sure you want to delete this product?
       </ActionDialog>
     </div >
   );
 }
 
 type CatalogViewProps = {
-  groupedOffers: Map<string | undefined, Array<{ id: string, offer: Offer }>>,
+  groupedProducts: Map<string | undefined, Array<{ id: string, product: Product }>>,
   groups: Record<string, { displayName?: string }>,
   existingItems: Array<{ id: string, displayName: string, customerType: string }>,
-  onSaveOffer: (id: string, offer: Offer) => Promise<void>,
-  onDeleteOffer: (id: string) => Promise<void>,
+  onSaveProduct: (id: string, product: Product) => Promise<void>,
+  onDeleteProduct: (id: string) => Promise<void>,
   onCreateNewItem: () => void,
-  onOpenOfferDetails: (offer: Offer) => void,
-  onSaveOfferWithGroup: (groupId: string, offerId: string, offer: Offer) => Promise<void>,
+  onOpenProductDetails: (product: Product) => void,
+  onSaveProductWithGroup: (groupId: string, productId: string, product: Product) => Promise<void>,
 };
 
-function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDeleteOffer, onCreateNewItem, onOpenOfferDetails, onSaveOfferWithGroup }: CatalogViewProps) {
+function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, onDeleteProduct, onCreateNewItem, onOpenProductDetails, onSaveProductWithGroup }: CatalogViewProps) {
   const [activeType, setActiveType] = useState<'user' | 'team' | 'custom'>('user');
-  const [drafts, setDrafts] = useState<Array<{ key: string, groupId: string | undefined, offer: Offer }>>([]);
+  const [drafts, setDrafts] = useState<Array<{ key: string, groupId: string | undefined, product: Product }>>([]);
   const [creatingGroupKey, setCreatingGroupKey] = useState<string | undefined>(undefined);
   const [newGroupId, setNewGroupId] = useState("");
   const newGroupInputRef = useRef<HTMLInputElement | null>(null);
 
   const filtered = useMemo(() => {
-    const res = new Map<string | undefined, Array<{ id: string, offer: Offer }>>();
-    groupedOffers.forEach((offers, gid) => {
-      const f = offers.filter(o => o.offer.customerType === activeType);
+    const res = new Map<string | undefined, Array<{ id: string, product: Product }>>();
+    groupedProducts.forEach((products, gid) => {
+      const f = products.filter(o => o.product.customerType === activeType);
       if (f.length) res.set(gid, f);
     });
     return res;
-  }, [groupedOffers, activeType]);
+  }, [groupedProducts, activeType]);
 
   useEffect(() => {
     if (creatingGroupKey && newGroupInputRef.current) {
@@ -1086,12 +1086,12 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
 
   const usedIds = useMemo(() => {
     const all: string[] = [];
-    groupedOffers.forEach(arr => arr.forEach(({ id }) => all.push(id)));
+    groupedProducts.forEach(arr => arr.forEach(({ id }) => all.push(id)));
     drafts.forEach(d => all.push(d.key));
     return new Set(all);
-  }, [groupedOffers, drafts]);
+  }, [groupedProducts, drafts]);
 
-  const generateOfferId = (base: string) => {
+  const generateProductId = (base: string) => {
     let id = base;
     let i = 2;
     while (usedIds.has(id)) id = `${base}-${i++}`;
@@ -1100,7 +1100,7 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
 
   const groupIdsToRender = useMemo(() => {
     const s = new Set<string | undefined>();
-    filtered.forEach((_offers, gid) => s.add(gid));
+    filtered.forEach((_products, gid) => s.add(gid));
     const arr = Array.from(s.values());
     const withoutUndefined = arr.filter((gid): gid is string => gid !== undefined);
     const ordered: Array<string | undefined> = [...withoutUndefined, undefined];
@@ -1128,7 +1128,7 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
 
       {groupIdsToRender.map((groupId) => {
         const isNewGroupPlaceholder = !!creatingGroupKey && groupId === creatingGroupKey;
-        const offers = isNewGroupPlaceholder ? [] : (filtered.get(groupId) || []);
+        const products = isNewGroupPlaceholder ? [] : (filtered.get(groupId) || []);
         const groupName = !isNewGroupPlaceholder ? (groupId ? ((groups[groupId].displayName || groupId)) : 'No catalog') : '';
         return (
           <div key={groupId || 'ungrouped'}>
@@ -1159,39 +1159,39 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
             <div className="relative rounded-xl bg-slate-100 dark:bg-muted border-slate-100 dark:border-muted border-2">
               <div className="flex gap-4 justify-start overflow-x-auto p-4 min-h-20 pr-16">
                 <div className="flex max-w-max gap-4 items-start">
-                  {offers.map(({ id, offer }) => (
-                    <OfferCard
+                  {products.map(({ id, product }) => (
+                    <ProductCard
                       key={id}
                       id={id}
                       activeType={activeType}
-                      offer={offer}
-                      allOffers={offers}
+                      product={product}
+                      allProducts={products}
                       existingItems={existingItems}
-                      onSave={onSaveOffer}
-                      onDelete={onDeleteOffer}
-                      onDuplicate={(srcOffer) => {
-                        const key = generateOfferId("offer");
-                        const duplicated: Offer = {
-                          ...srcOffer,
-                          displayName: `${srcOffer.displayName || id} Copy`,
+                      onSave={onSaveProduct}
+                      onDelete={onDeleteProduct}
+                      onDuplicate={(srcProduct) => {
+                        const key = generateProductId("product");
+                        const duplicated: Product = {
+                          ...srcProduct,
+                          displayName: `${srcProduct.displayName || id} Copy`,
                         };
-                        setDrafts(prev => [...prev, { key, groupId, offer: duplicated }]);
+                        setDrafts(prev => [...prev, { key, groupId, product: duplicated }]);
                       }}
                       onCreateNewItem={onCreateNewItem}
-                      onOpenDetails={(o) => onOpenOfferDetails(o)}
+                      onOpenDetails={(o) => onOpenProductDetails(o)}
                     />
                   ))}
-                  {drafts.filter(d => d.groupId === groupId && d.offer.customerType === activeType).map((d) => (
-                    <OfferCard
+                  {drafts.filter(d => d.groupId === groupId && d.product.customerType === activeType).map((d) => (
+                    <ProductCard
                       key={d.key}
                       id={d.key}
                       activeType={activeType}
-                      offer={d.offer}
-                      allOffers={offers}
+                      product={d.product}
+                      allProducts={products}
                       existingItems={existingItems}
                       isDraft
-                      onSave={async (_ignoredId, offer) => {
-                        const newId = generateOfferId('offer');
+                      onSave={async (_ignoredId, product) => {
+                        const newId = generateProductId('product');
                         if (isNewGroupPlaceholder) {
                           const id = newGroupId.trim();
                           if (!id) {
@@ -1206,14 +1206,14 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
                             alert("Catalog ID already exists");
                             return;
                           }
-                          const offerWithGroup: Offer = { ...offer, groupId: id };
-                          await onSaveOfferWithGroup(id, newId, offerWithGroup);
+                          const productWithGroup: Product = { ...product, groupId: id };
+                          await onSaveProductWithGroup(id, newId, productWithGroup);
                           setCreatingGroupKey(undefined);
                           setNewGroupId("");
                           setDrafts(prev => prev.filter(x => x.key !== d.key));
                           return;
                         }
-                        await onSaveOffer(newId, offer);
+                        await onSaveProduct(newId, product);
                         setDrafts(prev => prev.filter(x => x.key !== d.key));
                       }}
                       onDelete={async () => {
@@ -1225,10 +1225,10 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
                       }}
                       onDuplicate={() => {
                         const cloneKey = `${d.key}-copy`;
-                        setDrafts(prev => ([...prev, { key: cloneKey, groupId: d.groupId, offer: { ...d.offer, displayName: `${d.offer.displayName} Copy` } }]));
+                        setDrafts(prev => ([...prev, { key: cloneKey, groupId: d.groupId, product: { ...d.product, displayName: `${d.product.displayName} Copy` } }]));
                       }}
                       onCreateNewItem={onCreateNewItem}
-                      onOpenDetails={(o) => onOpenOfferDetails(o)}
+                      onOpenDetails={(o) => onOpenProductDetails(o)}
                       onCancelDraft={() => {
                         setDrafts(prev => prev.filter(x => x.key !== d.key));
                         if (isNewGroupPlaceholder) {
@@ -1245,9 +1245,9 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
                           variant="outline"
                           className="h-10 w-10 rounded-full p-0"
                           onClick={() => {
-                            const key = generateOfferId("offer");
-                            const newOffer: Offer = {
-                              displayName: 'New Offer',
+                            const key = generateProductId("product");
+                            const newProduct: Product = {
+                              displayName: 'New Product',
                               customerType: activeType,
                               groupId: groupId || undefined,
                               isAddOnTo: false,
@@ -1257,12 +1257,12 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
                               serverOnly: false,
                               freeTrial: undefined,
                             };
-                            setDrafts(prev => [...prev, { key, groupId, offer: newOffer }]);
+                            setDrafts(prev => [...prev, { key, groupId, product: newProduct }]);
                           }}
                         >
                           <Plus className="h-8 w-8" />
                         </Button>
-                        Create offer
+                        Create product
                       </div>
                     </div>
                   )}
@@ -1283,9 +1283,9 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
               const tempKey = `__new_catalog__${Date.now().toString(36).slice(2, 8)}`;
               setCreatingGroupKey(tempKey);
               setNewGroupId("");
-              const draftKey = generateOfferId("offer");
-              const newOffer: Offer = {
-                displayName: 'New Offer',
+              const draftKey = generateProductId("product");
+              const newProduct: Product = {
+                displayName: 'New Product',
                 customerType: activeType,
                 groupId: tempKey,
                 isAddOnTo: false,
@@ -1295,7 +1295,7 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
                 serverOnly: false,
                 freeTrial: undefined,
               };
-              setDrafts(prev => [...prev, { key: draftKey, groupId: tempKey, offer: newOffer }]);
+              setDrafts(prev => [...prev, { key: draftKey, groupId: tempKey, product: newProduct }]);
             }}
           >
             <Plus className="h-8 w-8" />
@@ -1308,7 +1308,7 @@ function CatalogView({ groupedOffers, groups, existingItems, onSaveOffer, onDele
   );
 }
 
-function WelcomeScreen({ onCreateOffer }: { onCreateOffer: () => void }) {
+function WelcomeScreen({ onCreateProduct }: { onCreateProduct: () => void }) {
   return (
     <div className="flex flex-col items-center justify-center h-full px-4 py-12 max-w-3xl mx-auto">
       <IllustratedInfo
@@ -1346,23 +1346,23 @@ function WelcomeScreen({ onCreateOffer }: { onCreateOffer: () => void }) {
         )}
         title="Welcome to Payments!"
         description={[
-          <>Stack Auth Payments is built on two primitives: offers and items.</>,
-          <>Offers are what customers buy — the columns of your pricing table. Each offer has one or more prices and may or may not include items.</>,
+          <>Stack Auth Payments is built on two primitives: products and items.</>,
+          <>Products are what customers buy — the columns of your pricing table. Each product has one or more prices and may or may not include items.</>,
           <>Items are what customers receive — the rows of your pricing table. A user can hold multiple of the same item. Items are powerful; they can unlock feature access, raise limits, or meter consumption for usage-based billing.</>,
-          <>Create your first offer to get started!</>,
+          <>Create your first product to get started!</>,
         ]}
       />
-      <Button onClick={onCreateOffer}>
+      <Button onClick={onCreateProduct}>
         <Plus className="h-4 w-4 mr-2" />
-        Create Your First Offer
+        Create Your First Product
       </Button>
     </div>
   );
 }
 
 export default function PageClient({ onViewChange }: { onViewChange: (view: "list" | "catalogs") => void }) {
-  const [showOfferDialog, setShowOfferDialog] = useState(false);
-  const [editingOffer, setEditingOffer] = useState<Offer | null>(null);
+  const [showProductDialog, setShowProductDialog] = useState(false);
+  const [editingProduct, setEditingProduct] = useState<Product | null>(null);
   const [showItemDialog, setShowItemDialog] = useState(false);
   const [editingItem, setEditingItem] = useState<{ id: string, displayName: string, customerType: 'user' | 'team' | 'custom' } | null>(null);
   const stackAdminApp = useAdminApp();
@@ -1373,40 +1373,40 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   const paymentsConfig: CompleteConfig['payments'] = shouldUseDummyData ? (DUMMY_PAYMENTS_CONFIG as CompleteConfig['payments']) : config.payments;
 
 
-  // Group offers by groupId and sort by customer type priority
-  const groupedOffers = useMemo(() => {
-    const groups = new Map<string | undefined, Array<{ id: string, offer: Offer }>>();
+  // Group products by groupId and sort by customer type priority
+  const groupedProducts = useMemo(() => {
+    const groups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
-    // Group offers
-    for (const [id, offer] of typedEntries(paymentsConfig.offers)) {
-      const groupId = offer.groupId;
+    // Group products
+    for (const [id, product] of typedEntries(paymentsConfig.products)) {
+      const groupId = product.groupId;
       if (!groups.has(groupId)) {
         groups.set(groupId, []);
       }
-      groups.get(groupId)!.push({ id, offer });
+      groups.get(groupId)!.push({ id, product });
     }
 
-    // Sort offers within each group by customer type, then by ID
+    // Sort products within each group by customer type, then by ID
     const customerTypePriority = { user: 1, team: 2, custom: 3 };
-    groups.forEach((offers) => {
-      offers.sort((a, b) => {
-        const priorityA = customerTypePriority[a.offer.customerType as keyof typeof customerTypePriority] || 4;
-        const priorityB = customerTypePriority[b.offer.customerType as keyof typeof customerTypePriority] || 4;
+    groups.forEach((products) => {
+      products.sort((a, b) => {
+        const priorityA = customerTypePriority[a.product.customerType as keyof typeof customerTypePriority] || 4;
+        const priorityB = customerTypePriority[b.product.customerType as keyof typeof customerTypePriority] || 4;
         if (priorityA !== priorityB) {
           return priorityA - priorityB;
         }
         // If same customer type, sort addons last
-        if (a.offer.isAddOnTo !== b.offer.isAddOnTo) {
-          return a.offer.isAddOnTo ? 1 : -1;
+        if (a.product.isAddOnTo !== b.product.isAddOnTo) {
+          return a.product.isAddOnTo ? 1 : -1;
         }
         // If same customer type and addons, sort by lowest price
-        const getPricePriority = (offer: Offer) => {
-          if (offer.prices === 'include-by-default') return 0;
-          if (typeof offer.prices !== 'object') return 0;
-          return Math.min(...Object.values(offer.prices).map(price => +(price.USD ?? Infinity)));
+        const getPricePriority = (product: Product) => {
+          if (product.prices === 'include-by-default') return 0;
+          if (typeof product.prices !== 'object') return 0;
+          return Math.min(...Object.values(product.prices).map(price => +(price.USD ?? Infinity)));
         };
-        const priceA = getPricePriority(a.offer);
-        const priceB = getPricePriority(b.offer);
+        const priceA = getPricePriority(a.product);
+        const priceB = getPricePriority(b.product);
         if (priceA !== priceB) {
           return priceA - priceB;
         }
@@ -1416,18 +1416,18 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Sort groups by their predominant customer type
-    const sortedGroups = new Map<string | undefined, Array<{ id: string, offer: Offer }>>();
+    const sortedGroups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
     // Helper to get group priority
     const getGroupPriority = (groupId: string | undefined) => {
       if (!groupId) return 999; // Ungrouped always last
 
-      const offers = groups.get(groupId) || [];
-      if (offers.length === 0) return 999;
+      const products = groups.get(groupId) || [];
+      if (products.length === 0) return 999;
 
       // Get the most common customer type in the group
-      const typeCounts = offers.reduce((acc, { offer }) => {
-        const type = offer.customerType;
+      const typeCounts = products.reduce((acc, { product }) => {
+        const type = product.customerType;
         acc[type] = (acc[type] || 0) + 1;
         return acc;
       }, {} as Record<string, number>);
@@ -1447,20 +1447,20 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Rebuild map in sorted order
-    sortedEntries.forEach(([groupId, offers]) => {
-      sortedGroups.set(groupId, offers);
+    sortedEntries.forEach(([groupId, products]) => {
+      sortedGroups.set(groupId, products);
     });
 
     return sortedGroups;
   }, [paymentsConfig]);
 
 
-  // Check if there are no offers and no items
-  const hasNoOffersAndNoItems = Object.keys(paymentsConfig.offers).length === 0 && Object.keys(paymentsConfig.items).length === 0;
+  // Check if there are no products and no items
+  const hasNoProductsAndNoItems = Object.keys(paymentsConfig.products).length === 0 && Object.keys(paymentsConfig.items).length === 0;
 
-  // Handler for create offer button
-  const handleCreateOffer = () => {
-    setShowOfferDialog(true);
+  // Handler for create product button
+  const handleCreateProduct = () => {
+    setShowProductDialog(true);
   };
 
   // Handler for create item button
@@ -1468,11 +1468,11 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     setShowItemDialog(true);
   };
 
-  // Handler for saving offer
-  const handleSaveOffer = async (offerId: string, offer: Offer) => {
-    await project.updateConfig({ [`payments.offers.${offerId}`]: offer });
-    setShowOfferDialog(false);
-    toast({ title: editingOffer ? "Offer updated" : "Offer created" });
+  // Handler for saving product
+  const handleSaveProduct = async (productId: string, product: Product) => {
+    await project.updateConfig({ [`payments.products.${productId}`]: product });
+    setShowProductDialog(false);
+    toast({ title: editingProduct ? "Product updated" : "Product created" });
   };
 
   // Handler for saving item
@@ -1483,12 +1483,12 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     toast({ title: editingItem ? "Item updated" : "Item created" });
   };
 
-  // Prepare data for offer dialog - update when items change
-  const existingOffersList = typedEntries(paymentsConfig.offers).map(([id, offer]) => ({
+  // Prepare data for product dialog - update when items change
+  const existingProductsList = typedEntries(paymentsConfig.products).map(([id, product]) => ({
     id,
-    displayName: offer.displayName,
-    groupId: offer.groupId,
-    customerType: offer.customerType
+    displayName: product.displayName,
+    groupId: product.groupId,
+    customerType: product.customerType
   }));
 
   const existingItemsList = typedEntries(paymentsConfig.items).map(([id, item]) => ({
@@ -1497,21 +1497,21 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     customerType: item.customerType
   }));
 
-  const handleInlineSaveOffer = async (offerId: string, offer: Offer) => {
-    await project.updateConfig({ [`payments.offers.${offerId}`]: offer });
-    toast({ title: "Offer updated" });
+  const handleInlineSaveProduct = async (productId: string, product: Product) => {
+    await project.updateConfig({ [`payments.products.${productId}`]: product });
+    toast({ title: "Product updated" });
   };
 
-  const handleDeleteOffer = async (offerId: string) => {
-    await project.updateConfig({ [`payments.offers.${offerId}`]: null });
-    toast({ title: "Offer deleted" });
+  const handleDeleteProduct = async (productId: string) => {
+    await project.updateConfig({ [`payments.products.${productId}`]: null });
+    toast({ title: "Product deleted" });
   };
 
 
-  // If no offers and items, show welcome screen instead of everything
+  // If no products and items, show welcome screen instead of everything
   const innerContent = (
     <PageLayout
-      title='Offer'
+      title='Product'
       actions={
         <div className="flex items-center gap-2 self-center">
           <Label htmlFor={switchId}>Pricing table</Label>
@@ -1522,22 +1522,22 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     >
       <div className="flex-1">
         <CatalogView
-          groupedOffers={groupedOffers}
+          groupedProducts={groupedProducts}
           groups={paymentsConfig.groups}
           existingItems={existingItemsList}
-          onSaveOffer={handleInlineSaveOffer}
-          onDeleteOffer={handleDeleteOffer}
+          onSaveProduct={handleInlineSaveProduct}
+          onDeleteProduct={handleDeleteProduct}
           onCreateNewItem={handleCreateItem}
-          onOpenOfferDetails={(offer) => {
-            setEditingOffer(offer);
-            setShowOfferDialog(true);
+          onOpenProductDetails={(product) => {
+            setEditingProduct(product);
+            setShowProductDialog(true);
           }}
-          onSaveOfferWithGroup={async (groupId, offerId, offer) => {
+          onSaveProductWithGroup={async (groupId, productId, product) => {
             await project.updateConfig({
               [`payments.groups.${groupId}`]: {},
-              [`payments.offers.${offerId}`]: offer,
+              [`payments.products.${productId}`]: product,
             });
-            toast({ title: "Offer created" });
+            toast({ title: "Product created" });
           }}
         />
       </div>
@@ -1548,18 +1548,18 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     <>
       {innerContent}
 
-      {/* Offer Dialog */}
-      <OfferDialog
-        open={showOfferDialog}
+      {/* Product Dialog */}
+      <ProductDialog
+        open={showProductDialog}
         onOpenChange={(open) => {
-          setShowOfferDialog(open);
+          setShowProductDialog(open);
           if (!open) {
-            setEditingOffer(null);
+            setEditingProduct(null);
           }
         }}
-        onSave={async (offerId, offer) => await handleSaveOffer(offerId, offer)}
-        editingOffer={editingOffer ?? undefined}
-        existingOffers={existingOffersList}
+        onSave={async (productId, product) => await handleSaveProduct(productId, product)}
+        editingProduct={editingProduct ?? undefined}
+        existingProducts={existingProductsList}
         existingGroups={Object.fromEntries(Object.entries(paymentsConfig.groups).map(([id, g]) => [id, { displayName: g.displayName || id }]))}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
index 2420ee39de..f8c023717d 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
@@ -6,7 +6,7 @@ import { useHover } from "@stackframe/stack-shared/dist/hooks/use-hover";
 import { DayInterval } from "@stackframe/stack-shared/dist/utils/dates";
 import { prettyPrintWithMagnitudes } from "@stackframe/stack-shared/dist/utils/numbers";
 import { stringCompare } from "@stackframe/stack-shared/dist/utils/strings";
-import { Button, Card, CardContent, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger, Switch, Label, toast } from "@stackframe/stack-ui";
+import { Button, Card, CardContent, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger, Label, Switch, toast } from "@stackframe/stack-ui";
 import { MoreVertical, Plus } from "lucide-react";
 import React, { ReactNode, useEffect, useId, useMemo, useRef, useState } from "react";
 import { IllustratedInfo } from "../../../../../../../components/illustrated-info";
@@ -15,9 +15,9 @@ import { useAdminApp } from "../../use-admin-app";
 import { DUMMY_PAYMENTS_CONFIG } from "./dummy-data";
 import { ItemDialog } from "./item-dialog";
 import { ListSection } from "./list-section";
-import { OfferDialog } from "./offer-dialog";
+import { ProductDialog } from "./product-dialog";
 
-type Offer = CompleteConfig['payments']['offers'][keyof CompleteConfig['payments']['offers']];
+type Product = CompleteConfig['payments']['products'][keyof CompleteConfig['payments']['products']];
 type Item = CompleteConfig['payments']['items'][keyof CompleteConfig['payments']['items']];
 
 // Custom action menu component
@@ -270,7 +270,7 @@ function formatInterval(interval: DayInterval): string {
   return count > 1 ? `${count}${unitShort}` : unitShort;
 }
 
-function formatPrice(price: (Offer['prices'] & object)[string]): string | null {
+function formatPrice(price: (Product['prices'] & object)[string]): string | null {
   if (typeof price === 'string') return null;
 
   const amounts = [];
@@ -289,7 +289,7 @@ function formatPrice(price: (Offer['prices'] & object)[string]): string | null {
   return amounts.join(', ') || null;
 }
 
-function formatOfferPrices(prices: Offer['prices']): string {
+function formatProductPrices(prices: Product['prices']): string {
   if (prices === 'include-by-default') return 'Free';
   if (typeof prices !== 'object') return '';
 
@@ -301,113 +301,113 @@ function formatOfferPrices(prices: Offer['prices']): string {
   return formattedPrices.join(', ');
 }
 
-// OffersList component with props
-type OffersListProps = {
-  groupedOffers: Map<string | undefined, Array<{ id: string, offer: any }>>,
+// ProductsList component with props
+type ProductsListProps = {
+  groupedProducts: Map<string | undefined, Array<{ id: string, product: any }>>,
   paymentsGroups: any,
   hoveredItemId: string | null,
-  getConnectedOffers: (itemId: string) => string[],
-  offerRefs?: Record<string, React.RefObject<HTMLDivElement>>,
-  onOfferMouseEnter: (offerId: string) => void,
-  onOfferMouseLeave: () => void,
-  onOfferAdd?: () => void,
-  setEditingOffer: (offer: any) => void,
-  setShowOfferDialog: (show: boolean) => void,
+  getConnectedProducts: (itemId: string) => string[],
+  productRefs?: Record<string, React.RefObject<HTMLDivElement>>,
+  onProductMouseEnter: (productId: string) => void,
+  onProductMouseLeave: () => void,
+  onProductAdd?: () => void,
+  setEditingProduct: (product: any) => void,
+  setShowProductDialog: (show: boolean) => void,
 };
 
-function OffersList({
-  groupedOffers,
+function ProductsList({
+  groupedProducts,
   paymentsGroups,
   hoveredItemId,
-  getConnectedOffers,
-  offerRefs,
-  onOfferMouseEnter,
-  onOfferMouseLeave,
-  onOfferAdd,
-  setEditingOffer,
-  setShowOfferDialog,
-}: OffersListProps) {
+  getConnectedProducts,
+  productRefs,
+  onProductMouseEnter,
+  onProductMouseLeave,
+  onProductAdd,
+  setEditingProduct,
+  setShowProductDialog,
+}: ProductsListProps) {
   const stackAdminApp = useAdminApp();
   const project = stackAdminApp.useProject();
   const [searchQuery, setSearchQuery] = useState("");
   let globalIndex = 0;
 
-  // Filter offers based on search query
-  const filteredGroupedOffers = useMemo(() => {
-    if (!searchQuery) return groupedOffers;
+  // Filter products based on search query
+  const filteredGroupedProducts = useMemo(() => {
+    if (!searchQuery) return groupedProducts;
 
-    const filtered = new Map<string | undefined, Array<{ id: string, offer: any }>>();
+    const filtered = new Map<string | undefined, Array<{ id: string, product: any }>>();
 
-    groupedOffers.forEach((offers, groupId) => {
-      const filteredOffers = offers.filter(({ id, offer }) => {
+    groupedProducts.forEach((products, groupId) => {
+      const filteredProducts = products.filter(({ id, product }) => {
         const query = searchQuery.toLowerCase();
         return (
           id.toLowerCase().includes(query) ||
-          offer.displayName?.toLowerCase().includes(query) ||
-          offer.customerType?.toLowerCase().includes(query)
+          product.displayName?.toLowerCase().includes(query) ||
+          product.customerType?.toLowerCase().includes(query)
         );
       });
 
-      if (filteredOffers.length > 0) {
-        filtered.set(groupId, filteredOffers);
+      if (filteredProducts.length > 0) {
+        filtered.set(groupId, filteredProducts);
       }
     });
 
     return filtered;
-  }, [groupedOffers, searchQuery]);
+  }, [groupedProducts, searchQuery]);
 
   return (
     <ListSection
       title={<>
-        Offers
+        Products
       </>}
-      titleTooltip="Offers are the products, plans, or pricing tiers you sell to your customers. They are the columns in a pricing table."
-      onAddClick={() => onOfferAdd?.()}
+      titleTooltip="Products are the products, plans, or pricing tiers you sell to your customers. They are the columns in a pricing table."
+      onAddClick={() => onProductAdd?.()}
       hasTitleBorder={false}
       searchValue={searchQuery}
       onSearchChange={setSearchQuery}
-      searchPlaceholder="Search offers..."
+      searchPlaceholder="Search products..."
     >
       <GroupedList>
-        {[...filteredGroupedOffers.entries()].map(([groupId, offers]) => {
+        {[...filteredGroupedProducts.entries()].map(([groupId, products]) => {
           const group = groupId ? paymentsGroups[groupId] : undefined;
           const groupName = group?.displayName;
 
           return (
             <ListGroup key={groupId || 'ungrouped'} title={groupId ? (groupName || groupId) : "Other"}>
-              {offers.map(({ id, offer }) => {
+              {products.map(({ id, product }) => {
                 const isEven = globalIndex % 2 === 0;
                 globalIndex++;
-                const connectedItems = hoveredItemId ? getConnectedOffers(hoveredItemId) : [];
+                const connectedItems = hoveredItemId ? getConnectedProducts(hoveredItemId) : [];
                 const isHighlighted = hoveredItemId ? connectedItems.includes(id) : false;
 
                 return (
                   <ListItem
                     key={id}
                     id={id}
-                    displayName={offer.displayName}
-                    customerType={offer.customerType}
-                    subtitle={formatOfferPrices(offer.prices)}
+                    displayName={product.displayName}
+                    customerType={product.customerType}
+                    subtitle={formatProductPrices(product.prices)}
                     isEven={isEven}
                     isHighlighted={isHighlighted}
-                    itemRef={offerRefs?.[id]}
-                    onMouseEnter={() => onOfferMouseEnter(id)}
-                    onMouseLeave={onOfferMouseLeave}
+                    itemRef={productRefs?.[id]}
+                    onMouseEnter={() => onProductMouseEnter(id)}
+                    onMouseLeave={onProductMouseLeave}
                     actionItems={[
                       {
                         item: "Edit",
                         onClick: () => {
-                          setEditingOffer(offer);
-                          setShowOfferDialog(true);
+                          setEditingProduct(product);
+                          setShowProductDialog(true);
                         },
                       },
                       '-',
                       {
                         item: "Delete",
                         onClick: async () => {
-                          if (confirm(`Are you sure you want to delete the offer "${offer.displayName}"?`)) {
-                            await project.updateConfig({ [`payments.offers.${id}`]: null });
-                            toast({ title: "Offer deleted" });
+                          if (confirm(`Are you sure you want to delete the product "${product.displayName}"?`)) {
+                            await project.updateConfig({ [`payments.products.${id}`]: null });
+                            toast({ title: "Product deleted" });
                           }
                         },
                         danger: true,
@@ -427,8 +427,8 @@ function OffersList({
 // ItemsList component with props
 type ItemsListProps = {
   items: CompleteConfig['payments']['items'],
-  hoveredOfferId: string | null,
-  getConnectedItems: (offerId: string) => string[],
+  hoveredProductId: string | null,
+  getConnectedItems: (productId: string) => string[],
   itemRefs?: Record<string, React.RefObject<HTMLDivElement>>,
   onItemMouseEnter: (itemId: string) => void,
   onItemMouseLeave: () => void,
@@ -439,7 +439,7 @@ type ItemsListProps = {
 
 function ItemsList({
   items,
-  hoveredOfferId,
+  hoveredProductId,
   getConnectedItems,
   itemRefs,
   onItemMouseEnter,
@@ -491,8 +491,8 @@ function ItemsList({
     >
       <GroupedList>
         {filteredItems.map(([id, item]: [string, any], index) => {
-          const connectedOffers = hoveredOfferId ? getConnectedItems(hoveredOfferId) : [];
-          const isHighlighted = hoveredOfferId ? connectedOffers.includes(id) : false;
+          const connectedProducts = hoveredProductId ? getConnectedItems(hoveredProductId) : [];
+          const isHighlighted = hoveredProductId ? connectedProducts.includes(id) : false;
 
           return (
             <ListItem
@@ -537,7 +537,7 @@ function ItemsList({
   );
 }
 
-function WelcomeScreen({ onCreateOffer }: { onCreateOffer: () => void }) {
+function WelcomeScreen({ onCreateProduct }: { onCreateProduct: () => void }) {
   return (
     <div className="flex flex-col items-center justify-center h-full px-4 py-12 max-w-3xl mx-auto">
       <IllustratedInfo
@@ -575,26 +575,26 @@ function WelcomeScreen({ onCreateOffer }: { onCreateOffer: () => void }) {
         )}
         title="Welcome to Payments!"
         description={[
-          <>Stack Auth Payments is built on two primitives: offers and items.</>,
-          <>Offers are what customers buy — the columns of your pricing table. Each offer has one or more prices and may or may not include items.</>,
+          <>Stack Auth Payments is built on two primitives: products and items.</>,
+          <>Products are what customers buy — the columns of your pricing table. Each product has one or more prices and may or may not include items.</>,
           <>Items are what customers receive — the rows of your pricing table. A user can hold multiple of the same item. Items are powerful; they can unlock feature access, raise limits, or meter consumption for usage-based billing.</>,
-          <>Create your first offer to get started!</>,
+          <>Create your first product to get started!</>,
         ]}
       />
-      <Button onClick={onCreateOffer}>
+      <Button onClick={onCreateProduct}>
         <Plus className="h-4 w-4 mr-2" />
-        Create Your First Offer
+        Create Your First Product
       </Button>
     </div>
   );
 }
 
 export default function PageClient({ onViewChange }: { onViewChange: (view: "list" | "catalogs") => void }) {
-  const [activeTab, setActiveTab] = useState<"offers" | "items">("offers");
-  const [hoveredOfferId, setHoveredOfferId] = useState<string | null>(null);
+  const [activeTab, setActiveTab] = useState<"products" | "items">("products");
+  const [hoveredProductId, setHoveredProductId] = useState<string | null>(null);
   const [hoveredItemId, setHoveredItemId] = useState<string | null>(null);
-  const [showOfferDialog, setShowOfferDialog] = useState(false);
-  const [editingOffer, setEditingOffer] = useState<any>(null);
+  const [showProductDialog, setShowProductDialog] = useState(false);
+  const [editingProduct, setEditingProduct] = useState<any>(null);
   const [showItemDialog, setShowItemDialog] = useState(false);
   const [editingItem, setEditingItem] = useState<any>(null);
   const stackAdminApp = useAdminApp();
@@ -605,17 +605,17 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
 
   const paymentsConfig = shouldUseDummyData ? DUMMY_PAYMENTS_CONFIG : config.payments;
 
-  // Refs for offers and items
+  // Refs for products and items
   const containerRef = useRef<HTMLDivElement>(null);
 
-  // Create refs for all offers and items
-  const offerRefs = useMemo(() => {
+  // Create refs for all products and items
+  const productRefs = useMemo(() => {
     const refs = Object.fromEntries(
-      Object.keys(paymentsConfig.offers)
+      Object.keys(paymentsConfig.products)
         .map(id => [id, React.createRef<HTMLDivElement>()])
     );
     return refs;
-  }, [paymentsConfig.offers]);
+  }, [paymentsConfig.products]);
 
   const itemRefs = useMemo(() => {
     const refs = Object.fromEntries(
@@ -625,40 +625,40 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     return refs;
   }, [paymentsConfig.items]);
 
-  // Group offers by groupId and sort by customer type priority
-  const groupedOffers = useMemo(() => {
-    const groups = new Map<string | undefined, Array<{ id: string, offer: typeof paymentsConfig.offers[keyof typeof paymentsConfig.offers] }>>();
+  // Group products by groupId and sort by customer type priority
+  const groupedProducts = useMemo(() => {
+    const groups = new Map<string | undefined, Array<{ id: string, product: typeof paymentsConfig.products[keyof typeof paymentsConfig.products] }>>();
 
-    // Group offers
-    Object.entries(paymentsConfig.offers).forEach(([id, offer]: [string, any]) => {
-      const groupId = offer.groupId;
+    // Group products
+    Object.entries(paymentsConfig.products).forEach(([id, product]: [string, any]) => {
+      const groupId = product.groupId;
       if (!groups.has(groupId)) {
         groups.set(groupId, []);
       }
-      groups.get(groupId)!.push({ id, offer });
+      groups.get(groupId)!.push({ id, product });
     });
 
-    // Sort offers within each group by customer type, then by ID
+    // Sort products within each group by customer type, then by ID
     const customerTypePriority = { user: 1, team: 2, custom: 3 };
-    groups.forEach((offers) => {
-      offers.sort((a, b) => {
-        const priorityA = customerTypePriority[a.offer.customerType as keyof typeof customerTypePriority] || 4;
-        const priorityB = customerTypePriority[b.offer.customerType as keyof typeof customerTypePriority] || 4;
+    groups.forEach((products) => {
+      products.sort((a, b) => {
+        const priorityA = customerTypePriority[a.product.customerType as keyof typeof customerTypePriority] || 4;
+        const priorityB = customerTypePriority[b.product.customerType as keyof typeof customerTypePriority] || 4;
         if (priorityA !== priorityB) {
           return priorityA - priorityB;
         }
         // If same customer type, sort addons last
-        if (a.offer.isAddOnTo !== b.offer.isAddOnTo) {
-          return a.offer.isAddOnTo ? 1 : -1;
+        if (a.product.isAddOnTo !== b.product.isAddOnTo) {
+          return a.product.isAddOnTo ? 1 : -1;
         }
         // If same customer type and addons, sort by lowest price
-        const getPricePriority = (offer: Offer) => {
-          if (offer.prices === 'include-by-default') return 0;
-          if (typeof offer.prices !== 'object') return 0;
-          return Math.min(...Object.values(offer.prices).map(price => +(price.USD ?? Infinity)));
+        const getPricePriority = (product: Product) => {
+          if (product.prices === 'include-by-default') return 0;
+          if (typeof product.prices !== 'object') return 0;
+          return Math.min(...Object.values(product.prices).map(price => +(price.USD ?? Infinity)));
         };
-        const priceA = getPricePriority(a.offer);
-        const priceB = getPricePriority(b.offer);
+        const priceA = getPricePriority(a.product);
+        const priceB = getPricePriority(b.product);
         if (priceA !== priceB) {
           return priceA - priceB;
         }
@@ -668,18 +668,18 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Sort groups by their predominant customer type
-    const sortedGroups = new Map<string | undefined, Array<{ id: string, offer: Offer }>>();
+    const sortedGroups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
     // Helper to get group priority
     const getGroupPriority = (groupId: string | undefined) => {
       if (!groupId) return 999; // Ungrouped always last
 
-      const offers = groups.get(groupId) || [];
-      if (offers.length === 0) return 999;
+      const products = groups.get(groupId) || [];
+      if (products.length === 0) return 999;
 
       // Get the most common customer type in the group
-      const typeCounts = offers.reduce((acc, { offer }) => {
-        const type = offer.customerType;
+      const typeCounts = products.reduce((acc, { product }) => {
+        const type = product.customerType;
         acc[type] = (acc[type] || 0) + 1;
         return acc;
       }, {} as Record<string, number>);
@@ -699,39 +699,39 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Rebuild map in sorted order
-    sortedEntries.forEach(([groupId, offers]) => {
-      sortedGroups.set(groupId, offers);
+    sortedEntries.forEach(([groupId, products]) => {
+      sortedGroups.set(groupId, products);
     });
 
     return sortedGroups;
   }, [paymentsConfig]);
 
-  // Get connected items for an offer
-  const getConnectedItems = (offerId: string) => {
-    const offer = paymentsConfig.offers[offerId];
-    return Object.keys(offer.includedItems);
+  // Get connected items for an product
+  const getConnectedItems = (productId: string) => {
+    const product = paymentsConfig.products[productId];
+    return Object.keys(product.includedItems);
   };
 
-  // Get item quantity for an offer
-  const getItemQuantity = (offerId: string, itemId: string) => {
-    const offer = paymentsConfig.offers[offerId];
-    if (!(itemId in offer.includedItems)) return 0;
-    return offer.includedItems[itemId].quantity;
+  // Get item quantity for an product
+  const getItemQuantity = (productId: string, itemId: string) => {
+    const product = paymentsConfig.products[productId];
+    if (!(itemId in product.includedItems)) return 0;
+    return product.includedItems[itemId].quantity;
   };
 
-  // Get connected offers for an item
-  const getConnectedOffers = (itemId: string) => {
-    return Object.entries(paymentsConfig.offers)
-      .filter(([_, offer]: [string, any]) => itemId in offer.includedItems)
+  // Get connected products for an item
+  const getConnectedProducts = (itemId: string) => {
+    return Object.entries(paymentsConfig.products)
+      .filter(([_, product]: [string, any]) => itemId in product.includedItems)
       .map(([id]) => id);
   };
 
-  // Check if there are no offers and no items
-  const hasNoOffersAndNoItems = Object.keys(paymentsConfig.offers).length === 0 && Object.keys(paymentsConfig.items).length === 0;
+  // Check if there are no products and no items
+  const hasNoProductsAndNoItems = Object.keys(paymentsConfig.products).length === 0 && Object.keys(paymentsConfig.items).length === 0;
 
-  // Handler for create offer button
-  const handleCreateOffer = () => {
-    setShowOfferDialog(true);
+  // Handler for create product button
+  const handleCreateProduct = () => {
+    setShowProductDialog(true);
   };
 
   // Handler for create item button
@@ -739,11 +739,11 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     setShowItemDialog(true);
   };
 
-  // Handler for saving offer
-  const handleSaveOffer = async (offerId: string, offer: Offer) => {
-    await project.updateConfig({ [`payments.offers.${offerId}`]: offer });
-    setShowOfferDialog(false);
-    toast({ title: editingOffer ? "Offer updated" : "Offer created" });
+  // Handler for saving product
+  const handleSaveProduct = async (productId: string, product: Product) => {
+    await project.updateConfig({ [`payments.products.${productId}`]: product });
+    setShowProductDialog(false);
+    toast({ title: editingProduct ? "Product updated" : "Product created" });
   };
 
   // Handler for saving item
@@ -754,12 +754,12 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     toast({ title: editingItem ? "Item updated" : "Item created" });
   };
 
-  // Prepare data for offer dialog - update when items change
-  const existingOffersList = Object.entries(paymentsConfig.offers).map(([id, offer]: [string, any]) => ({
+  // Prepare data for product dialog - update when items change
+  const existingProductsList = Object.entries(paymentsConfig.products).map(([id, product]: [string, any]) => ({
     id,
-    displayName: offer.displayName,
-    groupId: offer.groupId,
-    customerType: offer.customerType
+    displayName: product.displayName,
+    groupId: product.groupId,
+    customerType: product.customerType
   }));
 
   const existingItemsList = Object.entries(paymentsConfig.items).map(([id, item]: [string, any]) => ({
@@ -768,14 +768,14 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     customerType: item.customerType
   }));
 
-  // If no offers and items, show welcome screen instead of everything
+  // If no products and items, show welcome screen instead of everything
   let innerContent;
-  if (hasNoOffersAndNoItems) {
-    innerContent = <WelcomeScreen onCreateOffer={handleCreateOffer} />;
+  if (hasNoProductsAndNoItems) {
+    innerContent = <WelcomeScreen onCreateProduct={handleCreateProduct} />;
   } else {
     innerContent = (
       <PageLayout
-        title="Offers"
+        title="Products"
         actions={
           <div className="flex items-center gap-2 self-center">
             <Label htmlFor={switchId}>Pricing table</Label>
@@ -788,15 +788,15 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
         < div className="lg:hidden mb-4" >
           <div className="flex space-x-1 bg-muted p-1 rounded-md">
             <button
-              onClick={() => setActiveTab("offers")}
+              onClick={() => setActiveTab("products")}
               className={cn(
                 "flex-1 px-3 py-2 rounded-sm text-sm font-medium transition-all",
-                activeTab === "offers"
+                activeTab === "products"
                   ? "bg-background text-foreground shadow-sm"
                   : "text-muted-foreground hover:text-foreground"
               )}
             >
-              Offers
+              Products
             </button>
             <button
               onClick={() => setActiveTab("items")}
@@ -822,17 +822,17 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
           < Card className="hidden lg:flex w-full relative" ref={containerRef} >
             <CardContent className="flex w-full">
               <div className="flex-1">
-                <OffersList
-                  groupedOffers={groupedOffers}
+                <ProductsList
+                  groupedProducts={groupedProducts}
                   paymentsGroups={paymentsConfig.groups}
                   hoveredItemId={hoveredItemId}
-                  getConnectedOffers={getConnectedOffers}
-                  offerRefs={offerRefs}
-                  onOfferMouseEnter={setHoveredOfferId}
-                  onOfferMouseLeave={() => setHoveredOfferId(null)}
-                  onOfferAdd={handleCreateOffer}
-                  setEditingOffer={setEditingOffer}
-                  setShowOfferDialog={setShowOfferDialog}
+                  getConnectedProducts={getConnectedProducts}
+                  productRefs={productRefs}
+                  onProductMouseEnter={setHoveredProductId}
+                  onProductMouseLeave={() => setHoveredProductId(null)}
+                  onProductAdd={handleCreateProduct}
+                  setEditingProduct={setEditingProduct}
+                  setShowProductDialog={setShowProductDialog}
                 />
               </div>
             </CardContent>
@@ -841,7 +841,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
               <div className="flex-1">
                 <ItemsList
                   items={paymentsConfig.items}
-                  hoveredOfferId={hoveredOfferId}
+                  hoveredProductId={hoveredProductId}
                   getConnectedItems={getConnectedItems}
                   itemRefs={itemRefs}
                   onItemMouseEnter={setHoveredItemId}
@@ -855,25 +855,25 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
 
             {/* Connection lines */}
             {
-              hoveredOfferId && getConnectedItems(hoveredOfferId).map(itemId => (
+              hoveredProductId && getConnectedItems(hoveredProductId).map(itemId => (
                 <ConnectionLine
-                  key={`${hoveredOfferId}-${itemId}`}
-                  fromRef={offerRefs[hoveredOfferId]}
+                  key={`${hoveredProductId}-${itemId}`}
+                  fromRef={productRefs[hoveredProductId]}
                   toRef={itemRefs[itemId]}
                   containerRef={containerRef}
-                  quantity={getItemQuantity(hoveredOfferId, itemId)}
+                  quantity={getItemQuantity(hoveredProductId, itemId)}
                 />
               ))
             }
 
             {
-              hoveredItemId && getConnectedOffers(hoveredItemId).map(offerId => (
+              hoveredItemId && getConnectedProducts(hoveredItemId).map(productId => (
                 <ConnectionLine
-                  key={`${offerId}-${hoveredItemId}`}
-                  fromRef={offerRefs[offerId]}
+                  key={`${productId}-${hoveredItemId}`}
+                  fromRef={productRefs[productId]}
                   toRef={itemRefs[hoveredItemId]}
                   containerRef={containerRef}
-                  quantity={getItemQuantity(offerId, hoveredItemId)}
+                  quantity={getItemQuantity(productId, hoveredItemId)}
                 />
               ))
             }
@@ -881,22 +881,22 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
 
           {/* Mobile single column with tabs */}
           < div className="lg:hidden w-full" >
-            {activeTab === "offers" ? (
-              <OffersList
-                groupedOffers={groupedOffers}
+            {activeTab === "products" ? (
+              <ProductsList
+                groupedProducts={groupedProducts}
                 paymentsGroups={paymentsConfig.groups}
                 hoveredItemId={hoveredItemId}
-                getConnectedOffers={getConnectedOffers}
-                onOfferMouseEnter={setHoveredOfferId}
-                onOfferMouseLeave={() => setHoveredOfferId(null)}
-                onOfferAdd={handleCreateOffer}
-                setEditingOffer={setEditingOffer}
-                setShowOfferDialog={setShowOfferDialog}
+                getConnectedProducts={getConnectedProducts}
+                onProductMouseEnter={setHoveredProductId}
+                onProductMouseLeave={() => setHoveredProductId(null)}
+                onProductAdd={handleCreateProduct}
+                setEditingProduct={setEditingProduct}
+                setShowProductDialog={setShowProductDialog}
               />
             ) : (
               <ItemsList
                 items={paymentsConfig.items}
-                hoveredOfferId={hoveredOfferId}
+                hoveredProductId={hoveredProductId}
                 getConnectedItems={getConnectedItems}
                 onItemMouseEnter={setHoveredItemId}
                 onItemMouseLeave={() => setHoveredItemId(null)}
@@ -915,18 +915,18 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     <>
       {innerContent}
 
-      {/* Offer Dialog */}
-      <OfferDialog
-        open={showOfferDialog}
+      {/* Product Dialog */}
+      <ProductDialog
+        open={showProductDialog}
         onOpenChange={(open) => {
-          setShowOfferDialog(open);
+          setShowProductDialog(open);
           if (!open) {
-            setEditingOffer(null);
+            setEditingProduct(null);
           }
         }}
-        onSave={async (offerId, offer) => await handleSaveOffer(offerId, offer)}
-        editingOffer={editingOffer}
-        existingOffers={existingOffersList}
+        onSave={async (productId, product) => await handleSaveProduct(productId, product)}
+        editingProduct={editingProduct}
+        existingProducts={existingProductsList}
         existingGroups={paymentsConfig.groups}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx
index d2f449e789..0831a408e7 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx
@@ -9,9 +9,9 @@ const SUPPORTED_CURRENCIES = [
   { code: 'USD', symbol: '$', name: 'US Dollar' }
 ];
 
-type Offer = CompleteConfig['payments']['offers'][string];
-type IncludedItem = Offer['includedItems'][string];
-type Price = (Offer['prices'] & object)[string];
+type Product = CompleteConfig['payments']['products'][string];
+type IncludedItem = Product['includedItems'][string];
+type Price = (Product['prices'] & object)[string];
 
 type PriceDialogProps = {
   open: boolean,
@@ -147,7 +147,7 @@ export function PriceDialog({
         <DialogHeader>
           <DialogTitle>{editingPrice ? "Edit Price" : "Add Price"}</DialogTitle>
           <DialogDescription>
-            Configure the pricing for this offer. You can create one-time or recurring prices with optional free trials.
+            Configure the pricing for this product. You can create one-time or recurring prices with optional free trials.
           </DialogDescription>
         </DialogHeader>
 
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/page.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/page.tsx
index e9801af08a..aaeb7eb77b 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/page.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/page.tsx
@@ -1,5 +1,5 @@
 import { redirect } from "next/navigation";
 
 export default function Page() {
-  redirect("./payments/offers");
+  redirect("./payments/products");
 }
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
index 046ec26c60..24949858d5 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
@@ -9,39 +9,39 @@ import { getPublicEnvVar } from '@/lib/env';
 import { cn, devFeaturesEnabledForProject } from "@/lib/utils";
 import { AdminProject, UserButton, useUser } from "@stackframe/stack";
 import {
-  Breadcrumb,
-  BreadcrumbItem,
-  BreadcrumbList,
-  BreadcrumbPage,
-  BreadcrumbSeparator,
-
-  Sheet,
-  SheetContent,
-  SheetTitle,
-  SheetTrigger,
-  Typography,
-  buttonVariants
+    Breadcrumb,
+    BreadcrumbItem,
+    BreadcrumbList,
+    BreadcrumbPage,
+    BreadcrumbSeparator,
+
+    Sheet,
+    SheetContent,
+    SheetTitle,
+    SheetTrigger,
+    Typography,
+    buttonVariants
 } from "@stackframe/stack-ui";
 import {
-  Book,
-  CreditCard,
-  FilePen,
-  Globe,
-  KeyRound,
-  LayoutTemplate,
-  Link as LinkIcon,
-  LockKeyhole,
-  LucideIcon,
-  Mail,
-  Menu,
-  Palette,
-  Receipt,
-  Settings,
-  Settings2,
-  ShieldEllipsis,
-  User,
-  Users,
-  Webhook,
+    Book,
+    CreditCard,
+    FilePen,
+    Globe,
+    KeyRound,
+    LayoutTemplate,
+    Link as LinkIcon,
+    LockKeyhole,
+    LucideIcon,
+    Mail,
+    Menu,
+    Palette,
+    Receipt,
+    Settings,
+    Settings2,
+    ShieldEllipsis,
+    User,
+    Users,
+    Webhook,
 } from "lucide-react";
 import { useTheme } from "next-themes";
 import { usePathname } from "next/navigation";
@@ -247,9 +247,9 @@ const navigationItems: (Label | Item | Hidden)[] = [
     type: 'label',
   },
   {
-    name: "Offers",
-    href: "/payments/offers",
-    regex: /^\/projects\/[^\/]+\/payments\/offers$/,
+    name: "Products",
+    href: "/payments/products",
+    regex: /^\/projects\/[^\/]+\/payments\/products$/,
     icon: CreditCard,
     type: 'item',
   },
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/workflows/workflow-list.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/workflows/workflow-list.tsx
index 476628a75d..ef7e62ee3e 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/workflows/workflow-list.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/workflows/workflow-list.tsx
@@ -3,7 +3,7 @@ import { cn } from "@/lib/utils";
 import { Button, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from "@stackframe/stack-ui";
 import { MoreVertical } from "lucide-react";
 import { useState } from "react";
-import { ListSection } from "../payments/offers/list-section";
+import { ListSection } from "../payments/products/list-section";
 
 type Workflow = {
   id: string,
diff --git a/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx b/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
index 5100d0c2b5..ac47a5ef0f 100644
--- a/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
+++ b/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
@@ -4,7 +4,7 @@ import { CheckoutForm } from "@/components/payments/checkout";
 import { StripeElementsProvider } from "@/components/payments/stripe-elements-provider";
 import { getPublicEnvVar } from "@/lib/env";
 import { StackAdminApp, useUser } from "@stackframe/stack";
-import { inlineOfferSchema } from "@stackframe/stack-shared/dist/schema-fields";
+import { inlineProductSchema } from "@stackframe/stack-shared/dist/schema-fields";
 import { throwErr } from "@stackframe/stack-shared/dist/utils/errors";
 import { typedEntries } from "@stackframe/stack-shared/dist/utils/objects";
 import { runAsynchronouslyWithAlert } from "@stackframe/stack-shared/dist/utils/promises";
@@ -13,19 +13,19 @@ import { ArrowRight, Minus, Plus } from "lucide-react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import * as yup from "yup";
 
-type OfferData = {
-  offer?: Omit<yup.InferType<typeof inlineOfferSchema>, "included_items" | "server_only"> & { stackable: boolean },
+type ProductData = {
+  product?: Omit<yup.InferType<typeof inlineProductSchema>, "included_items" | "server_only"> & { stackable: boolean },
   stripe_account_id: string,
   project_id: string,
   already_bought_non_stackable?: boolean,
-  conflicting_group_offers?: { offer_id: string, display_name: string }[],
+  conflicting_group_products?: { product_id: string, display_name: string }[],
 };
 
 const apiUrl = getPublicEnvVar("NEXT_PUBLIC_STACK_API_URL") ?? throwErr("NEXT_PUBLIC_STACK_API_URL is not set");
 const baseUrl = new URL("/api/v1", apiUrl).toString();
 
 export default function PageClient({ code }: { code: string }) {
-  const [data, setData] = useState<OfferData | null>(null);
+  const [data, setData] = useState<ProductData | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [selectedPriceId, setSelectedPriceId] = useState<string | null>(null);
@@ -52,10 +52,10 @@ export default function PageClient({ code }: { code: string }) {
   }, [quantityInput]);
 
   const unitCents = useMemo((): number => {
-    if (!selectedPriceId || !data?.offer?.prices) {
+    if (!selectedPriceId || !data?.product?.prices) {
       return 0;
     }
-    return Number(data.offer.prices[selectedPriceId].USD) * 100;
+    return Number(data.product.prices[selectedPriceId].USD) * 100;
   }, [data, selectedPriceId]);
 
   const MAX_STRIPE_AMOUNT_CENTS = 999_999 * 100;
@@ -74,8 +74,8 @@ export default function PageClient({ code }: { code: string }) {
   }, [unitCents, rawAmountCents, isTooLarge, MAX_STRIPE_AMOUNT_CENTS]);
 
   const elementsMode = useMemo<"subscription" | "payment">(() => {
-    if (!selectedPriceId || !data?.offer?.prices) return "subscription";
-    const price = data.offer.prices[selectedPriceId];
+    if (!selectedPriceId || !data?.product?.prices) return "subscription";
+    const price = data.product.prices[selectedPriceId];
     return price.interval ? "subscription" : "payment";
   }, [data, selectedPriceId]);
 
@@ -99,8 +99,8 @@ export default function PageClient({ code }: { code: string }) {
     }
     const result = await response.json();
     setData(result);
-    if (result?.offer?.prices) {
-      const firstPriceId = Object.keys(result.offer.prices)[0];
+    if (result?.product?.prices) {
+      const firstPriceId = Object.keys(result.product.prices)[0];
       setSelectedPriceId(firstPriceId);
     }
   }, [code]);
@@ -156,29 +156,29 @@ export default function PageClient({ code }: { code: string }) {
         ) : (
           <>
             <div className="mb-6">
-              <Typography type="h2" className="mb-2">{data?.offer?.display_name || "Plan"}</Typography>
+              <Typography type="h2" className="mb-2">{data?.product?.display_name || "Plan"}</Typography>
             </div>
             <div className="space-y-3">
               {data?.already_bought_non_stackable ? (
                 <Alert variant="destructive">
                   <AlertTitle>Already purchased</AlertTitle>
                   <AlertDescription>
-                    You already have this offer.
+                    You already have this product.
                   </AlertDescription>
                 </Alert>
-              ) : data?.conflicting_group_offers && data.conflicting_group_offers.length > 0 ? (
+              ) : data?.conflicting_group_products && data.conflicting_group_products.length > 0 ? (
                 <Alert>
                   <AlertTitle>Plan change</AlertTitle>
                   <AlertDescription>
-                    {data.conflicting_group_offers.length === 1 ? (
-                      <>This purchase will change your plan from {data.conflicting_group_offers[0].display_name}.</>
+                    {data.conflicting_group_products.length === 1 ? (
+                      <>This purchase will change your plan from {data.conflicting_group_products[0].display_name}.</>
                     ) : (
                       <>This purchase will change your plan from one of your existing plans.</>
                     )}
                   </AlertDescription>
                 </Alert>
               ) : null}
-              {data?.offer?.prices && typedEntries(data.offer.prices).map(([priceId, priceData]) => (
+              {data?.product?.prices && typedEntries(data.product.prices).map(([priceId, priceData]) => (
                 <Card
                   key={priceId}
                   className={`border cursor-pointer transition-colors ${selectedPriceId === priceId ? 'border-blue-500' : 'hover:border-primary/30'}`}
@@ -203,7 +203,7 @@ export default function PageClient({ code }: { code: string }) {
                   </CardContent>
                 </Card>
               ))}
-              {data?.offer?.stackable && selectedPriceId && (
+              {data?.product?.stackable && selectedPriceId && (
                 <div className="pt-4 space-y-2">
                   <div className="flex items-center justify-between">
                     <Typography type="label">Quantity</Typography>
@@ -251,10 +251,10 @@ export default function PageClient({ code }: { code: string }) {
                   <div className="pt-4 flex items-baseline justify-between">
                     <Typography type="label">Total</Typography>
                     <Typography type="h4">
-                      ${selectedPriceId ? (Number(data.offer.prices[selectedPriceId].USD) * Math.max(0, quantityNumber)) : 0}
-                      {selectedPriceId && data.offer.prices[selectedPriceId].interval && (
+                      ${selectedPriceId ? (Number(data.product.prices[selectedPriceId].USD) * Math.max(0, quantityNumber)) : 0}
+                      {selectedPriceId && data.product.prices[selectedPriceId].interval && (
                         <span className="text-sm text-primary/50">
-                          {" "}/ {shortenedInterval(data.offer.prices[selectedPriceId].interval!)}
+                          {" "}/ {shortenedInterval(data.product.prices[selectedPriceId].interval!)}
                         </span>
                       )}
                     </Typography>
diff --git a/apps/dashboard/src/components/data-table/payment-item-table.tsx b/apps/dashboard/src/components/data-table/payment-item-table.tsx
index e4d228dd26..9142002ac9 100644
--- a/apps/dashboard/src/components/data-table/payment-item-table.tsx
+++ b/apps/dashboard/src/components/data-table/payment-item-table.tsx
@@ -105,11 +105,11 @@ function ActionsCell({ item }: { item: PaymentItem }) {
           label: "Delete",
           onClick: async () => {
             const config = await project.getConfig();
-            for (const [offerId, offer] of Object.entries(config.payments.offers)) {
-              if (has(offer.includedItems, item.id)) {
+            for (const [productId, product] of Object.entries(config.payments.products)) {
+              if (has(product.includedItems, item.id)) {
                 toast({
-                  title: "Item is included in offer",
-                  description: `Please remove it from the offer "${offerId}" before deleting.`,
+                  title: "Item is included in product",
+                  description: `Please remove it from the product "${productId}" before deleting.`,
                   variant: "destructive",
                 });
                 return "prevent-close";
diff --git a/apps/dashboard/src/components/data-table/payment-offer-table.tsx b/apps/dashboard/src/components/data-table/payment-offer-table.tsx
index 3e3f4c8b40..96a5245995 100644
--- a/apps/dashboard/src/components/data-table/payment-offer-table.tsx
+++ b/apps/dashboard/src/components/data-table/payment-offer-table.tsx
@@ -1,20 +1,20 @@
 'use client';
 import { useAdminApp } from "@/app/(main)/(protected)/projects/[projectId]/use-admin-app";
-import { OfferDialog } from "@/components/payments/offer-dialog";
+import { ProductDialog } from "@/components/payments/product-dialog";
 import { branchPaymentsSchema } from "@stackframe/stack-shared/dist/config/schema";
 import { ActionCell, ActionDialog, DataTable, DataTableColumnHeader, TextCell, toast } from "@stackframe/stack-ui";
 import { ColumnDef } from "@tanstack/react-table";
 import { useState } from "react";
 import * as yup from "yup";
 
-type PaymentOffer = {
+type PaymentProduct = {
   id: string,
-} & yup.InferType<typeof branchPaymentsSchema>["offers"][string];
+} & yup.InferType<typeof branchPaymentsSchema>["products"][string];
 
-const columns: ColumnDef<PaymentOffer>[] = [
+const columns: ColumnDef<PaymentProduct>[] = [
   {
     accessorKey: "id",
-    header: ({ column }) => <DataTableColumnHeader column={column} columnTitle="Offer ID" />,
+    header: ({ column }) => <DataTableColumnHeader column={column} columnTitle="Product ID" />,
     cell: ({ row }) => <TextCell><span className="font-mono text-sm">{row.original.id}</span></TextCell>,
     enableSorting: false,
   },
@@ -44,14 +44,14 @@ const columns: ColumnDef<PaymentOffer>[] = [
   },
   {
     id: "actions",
-    cell: ({ row }) => <ActionsCell offer={row.original} />,
+    cell: ({ row }) => <ActionsCell product={row.original} />,
   }
 ];
 
-export function PaymentOfferTable({ offers }: { offers: Record<string, yup.InferType<typeof branchPaymentsSchema>["offers"][string]> }) {
-  const data: PaymentOffer[] = Object.entries(offers).map(([id, offer]) => ({
+export function PaymentProductTable({ products }: { products: Record<string, yup.InferType<typeof branchPaymentsSchema>["products"][string]> }) {
+  const data: PaymentProduct[] = Object.entries(products).map(([id, product]) => ({
     id,
-    ...offer,
+    ...product,
   }));
 
   return <DataTable
@@ -63,7 +63,7 @@ export function PaymentOfferTable({ offers }: { offers: Record<string, yup.Infer
   />;
 }
 
-function ActionsCell({ offer }: { offer: PaymentOffer }) {
+function ActionsCell({ product }: { product: PaymentProduct }) {
   const [isEditOpen, setIsEditOpen] = useState(false);
   const [isDeleteOpen, setIsDeleteOpen] = useState(false);
   const stackAdminApp = useAdminApp();
@@ -85,25 +85,25 @@ function ActionsCell({ offer }: { offer: PaymentOffer }) {
           },
         ]}
       />
-      <OfferDialog
+      <ProductDialog
         open={isEditOpen}
         onOpenChange={setIsEditOpen}
         project={project}
         mode="edit"
-        initial={{ id: offer.id, value: offer }}
+        initial={{ id: product.id, value: product }}
       />
       <ActionDialog
         open={isDeleteOpen}
         onOpenChange={setIsDeleteOpen}
-        title="Delete Offer"
-        description="This action will permanently delete this offer."
+        title="Delete Product"
+        description="This action will permanently delete this product."
         cancelButton
         danger
         okButton={{
           label: "Delete",
           onClick: async () => {
-            await project.updateConfig({ [`payments.offers.${offer.id}`]: null });
-            toast({ title: "Offer deleted" });
+            await project.updateConfig({ [`payments.products.${product.id}`]: null });
+            toast({ title: "Product deleted" });
           },
         }}
       />
diff --git a/apps/dashboard/src/components/data-table/transaction-table.tsx b/apps/dashboard/src/components/data-table/transaction-table.tsx
index ff38384228..b3f692a64e 100644
--- a/apps/dashboard/src/components/data-table/transaction-table.tsx
+++ b/apps/dashboard/src/components/data-table/transaction-table.tsx
@@ -60,11 +60,11 @@ const columns: ColumnDef<AdminTransaction>[] = [
     enableSorting: false,
   },
   {
-    accessorKey: 'offer_or_item',
-    header: ({ column }) => <DataTableColumnHeader column={column} columnTitle="Offer / Item" />,
+    accessorKey: 'product_or_item',
+    header: ({ column }) => <DataTableColumnHeader column={column} columnTitle="Product / Item" />,
     cell: ({ row }) => (
       <TextCell>
-        {row.original.type === 'item_quantity_change' ? (row.original.item_id ?? '—') : (row.original.offer_display_name || '—')}
+        {row.original.type === 'item_quantity_change' ? (row.original.item_id ?? '—') : (row.original.product_display_name || '—')}
       </TextCell>
     ),
     enableSorting: false,
@@ -145,7 +145,7 @@ export function TransactionTable() {
         customer_id: true,
         price: true,
         // Hide the rest by default; users can enable via View menu
-        offer_or_item: false,
+        product_or_item: false,
         quantity: false,
         test_mode: true,
         status: false,
diff --git a/apps/dashboard/src/components/payments/create-checkout-dialog.tsx b/apps/dashboard/src/components/payments/create-checkout-dialog.tsx
index 4385fcfbc6..f6aab07645 100644
--- a/apps/dashboard/src/components/payments/create-checkout-dialog.tsx
+++ b/apps/dashboard/src/components/payments/create-checkout-dialog.tsx
@@ -1,12 +1,12 @@
-import { Team, ServerUser } from "@stackframe/stack";
+import { useAdminApp } from "@/app/(main)/(protected)/projects/[projectId]/use-admin-app";
+import { ServerUser, Team } from "@stackframe/stack";
 import { KnownErrors } from "@stackframe/stack-shared";
 import { Result } from "@stackframe/stack-shared/dist/utils/results";
+import { ActionDialog, InlineCode, Typography, toast } from "@stackframe/stack-ui";
 import { useState } from "react";
-import { ActionDialog, InlineCode, toast, Typography } from "@stackframe/stack-ui";
+import * as yup from "yup";
 import { FormDialog } from "../form-dialog";
-import { useAdminApp } from "@/app/(main)/(protected)/projects/[projectId]/use-admin-app";
 import { SelectField } from "../form-fields";
-import * as yup from "yup";
 
 type Props = {
   open: boolean,
@@ -27,19 +27,19 @@ export function CreateCheckoutDialog(props: Props) {
   const config = project.useConfig();
   const [checkoutUrl, setCheckoutUrl] = useState<string | null>(null);
   const customer = props.user ?? props.team;
-  const offers = config.payments.offers;
-  const shownOffers = Object.keys(offers).filter(id => offers[id].customerType === (props.user ? "user" : "team"));
+  const products = config.payments.products;
+  const shownProducts = Object.keys(products).filter(id => products[id].customerType === (props.user ? "user" : "team"));
 
-  const createCheckoutUrl = async (data: { offerId: string }) => {
-    const result = await Result.fromPromise(customer.createCheckoutUrl({ offerId: data.offerId }));
+  const createCheckoutUrl = async (data: { productId: string }) => {
+    const result = await Result.fromPromise(customer.createCheckoutUrl({ productId: data.productId }));
     if (result.status === "ok") {
       setCheckoutUrl(result.data);
       return;
     }
-    if (result.error instanceof KnownErrors.OfferDoesNotExist) {
-      toast({ title: "Offer with given offerId does not exist", variant: "destructive" });
-    } else if (result.error instanceof KnownErrors.OfferCustomerTypeDoesNotMatch) {
-      toast({ title: "Customer type does not match expected type for this offer", variant: "destructive" });
+    if (result.error instanceof KnownErrors.ProductDoesNotExist) {
+      toast({ title: "Product with given productId does not exist", variant: "destructive" });
+    } else if (result.error instanceof KnownErrors.ProductCustomerTypeDoesNotMatch) {
+      toast({ title: "Customer type does not match expected type for this product", variant: "destructive" });
     } else if (result.error instanceof KnownErrors.CustomerDoesNotExist) {
       toast({ title: "Customer with given customerId does not exist", variant: "destructive" });
     } else {
@@ -55,16 +55,16 @@ export function CreateCheckoutDialog(props: Props) {
         onOpenChange={props.onOpenChange}
         title="Create Checkout URL"
         formSchema={yup.object({
-          offerId: yup.string().defined().label("Offer ID"),
+          productId: yup.string().defined().label("Product ID"),
         })}
         cancelButton
         okButton={{ label: "Create" }}
         onSubmit={values => createCheckoutUrl(values)}
         render={form => <SelectField
           control={form.control}
-          name="offerId"
-          label="Offer"
-          options={shownOffers.map(id => ({ value: id, label: id }))}
+          name="productId"
+          label="Product"
+          options={shownProducts.map(id => ({ value: id, label: id }))}
         />}
       />
       <ActionDialog
diff --git a/apps/dashboard/src/components/payments/offer-dialog.tsx b/apps/dashboard/src/components/payments/offer-dialog.tsx
index 351bbb37f7..e0af474aaa 100644
--- a/apps/dashboard/src/components/payments/offer-dialog.tsx
+++ b/apps/dashboard/src/components/payments/offer-dialog.tsx
@@ -5,9 +5,9 @@ import { CheckboxField, InputField, SelectField } from "@/components/form-fields
 import { IncludedItemEditorField } from "@/components/payments/included-item-editor";
 import { PriceEditorField } from "@/components/payments/price-editor";
 import { AdminProject } from "@stackframe/stack";
-import { offerSchema, priceOrIncludeByDefaultSchema, userSpecifiedIdSchema, yupRecord } from "@stackframe/stack-shared/dist/schema-fields";
+import { priceOrIncludeByDefaultSchema, productSchema, userSpecifiedIdSchema, yupRecord } from "@stackframe/stack-shared/dist/schema-fields";
 import { has } from "@stackframe/stack-shared/dist/utils/objects";
-import { Accordion, AccordionContent, AccordionItem, AccordionTrigger, FormLabel, FormItem, FormMessage, toast, FormField, Checkbox, FormControl, SimpleTooltip } from "@stackframe/stack-ui";
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Checkbox, FormControl, FormField, FormItem, FormLabel, FormMessage, SimpleTooltip, toast } from "@stackframe/stack-ui";
 import * as yup from "yup";
 
 type Props = {
@@ -22,15 +22,15 @@ type Props = {
       mode: "edit",
       initial: {
         id: string,
-        value: yup.InferType<typeof offerSchema>,
+        value: yup.InferType<typeof productSchema>,
       },
     }
   )
 
-export function OfferDialog({ open, onOpenChange, project, mode, initial }: Props) {
+export function ProductDialog({ open, onOpenChange, project, mode, initial }: Props) {
   const config = project.useConfig();
-  const localOfferSchema = yup.object({
-    offerId: userSpecifiedIdSchema("offerId").defined().label("Offer ID"),
+  const localProductSchema = yup.object({
+    productId: userSpecifiedIdSchema("productId").defined().label("Product ID"),
     displayName: yup.string().defined().label("Display Name"),
     customerType: yup.string().oneOf(["user", "team", "custom"]).defined().label("Customer Type"),
     prices: priceOrIncludeByDefaultSchema.defined().label("Prices").test("at-least-one-price", (value, context) => {
@@ -55,19 +55,19 @@ export function OfferDialog({ open, onOpenChange, project, mode, initial }: Prop
     <FormDialog
       open={open}
       onOpenChange={onOpenChange}
-      title={mode === "create" ? "Create New Offer" : "Edit Offer"}
-      formSchema={localOfferSchema}
+      title={mode === "create" ? "Create New Product" : "Edit Product"}
+      formSchema={localProductSchema}
       defaultValues={initial?.value ? {
-        offerId: initial.id,
+        productId: initial.id,
         ...initial.value,
       } : undefined}
-      okButton={{ label: mode === "create" ? "Create Offer" : "Save" }}
+      okButton={{ label: mode === "create" ? "Create Product" : "Save" }}
       cancelButton
       onSubmit={async (values) => {
         if (mode === "create") {
           const config = await project.getConfig();
-          if (has(config.payments.offers, values.offerId)) {
-            toast({ title: "An offer with this ID already exists", variant: "destructive" });
+          if (has(config.payments.products, values.productId)) {
+            toast({ title: "An product with this ID already exists", variant: "destructive" });
             return "prevent-close-and-prevent-reset";
           }
         }
@@ -79,11 +79,11 @@ export function OfferDialog({ open, onOpenChange, project, mode, initial }: Prop
           serverOnly: values.serverOnly,
           stackable: values.stackable,
         };
-        await project.updateConfig({ [`payments.offers.${values.offerId}`]: payload });
+        await project.updateConfig({ [`payments.products.${values.productId}`]: payload });
       }}
       render={(form) => (
         <div className="space-y-4">
-          <InputField control={form.control} name={"offerId"} label="Offer ID" required disabled={mode === "edit"} placeholder="team" />
+          <InputField control={form.control} name={"productId"} label="Product ID" required disabled={mode === "edit"} placeholder="team" />
           <InputField control={form.control} name={"displayName"} label="Display Name" required placeholder="Team" />
           <SelectField control={form.control} name={"customerType"} label="Customer Type" required options={[
             { value: "user", label: "User" },
@@ -128,7 +128,7 @@ export function OfferDialog({ open, onOpenChange, project, mode, initial }: Prop
                       </FormControl>
                       <div className="space-y-1 leading-none">
                         <FormLabel>
-                          <SimpleTooltip tooltip="The default offer that is included in the group">
+                          <SimpleTooltip tooltip="The default product that is included in the group">
                             Include by default
                           </SimpleTooltip>
                         </FormLabel>
diff --git a/apps/dashboard/src/components/payments/price-editor.tsx b/apps/dashboard/src/components/payments/price-editor.tsx
index cf7818c1b9..c914f14b70 100644
--- a/apps/dashboard/src/components/payments/price-editor.tsx
+++ b/apps/dashboard/src/components/payments/price-editor.tsx
@@ -1,15 +1,15 @@
 "use client";
 
-import { DayInterval } from "@stackframe/stack-shared/dist/utils/dates";
 import { InputField } from "@/components/form-fields";
-import { Control, FieldValues, Path } from "react-hook-form";
-import { KeyedRecordEditorField } from "../form-fields/keyed-record-editor-field";
+import { readableInterval } from "@/lib/dates";
 import { dayIntervalSchema, userSpecifiedIdSchema } from "@stackframe/stack-shared/dist/schema-fields";
+import { DayInterval } from "@stackframe/stack-shared/dist/utils/dates";
+import { Control, FieldValues, Path } from "react-hook-form";
 import * as yup from "yup";
-import { readableInterval } from "@/lib/dates";
 import { DayIntervalSelectorField } from "../form-fields/day-interval-selector-field";
+import { KeyedRecordEditorField } from "../form-fields/keyed-record-editor-field";
 
-type OfferPrice = {
+type ProductPrice = {
   USD: string,
   interval?: DayInterval,
   freeTrial?: DayInterval,
@@ -55,7 +55,7 @@ export function PriceEditorField<F extends FieldValues>(props: {
           USD: yup.string().defined().label("Price (USD)"),
           interval: dayIntervalSchema.optional().label("Interval"),
         }),
-        toFormValue: (id: string, value: OfferPrice) => typeof value === "string" ? value : ({
+        toFormValue: (id: string, value: ProductPrice) => typeof value === "string" ? value : ({
           id,
           USD: value.USD,
           interval: value.interval,
diff --git a/apps/e2e/tests/backend/backend-helpers.ts b/apps/e2e/tests/backend/backend-helpers.ts
index 9d9e73f564..0a9b60bb3a 100644
--- a/apps/e2e/tests/backend/backend-helpers.ts
+++ b/apps/e2e/tests/backend/backend-helpers.ts
@@ -1447,9 +1447,9 @@ export namespace Payments {
     await Payments.setup();
     await Project.updateConfig({
       payments: {
-        offers: {
-          "test-offer": {
-            displayName: "Test Offer",
+        products: {
+          "test-product": {
+            displayName: "Test Product",
             customerType: "user",
             serverOnly: false,
             stackable: false,
@@ -1472,7 +1472,7 @@ export namespace Payments {
       body: {
         customer_type: "user",
         customer_id: userId,
-        offer_id: "test-offer",
+        product_id: "test-product",
       },
     });
     expect(response.status).toBe(200);
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
index d95df0d6a0..38261f457b 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
@@ -1,15 +1,15 @@
 import { expect } from "vitest";
 import { it } from "../../../../../helpers";
-import { niceBackendFetch, Payments as PaymentsHelper, Project, User, InternalProjectKeys, backendContext } from "../../../../backend-helpers";
+import { Payments as PaymentsHelper, Project, User, niceBackendFetch } from "../../../../backend-helpers";
 
 async function setupProjectWithPaymentsConfig() {
   await Project.createAndSwitch();
   await PaymentsHelper.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "sub-offer": {
-          displayName: "Sub Offer",
+      products: {
+        "sub-product": {
+          displayName: "Sub Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -18,8 +18,8 @@ async function setupProjectWithPaymentsConfig() {
           },
           includedItems: {},
         },
-        "otp-offer": {
-          displayName: "One-Time Offer",
+        "otp-product": {
+          displayName: "One-Time Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -36,14 +36,14 @@ async function setupProjectWithPaymentsConfig() {
   });
 }
 
-async function createPurchaseCode(options: { userId: string, offerId: string }) {
+async function createPurchaseCode(options: { userId: string, productId: string }) {
   const res = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: options.userId,
-      offer_id: options.offerId,
+      product_id: options.productId,
     },
   });
   expect(res.status).toBe(200);
@@ -75,7 +75,7 @@ it("returns empty list for fresh project", async () => {
 it("includes TEST_MODE subscription", async () => {
   await setupProjectWithPaymentsConfig();
   const { userId } = await User.create();
-  const code = await createPurchaseCode({ userId, offerId: "sub-offer" });
+  const code = await createPurchaseCode({ userId, productId: "sub-product" });
 
   const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
     accessType: "admin",
@@ -95,7 +95,7 @@ it("includes TEST_MODE subscription", async () => {
         "customer_id": "<stripped UUID>",
         "customer_type": "user",
         "id": "<stripped UUID>",
-        "offer_display_name": "Sub Offer",
+        "product_display_name": "Sub Product",
         "price": {
           "USD": "1000",
           "interval": [
@@ -115,7 +115,7 @@ it("includes TEST_MODE subscription", async () => {
 it("includes TEST_MODE one-time purchase", async () => {
   await setupProjectWithPaymentsConfig();
   const { userId } = await User.create();
-  const code = await createPurchaseCode({ userId, offerId: "otp-offer" });
+  const code = await createPurchaseCode({ userId, productId: "otp-product" });
 
   const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
     accessType: "admin",
@@ -135,7 +135,7 @@ it("includes TEST_MODE one-time purchase", async () => {
         "customer_id": "<stripped UUID>",
         "customer_type": "user",
         "id": "<stripped UUID>",
-        "offer_display_name": "One-Time Offer",
+        "product_display_name": "One-Time Product",
         "price": { "USD": "5000" },
         "quantity": 1,
         "status": null,
@@ -172,7 +172,7 @@ it("includes item quantity change entries", async () => {
         "expires_at_millis": <stripped field 'expires_at_millis'>,
         "id": "<stripped UUID>",
         "item_id": "credits",
-        "offer_display_name": null,
+        "product_display_name": null,
         "price": null,
         "quantity": 5,
         "status": null,
@@ -189,7 +189,7 @@ it("supports concatenated cursor pagination", async () => {
 
   // Make a few entries across tables
   {
-    const code = await createPurchaseCode({ userId, offerId: "sub-offer" });
+    const code = await createPurchaseCode({ userId, productId: "sub-product" });
     await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
       accessType: "admin",
       method: "POST",
@@ -197,7 +197,7 @@ it("supports concatenated cursor pagination", async () => {
     });
   }
   {
-    const code = await createPurchaseCode({ userId, offerId: "otp-offer" });
+    const code = await createPurchaseCode({ userId, productId: "otp-product" });
     await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
       accessType: "admin",
       method: "POST",
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/create-purchase-url.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/create-purchase-url.test.ts
index c09c22c5ac..9df5ba4a73 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/create-purchase-url.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/create-purchase-url.test.ts
@@ -1,8 +1,8 @@
-import { it } from "../../../../../helpers";
-import { Auth, Project, User, niceBackendFetch, Payments } from "../../../../backend-helpers";
 import { generateUuid } from "@stackframe/stack-shared/dist/utils/uuids";
+import { it } from "../../../../../helpers";
+import { Auth, Payments, Project, User, niceBackendFetch } from "../../../../backend-helpers";
 
-it("should not be able to create purchase URL without offer_id or offer_inline", async ({ expect }) => {
+it("should not be able to create purchase URL without product_id or product_inline", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
@@ -16,20 +16,20 @@ it("should not be able to create purchase URL without offer_id or offer_inline",
   expect(response).toMatchInlineSnapshot(`
       NiceResponse {
         "status": 400,
-        "body": "Must specify either offer_id or offer_inline!",
+        "body": "Must specify either product_id or product_inline!",
         "headers": Headers { <some fields may have been hidden> },
       }
     `);
 });
 
-it("should error for non-existent offer_id", async ({ expect }) => {
+it("should error for non-existent product_id", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -51,22 +51,22 @@ it("should error for non-existent offer_id", async ({ expect }) => {
     body: {
       customer_type: "user",
       customer_id: generateUuid(),
-      offer_id: "non-existent-offer",
+      product_id: "non-existent-product",
     },
   });
   expect(response).toMatchInlineSnapshot(`
       NiceResponse {
         "status": 400,
         "body": {
-          "code": "OFFER_DOES_NOT_EXIST",
+          "code": "PRODUCT_DOES_NOT_EXIST",
           "details": {
             "access_type": "client",
-            "offer_id": "non-existent-offer",
+            "product_id": "non-existent-product",
           },
-          "error": "Offer with ID \\"non-existent-offer\\" does not exist or you don't have permissions to access it.",
+          "error": "Product with ID \\"non-existent-product\\" does not exist or you don't have permissions to access it.",
         },
         "headers": Headers {
-          "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+          "x-stack-known-error": "PRODUCT_DOES_NOT_EXIST",
           <some fields may have been hidden>,
         },
       }
@@ -78,9 +78,9 @@ it("should error for invalid customer_id", async ({ expect }) => {
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -103,24 +103,24 @@ it("should error for invalid customer_id", async ({ expect }) => {
     body: {
       customer_type: "team",
       customer_id: generateUuid(),
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
       "body": {
-        "code": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "code": "PRODUCT_CUSTOMER_TYPE_DOES_NOT_MATCH",
         "details": {
           "actual_customer_type": "team",
           "customer_id": "<stripped UUID>",
-          "offer_customer_type": "user",
-          "offer_id": "test-offer",
+          "product_customer_type": "user",
+          "product_id": "test-product",
         },
-        "error": "The team with ID \\"<stripped UUID>\\" is not a valid customer for the inline offer that has been passed in. The offer is configured to only be available for user customers, but the customer is a team.",
+        "error": "The team with ID \\"<stripped UUID>\\" is not a valid customer for the inline product that has been passed in. The product is configured to only be available for user customers, but the customer is a team.",
       },
       "headers": Headers {
-        "x-stack-known-error": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "x-stack-known-error": "PRODUCT_CUSTOMER_TYPE_DOES_NOT_MATCH",
         <some fields may have been hidden>,
       },
     }
@@ -131,9 +131,9 @@ it("should error for no connected stripe account", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -156,7 +156,7 @@ it("should error for no connected stripe account", async ({ expect }) => {
     body: {
       customer_type: "user",
       customer_id: user.userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(response).toMatchInlineSnapshot(`
@@ -169,7 +169,7 @@ it("should error for no connected stripe account", async ({ expect }) => {
 });
 
 
-it("should not allow offer_inline when calling from client", async ({ expect }) => {
+it("should not allow product_inline when calling from client", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
 
@@ -180,8 +180,8 @@ it("should not allow offer_inline when calling from client", async ({ expect })
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_inline: {
-        display_name: "Inline Test Offer",
+      product_inline: {
+        display_name: "Inline Test Product",
         customer_type: "user",
         server_only: true,
         prices: {
@@ -194,17 +194,17 @@ it("should not allow offer_inline when calling from client", async ({ expect })
       },
     },
   });
-  expect(response.body).toMatchInlineSnapshot(`"Cannot specify offer_inline when calling from client! Please call with a server API key, or use the offer_id parameter."`);
+  expect(response.body).toMatchInlineSnapshot(`"Cannot specify product_inline when calling from client! Please call with a server API key, or use the product_id parameter."`);
 });
 
-it("should error for server-only offer when calling from client", async ({ expect }) => {
+it("should error for server-only product when calling from client", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: true,
           stackable: false,
@@ -227,29 +227,29 @@ it("should error for server-only offer when calling from client", async ({ expec
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
       "body": {
-        "code": "OFFER_DOES_NOT_EXIST",
+        "code": "PRODUCT_DOES_NOT_EXIST",
         "details": {
           "access_type": "client",
-          "offer_id": "test-offer",
+          "product_id": "test-product",
         },
-        "error": "Offer with ID \\"test-offer\\" does not exist or you don't have permissions to access it.",
+        "error": "Product with ID \\"test-product\\" does not exist or you don't have permissions to access it.",
       },
       "headers": Headers {
-        "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+        "x-stack-known-error": "PRODUCT_DOES_NOT_EXIST",
         <some fields may have been hidden>,
       },
     }
   `);
 });
 
-it("should allow offer_inline when calling from server", async ({ expect }) => {
+it("should allow product_inline when calling from server", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
 
@@ -260,8 +260,8 @@ it("should allow offer_inline when calling from server", async ({ expect }) => {
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_inline: {
-        display_name: "Inline Test Offer",
+      product_inline: {
+        display_name: "Inline Test Product",
         customer_type: "user",
         server_only: true,
         prices: {
@@ -278,14 +278,14 @@ it("should allow offer_inline when calling from server", async ({ expect }) => {
   expect(response.body.url).toMatch(/^https?:\/\/localhost:8101\/purchase\/[a-z0-9-_]+$/);
 });
 
-it("should allow valid offer_id", async ({ expect }) => {
+it("should allow valid product_id", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -308,7 +308,7 @@ it("should allow valid offer_id", async ({ expect }) => {
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(response.status).toBe(200);
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
index 9c028e6007..7ac1e2b1bc 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
@@ -39,7 +39,7 @@ it("should error on invalid price_id", async ({ expect }) => {
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "Price not found on offer associated with this purchase code",
+      "body": "Price not found on product associated with this purchase code",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -70,9 +70,9 @@ it("should return client secret for one-time price (no interval)", async ({ expe
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "ot-offer": {
-          displayName: "One Time Offer",
+      products: {
+        "ot-product": {
+          displayName: "One Time Product",
           customerType: "user",
           serverOnly: false,
           stackable: true,
@@ -94,7 +94,7 @@ it("should return client secret for one-time price (no interval)", async ({ expe
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "ot-offer",
+      product_id: "ot-product",
     },
   });
   expect(urlRes.status).toBe(200);
@@ -113,12 +113,12 @@ it("should return client secret for one-time price (no interval)", async ({ expe
   expect(res.body).toEqual({ client_secret: expect.any(String) });
 });
 
-it("should error on one-time price quantity > 1 when offer is not stackable", async ({ expect }) => {
+it("should error on one-time price quantity > 1 when product is not stackable", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "ot-non-stack": {
           displayName: "One Time Non-Stackable",
           customerType: "user",
@@ -140,7 +140,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "ot-non-stack",
+      product_id: "ot-non-stack",
     },
   });
   expect(urlRes.status).toBe(200);
@@ -158,7 +158,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
   expect(res).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
+      "body": "This product is not stackable; quantity must be 1",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -170,9 +170,9 @@ it("should return client secret for one-time price even if a conflicting group s
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Test Group" } },
-      offers: {
-        subOffer: {
-          displayName: "Sub Offer",
+      products: {
+        subProduct: {
+          displayName: "Sub Product",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -195,14 +195,14 @@ it("should return client secret for one-time price even if a conflicting group s
 
   const { userId } = await User.create();
 
-  // Create test-mode DB-only subscription for subOffer
+  // Create test-mode DB-only subscription for subProduct
   const createUrlRespA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "subOffer",
+      product_id: "subProduct",
     },
   });
   expect(createUrlRespA.status).toBe(200);
@@ -214,14 +214,14 @@ it("should return client secret for one-time price even if a conflicting group s
   });
   expect(testModeRes.status).toBe(200);
 
-  // Now purchase one-time offer in same group; should succeed and return client secret
+  // Now purchase one-time product in same group; should succeed and return client secret
   const createUrlRespB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "oneTime",
+      product_id: "oneTime",
     },
   });
   expect(createUrlRespB.status).toBe(200);
@@ -241,12 +241,12 @@ it("should return client secret for one-time price even if a conflicting group s
   `);
 });
 
-it("test-mode should error on one-time price quantity > 1 when offer is not stackable", async ({ expect }) => {
+it("test-mode should error on one-time price quantity > 1 when product is not stackable", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         tmOneTime: {
           displayName: "TM One Time",
           customerType: "user",
@@ -263,7 +263,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "tmOneTime" },
+    body: { customer_type: "user", customer_id: userId, product_id: "tmOneTime" },
   });
   expect(urlRes.status).toBe(200);
   const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
@@ -276,7 +276,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   expect(res).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
+      "body": "This product is not stackable; quantity must be 1",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -296,13 +296,13 @@ it("should create purchase URL, validate code, and create purchase session", asy
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
+      "body": "This product is not stackable; quantity must be 1",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
 });
 
-it("should create purchase URL with inline offer, validate code, and create purchase session", async ({ expect }) => {
+it("should create purchase URL with inline product, validate code, and create purchase session", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Payments.setup();
 
@@ -313,8 +313,8 @@ it("should create purchase URL with inline offer, validate code, and create purc
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_inline: {
-        display_name: "Inline Test Offer",
+      product_inline: {
+        display_name: "Inline Test Product",
         customer_type: "user",
         server_only: true,
         prices: {
@@ -384,9 +384,9 @@ it("creates subscription in test mode and increases included item quantity", asy
           customerType: "user",
         },
       },
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -411,7 +411,7 @@ it("creates subscription in test mode and increases included item quantity", asy
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(createUrlResponse.status).toBe(200);
@@ -511,7 +511,7 @@ it("test-mode should error on invalid price_id", async ({ expect }) => {
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "Price not found on offer associated with this purchase code",
+      "body": "Price not found on product associated with this purchase code",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -528,9 +528,9 @@ it("allows stackable quantity in test mode and multiplies included items", async
           customerType: "user",
         },
       },
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: true,
@@ -555,7 +555,7 @@ it("allows stackable quantity in test mode and multiplies included items", async
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(createUrlResponse.status).toBe(200);
@@ -589,7 +589,7 @@ it("allows stackable quantity in test mode and multiplies included items", async
   expect(getAfter.body.quantity).toBe(6);
 });
 
-it("should update existing stripe subscription when switching offers within a group (non test-mode)", async ({ expect }) => {
+it("should update existing stripe subscription when switching products within a group (non test-mode)", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
@@ -597,9 +597,9 @@ it("should update existing stripe subscription when switching offers within a gr
       groups: {
         grp: { displayName: "Test Group" },
       },
-      offers: {
-        offerA: {
-          displayName: "Offer A",
+      products: {
+        productA: {
+          displayName: "Product A",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -612,8 +612,8 @@ it("should update existing stripe subscription when switching offers within a gr
           },
           includedItems: {},
         },
-        offerB: {
-          displayName: "Offer B",
+        productB: {
+          displayName: "Product B",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -632,14 +632,14 @@ it("should update existing stripe subscription when switching offers within a gr
 
   const { userId } = await User.create();
 
-  // First purchase: Offer A
+  // First purchase: Product A
   const createUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "offerA",
+      product_id: "productA",
     },
   });
   expect(createUrlA.status).toBe(200);
@@ -663,14 +663,14 @@ it("should update existing stripe subscription when switching offers within a gr
     }
   `);
 
-  // Second purchase: Offer B in same group (should update existing Stripe subscription)
+  // Second purchase: Product B in same group (should update existing Stripe subscription)
   const createUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "offerB",
+      product_id: "productB",
     },
   });
   expect(createUrlB.status).toBe(200);
@@ -703,9 +703,9 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
       groups: {
         grp: { displayName: "Test Group" },
       },
-      offers: {
-        offerA: {
-          displayName: "Offer A",
+      products: {
+        productA: {
+          displayName: "Product A",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -718,8 +718,8 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           },
           includedItems: {},
         },
-        offerB: {
-          displayName: "Offer B",
+        productB: {
+          displayName: "Product B",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -738,14 +738,14 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
 
   const { userId } = await User.create();
 
-  // Create test-mode DB-only subscription for offerA
+  // Create test-mode DB-only subscription for productA
   const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "offerA",
+      product_id: "productA",
     },
   });
   expect(resUrlA.status).toBe(200);
@@ -763,14 +763,14 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   });
   expect(testModeRes.status).toBe(200);
 
-  // Now purchase offerB in non test-mode; should cancel DB-only sub and create Stripe subscription
+  // Now purchase productB in non test-mode; should cancel DB-only sub and create Stripe subscription
   const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "offerB",
+      product_id: "productB",
     },
   });
   expect(resUrlB.status).toBe(200);
@@ -795,14 +795,14 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   `);
 });
 
-it("should block one-time purchase for same offer after prior one-time purchase (test-mode persisted)", async ({ expect }) => {
+it("should block one-time purchase for same product after prior one-time purchase (test-mode persisted)", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         ot: {
-          displayName: "One Time Offer",
+          displayName: "One Time Product",
           customerType: "user",
           serverOnly: false,
           stackable: true,
@@ -818,7 +818,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
   const createUrl1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
+    body: { customer_type: "user", customer_id: userId, product_id: "ot" },
   });
   expect(createUrl1.status).toBe(200);
   const code1 = (createUrl1.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -831,11 +831,11 @@ it("should block one-time purchase for same offer after prior one-time purchase
   });
   expect(testModeRes.status).toBe(200);
 
-  // Second: attempt another purchase for same offer (should be blocked by OneTimePurchase)
+  // Second: attempt another purchase for same product (should be blocked by OneTimePurchase)
   const createUrl2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
+    body: { customer_type: "user", customer_id: userId, product_id: "ot" },
   });
   expect(createUrl2.status).toBe(200);
   const code2 = (createUrl2.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -847,7 +847,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
     body: { full_code: code2, price_id: "one", quantity: 1 },
   });
   expect(res.status).toBe(400);
-  expect(String(res.body)).toContain("one-time purchase for this offer");
+  expect(String(res.body)).toContain("one-time purchase for this product");
 });
 
 it("should block one-time purchase in same group after prior one-time purchase in that group (test-mode persisted)", async ({ expect }) => {
@@ -856,9 +856,9 @@ it("should block one-time purchase in same group after prior one-time purchase i
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Group" } },
-      offers: {
-        offerA: {
-          displayName: "Offer A",
+      products: {
+        productA: {
+          displayName: "Product A",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -866,8 +866,8 @@ it("should block one-time purchase in same group after prior one-time purchase i
           prices: { one: { USD: "500" } },
           includedItems: {},
         },
-        offerB: {
-          displayName: "Offer B",
+        productB: {
+          displayName: "Product B",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -880,11 +880,11 @@ it("should block one-time purchase in same group after prior one-time purchase i
   });
 
   const { userId } = await User.create();
-  // Purchase offerA in TEST_MODE (persists OneTimePurchase)
+  // Purchase productA in TEST_MODE (persists OneTimePurchase)
   const urlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
+    body: { customer_type: "user", customer_id: userId, product_id: "productA" },
   });
   expect(urlA.status).toBe(200);
   const codeA = (urlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -897,11 +897,11 @@ it("should block one-time purchase in same group after prior one-time purchase i
   });
   expect(tmRes.status).toBe(200);
 
-  // Attempt to purchase offerB in same group (should be blocked)
+  // Attempt to purchase productB in same group (should be blocked)
   const urlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
+    body: { customer_type: "user", customer_id: userId, product_id: "productB" },
   });
   expect(urlB.status).toBe(200);
   const codeB = (urlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -913,5 +913,5 @@ it("should block one-time purchase in same group after prior one-time purchase i
     body: { full_code: codeB, price_id: "one", quantity: 1 },
   });
   expect(resB.status).toBe(400);
-  expect(String(resB.body)).toContain("one-time purchase in this offer group");
+  expect(String(resB.body)).toContain("one-time purchase in this product group");
 });
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
index 7b78026a63..d36c702e55 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
@@ -26,7 +26,7 @@ it("should error on invalid code", async ({ expect }) => {
   `);
 });
 
-it("should allow valid code and return offer data", async ({ expect }) => {
+it("should allow valid code and return product data", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
   const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
     method: "POST",
@@ -38,10 +38,10 @@ it("should allow valid code and return offer data", async ({ expect }) => {
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_offers": [],
-        "offer": {
+        "conflicting_group_products": [],
+        "product": {
           "customer_type": "user",
-          "display_name": "Test Offer",
+          "display_name": "Test Product",
           "prices": {
             "monthly": {
               "USD": "1000",
@@ -61,14 +61,14 @@ it("should allow valid code and return offer data", async ({ expect }) => {
   `);
 });
 
-it("should set already_bought_non_stackable when user already owns non-stackable offer", async ({ expect }) => {
+it("should set already_bought_non_stackable when user already owns non-stackable product", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
-        "test-offer": {
-          displayName: "Test Offer",
+      products: {
+        "test-product": {
+          displayName: "Test Product",
           customerType: "user",
           serverOnly: false,
           stackable: false,
@@ -85,14 +85,14 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   });
 
   const { userId } = await User.create();
-  // Create a code for test-offer and purchase it in test mode (creates DB subscription)
+  // Create a code for test-product and purchase it in test mode (creates DB subscription)
   const createUrlRes1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(createUrlRes1.status).toBe(200);
@@ -110,14 +110,14 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   });
   expect(testModeRes.status).toBe(200);
 
-  // Create a second code for the same offer and validate; should report already_bought_non_stackable
+  // Create a second code for the same product and validate; should report already_bought_non_stackable
   const createUrlRes2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(createUrlRes2.status).toBe(200);
@@ -134,10 +134,10 @@ it("should set already_bought_non_stackable when user already owns non-stackable
       "status": 200,
       "body": {
         "already_bought_non_stackable": true,
-        "conflicting_group_offers": [],
-        "offer": {
+        "conflicting_group_products": [],
+        "product": {
           "customer_type": "user",
-          "display_name": "Test Offer",
+          "display_name": "Test Product",
           "prices": {
             "monthly": {
               "USD": "1000",
@@ -157,15 +157,15 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   `);
 });
 
-it("should include conflicting_group_offers when switching within the same group", async ({ expect }) => {
+it("should include conflicting_group_products when switching within the same group", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Group" } },
-      offers: {
-        offerA: {
-          displayName: "Offer A",
+      products: {
+        productA: {
+          displayName: "Product A",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -173,8 +173,8 @@ it("should include conflicting_group_offers when switching within the same group
           prices: { monthly: { USD: "1000", interval: [1, "month"] } },
           includedItems: {},
         },
-        offerB: {
-          displayName: "Offer B",
+        productB: {
+          displayName: "Product B",
           customerType: "user",
           serverOnly: false,
           groupId: "grp",
@@ -188,11 +188,11 @@ it("should include conflicting_group_offers when switching within the same group
 
   const { userId } = await User.create();
 
-  // Subscribe to offerA in test mode
+  // Subscribe to productA in test mode
   const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
+    body: { customer_type: "user", customer_id: userId, product_id: "productA" },
   });
   expect(resUrlA.status).toBe(200);
   const codeA = (resUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -205,11 +205,11 @@ it("should include conflicting_group_offers when switching within the same group
   });
   expect(testModeRes.status).toBe(200);
 
-  // Now validate code for offerB; should report conflict with offerA
+  // Now validate code for productB; should report conflict with productA
   const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
-    body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
+    body: { customer_type: "user", customer_id: userId, product_id: "productB" },
   });
   expect(resUrlB.status).toBe(200);
   const codeB = (resUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
@@ -225,15 +225,15 @@ it("should include conflicting_group_offers when switching within the same group
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_offers": [
+        "conflicting_group_products": [
           {
-            "display_name": "Offer A",
-            "offer_id": "offerA",
+            "display_name": "Product A",
+            "product_id": "productA",
           },
         ],
-        "offer": {
+        "product": {
           "customer_type": "user",
-          "display_name": "Offer B",
+          "display_name": "Product B",
           "prices": {
             "monthly": {
               "USD": "2000",
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/stripe-webhooks.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/stripe-webhooks.test.ts
index 2c49f04b46..e6da6e3b76 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/stripe-webhooks.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/stripe-webhooks.test.ts
@@ -75,10 +75,10 @@ it("deduplicates one-time purchase on payment_intent.succeeded retry", async ({
   await Project.createAndSwitch();
   await Payments.setup();
 
-  // Configure an offer that grants 1 unit of an item via one-time purchase
+  // Configure an product that grants 1 unit of an item via one-time purchase
   const itemId = "one-time-credits";
-  const offerId = "ot";
-  const offer = {
+  const productId = "ot";
+  const product = {
     displayName: "One-time Credits Pack",
     customerType: "user",
     serverOnly: false,
@@ -92,8 +92,8 @@ it("deduplicates one-time purchase on payment_intent.succeeded retry", async ({
       items: {
         [itemId]: { displayName: "Credits", customerType: "user" },
       },
-      offers: {
-        [offerId]: offer,
+      products: {
+        [productId]: product,
       },
     },
   });
@@ -123,7 +123,7 @@ it("deduplicates one-time purchase on payment_intent.succeeded retry", async ({
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: offerId,
+      product_id: productId,
     },
   });
   expect(createUrlResponse.status).toBe(200);
@@ -144,8 +144,8 @@ it("deduplicates one-time purchase on payment_intent.succeeded retry", async ({
           "subscriptions.list": { data: [] },
         },
         metadata: {
-          offerId,
-          offer: JSON.stringify(offer),
+          productId,
+          product: JSON.stringify(product),
           customerId: userId,
           customerType: "user",
           purchaseQuantity: "1",
@@ -177,8 +177,8 @@ it("syncs subscriptions from webhook and is idempotent", async ({ expect }) => {
   await Payments.setup();
 
   const itemId = "subscription-credits";
-  const offerId = "sub-monthly";
-  const offer = {
+  const productId = "sub-monthly";
+  const product = {
     displayName: "Monthly Subscription",
     customerType: "user",
     serverOnly: false,
@@ -192,8 +192,8 @@ it("syncs subscriptions from webhook and is idempotent", async ({ expect }) => {
       items: {
         [itemId]: { displayName: "Credits", customerType: "user" },
       },
-      offers: {
-        [offerId]: offer,
+      products: {
+        [productId]: product,
       },
     },
   });
@@ -218,7 +218,7 @@ it("syncs subscriptions from webhook and is idempotent", async ({ expect }) => {
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: offerId,
+      product_id: productId,
     },
   });
   expect(createUrlResponse.status).toBe(200);
@@ -240,8 +240,8 @@ it("syncs subscriptions from webhook and is idempotent", async ({ expect }) => {
       ],
     },
     metadata: {
-      offerId,
-      offer: JSON.stringify(offer),
+      productId,
+      product: JSON.stringify(product),
       priceId: "monthly",
     },
     cancel_at_period_end: false,
@@ -290,8 +290,8 @@ it("updates a user's subscriptions via webhook (add then remove)", async ({ expe
   await Payments.setup();
 
   const itemId = "subscription-seat";
-  const offerId = "pro-monthly";
-  const offer = {
+  const productId = "pro-monthly";
+  const product = {
     displayName: "Pro Monthly",
     customerType: "user",
     serverOnly: false,
@@ -305,8 +305,8 @@ it("updates a user's subscriptions via webhook (add then remove)", async ({ expe
       items: {
         [itemId]: { displayName: "Seat", customerType: "user" },
       },
-      offers: {
-        [offerId]: offer,
+      products: {
+        [productId]: product,
       },
     },
   });
@@ -331,7 +331,7 @@ it("updates a user's subscriptions via webhook (add then remove)", async ({ expe
     body: {
       customer_type: "user",
       customer_id: userId,
-      offer_id: offerId,
+      product_id: productId,
     },
   });
   expect(createUrlResponse.status).toBe(200);
@@ -353,8 +353,8 @@ it("updates a user's subscriptions via webhook (add then remove)", async ({ expe
       ],
     },
     metadata: {
-      offerId,
-      offer: JSON.stringify(offer),
+      productId,
+      product: JSON.stringify(product),
       priceId: "monthly",
     },
     cancel_at_period_end: false,
diff --git a/docs/src/app/api/chat/route.ts b/docs/src/app/api/chat/route.ts
index cf77af1623..9632de92f6 100644
--- a/docs/src/app/api/chat/route.ts
+++ b/docs/src/app/api/chat/route.ts
@@ -97,7 +97,7 @@ When users need personalized support, have complex issues, or ask for help beyon
 - If you're unsure about a Stack Auth feature, say "As an AI, I don't know" or "As an AI, I'm not certain" clearly
 - Avoid saying things are "not possible" or "impossible", instead say that you don't know
 - Ask clarifying questions to better understand the user's needs
-- Offer to help with related Stack Auth topics that might be useful
+- Product to help with related Stack Auth topics that might be useful
 - Provide the best information you can based on your knowledge, but acknowledge limitations
 - If the issue is complex or requires personalized assistance, direct them to Discord or email support
 
diff --git a/docs/templates-api/overview.mdx b/docs/templates-api/overview.mdx
index 4cea2670d8..d7af90cbf9 100644
--- a/docs/templates-api/overview.mdx
+++ b/docs/templates-api/overview.mdx
@@ -6,7 +6,7 @@ full: true
 
 # REST API & Webhooks
 
-Stack offers a REST API for backends & frontends of any programming language or framework. This API is used to authenticate users, manage user data, and more.
+Stack products a REST API for backends & frontends of any programming language or framework. This API is used to authenticate users, manage user data, and more.
 
 ## Authentication
 
diff --git a/docs/templates/concepts/user-onboarding.mdx b/docs/templates/concepts/user-onboarding.mdx
index c451e1575f..0dc2b238db 100644
--- a/docs/templates/concepts/user-onboarding.mdx
+++ b/docs/templates/concepts/user-onboarding.mdx
@@ -47,7 +47,7 @@ export default function OnboardingPage() {
 ```
 
 <Info>
-While the above implementation offers a basic onboarding process, users can still skip onboarding by directly sending an API request to update the `clientMetadata.onboarded` flag. If you want to ensure that onboarding cannot be bypassed on the API level, you should create a server endpoint to validate and store the data, then save the `onboarded` flag in the `clientReadonlyMetadata` on the server side after validation.
+While the above implementation products a basic onboarding process, users can still skip onboarding by directly sending an API request to update the `clientMetadata.onboarded` flag. If you want to ensure that onboarding cannot be bypassed on the API level, you should create a server endpoint to validate and store the data, then save the `onboarded` flag in the `clientReadonlyMetadata` on the server side after validation.
 </Info>
 
 Next, we can create a hook/function to check if the user has completed onboarding and redirect them to the onboarding page:
diff --git a/docs/templates/customization/internationalization.mdx b/docs/templates/customization/internationalization.mdx
index d27064cc15..9a720d1c42 100644
--- a/docs/templates/customization/internationalization.mdx
+++ b/docs/templates/customization/internationalization.mdx
@@ -2,7 +2,7 @@
 title: Internationalization
 ---
 
-Internationalization (i18n) allows your application to support multiple languages, making it accessible to users worldwide. Stack Auth provides built-in internationalization support for its components, enabling you to offer a localized authentication experience with minimal effort.
+Internationalization (i18n) allows your application to support multiple languages, making it accessible to users worldwide. Stack Auth provides built-in internationalization support for its components, enabling you to product a localized authentication experience with minimal effort.
 
 ## Setup
 
diff --git a/docs/templates/customization/page-examples/sign-in.mdx b/docs/templates/customization/page-examples/sign-in.mdx
index ec96ae55a9..45a2cc9483 100644
--- a/docs/templates/customization/page-examples/sign-in.mdx
+++ b/docs/templates/customization/page-examples/sign-in.mdx
@@ -29,7 +29,7 @@ You can also use `useUser` at the beginning of the sign-in page to check whether
 
 `OAuthGroup`: A component that displays a list of available OAuth provider sign-in buttons. The available provider list is automatically fetched from the server based on your project configuration.
 
-`OAuthButton`: A component that renders a single OAuth sign-in button for a specific provider. Use this when you only want to offer specific OAuth providers.
+`OAuthButton`: A component that renders a single OAuth sign-in button for a specific provider. Use this when you only want to product specific OAuth providers.
 
 
 ## Custom OAuth Sign In
diff --git a/docs/templates/customization/page-examples/sign-up.mdx b/docs/templates/customization/page-examples/sign-up.mdx
index 72f0b1ad55..40e8b716ef 100644
--- a/docs/templates/customization/page-examples/sign-up.mdx
+++ b/docs/templates/customization/page-examples/sign-up.mdx
@@ -28,7 +28,7 @@ You can also use `useUser` at the beginning of the sign-up page to check whether
 
 `OAuthGroup`: A component that displays a list of available OAuth provider sign-up buttons. The available provider list is automatically fetched from the server based on your project configuration.
 
-`OAuthButton`: A component that renders a single OAuth sign-up button for a specific provider. Use this when you only want to offer specific OAuth providers.
+`OAuthButton`: A component that renders a single OAuth sign-up button for a specific provider. Use this when you only want to product specific OAuth providers.
 
 ## Custom OAuth Sign Up
 
diff --git a/docs/templates/others/self-host.mdx b/docs/templates/others/self-host.mdx
index 76411e87d0..dafdd4337f 100644
--- a/docs/templates/others/self-host.mdx
+++ b/docs/templates/others/self-host.mdx
@@ -22,7 +22,7 @@ On a high level, Stack Auth is composed of the following services:
 - **Dashboard**: The interface for managing users, teams, auth methods, etc. This is available at [app.stack-auth.com](https://app.stack-auth.com).
 - **Client SDK**: An SDK used to connect your app to the Stack Auth API backend, wrapping API calls and providing easy-to-use interfaces. More details [here](../getting-started/setup.mdx).
 - **Postgres database**: Used to store all user data. We use [Prisma](https://prisma.io) as the ORM and manage the database schema migrations.
-- **Svix**: Used to send webhooks. Svix is open-source and can be self-hosted, but also offers a cloud hosted solution. More on Svix [here](https://svix.com)
+- **Svix**: Used to send webhooks. Svix is open-source and can be self-hosted, but also products a cloud hosted solution. More on Svix [here](https://svix.com)
 - **Email server**: We use [Inbucket](https://inbucket.org) as a local email server for development and a separate SMTP server for production. Any email service supporting SMTP will work.
 - **S3 storage**: We use [S3Mock](https://github.com/adobe/S3Mock) as a local S3 storage for development and a separate S3 storage for production. Any S3 storage will work.
 
diff --git a/docs/templates/overview.mdx b/docs/templates/overview.mdx
index d06ea0f95d..a2bed298da 100644
--- a/docs/templates/overview.mdx
+++ b/docs/templates/overview.mdx
@@ -53,7 +53,7 @@ In truth, the authentication services industry has collectively failed. It's dom
 
 That's why we built Stack Auth. Integrating secure authentication into your app should take **5 minutes**, not 5 days.
 
-At the core of Stack Auth are deep integrations into frontend and backend frameworks. We offer the best developer experience with Next.js. Instead of providing mediocre support for numerous frameworks, we focused on making a few integrations excellent before adding new ones. We also offer a cross-compatible REST API as a fallback.
+At the core of Stack Auth are deep integrations into frontend and backend frameworks. We product the best developer experience with Next.js. Instead of providing mediocre support for numerous frameworks, we focused on making a few integrations excellent before adding new ones. We also product a cross-compatible REST API as a fallback.
 
 Here's an example. To get the current user, simply call:
 
diff --git a/docs/templates/rest-api/overview.mdx b/docs/templates/rest-api/overview.mdx
index 1a85e84bb7..3631ff6824 100644
--- a/docs/templates/rest-api/overview.mdx
+++ b/docs/templates/rest-api/overview.mdx
@@ -4,7 +4,7 @@ description: Complete REST API documentation for Stack Auth
 full: true
 ---
 
-Stack offers a REST API for backends & frontends of any programming language or framework. This API is used to authenticate users, manage user data, and more.
+Stack products a REST API for backends & frontends of any programming language or framework. This API is used to authenticate users, manage user data, and more.
 
 ## Authentication
 
diff --git a/examples/e-commerce/src/app/page.tsx b/examples/e-commerce/src/app/page.tsx
index 729e25cdd9..68633660e4 100644
--- a/examples/e-commerce/src/app/page.tsx
+++ b/examples/e-commerce/src/app/page.tsx
@@ -1,6 +1,6 @@
-import { ServerUser } from "@stackframe/stack";
 import { Shop } from "@/shop";
 import { stackServerApp } from "@/stack";
+import { ServerUser } from "@stackframe/stack";
 
 export default async function Home() {
   const users = await stackServerApp.listUsers();
@@ -34,7 +34,7 @@ export default async function Home() {
       {shops.map(shop => (
         <div key={shop[0].id} className="card">
           <h2>{shop[1].displayName}</h2>
-          Offered by {shop[0].displayName ?? shop[0].primaryEmail}<br />
+          Producted by {shop[0].displayName ?? shop[0].primaryEmail}<br />
           <h3>Products</h3>
           <ul>
             {shop[1].products.map((product, i) => (
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 7c917e1ee6..16288a875d 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -3,7 +3,7 @@
 import * as yup from "yup";
 import { DEFAULT_EMAIL_TEMPLATES, DEFAULT_EMAIL_THEMES, DEFAULT_EMAIL_THEME_ID } from "../helpers/emails";
 import * as schemaFields from "../schema-fields";
-import { offerSchema, userSpecifiedIdSchema, yupBoolean, yupDate, yupMixed, yupNever, yupNumber, yupObject, yupRecord, yupString, yupTuple, yupUnion } from "../schema-fields";
+import { productSchema, userSpecifiedIdSchema, yupBoolean, yupDate, yupMixed, yupNever, yupNumber, yupObject, yupRecord, yupString, yupTuple, yupUnion } from "../schema-fields";
 import { isShallowEqual } from "../utils/arrays";
 import { SUPPORTED_CURRENCIES } from "../utils/currency-constants";
 import { StackAssertionError } from "../utils/errors";
@@ -122,10 +122,10 @@ export const branchPaymentsSchema = yupObject({
     yupObject({
       displayName: yupString().optional(),
     }),
-  ).meta({ openapiField: { description: 'The groups that offers can be in. All offers in a group (besides add-ons) are mutually exclusive.', exampleValue: { "group-id": { displayName: "My Group" } } } }),
-  offers: yupRecord(
-    userSpecifiedIdSchema("offerId"),
-    offerSchema,
+  ).meta({ openapiField: { description: 'The groups that products can be in. All products in a group (besides add-ons) are mutually exclusive.', exampleValue: { "group-id": { displayName: "My Group" } } } }),
+  products: yupRecord(
+    userSpecifiedIdSchema("productId"),
+    productSchema,
   ),
   items: yupRecord(
     userSpecifiedIdSchema("itemId"),
@@ -475,7 +475,7 @@ const organizationConfigDefaults = {
     groups: (key: string) => ({
       displayName: undefined,
     }),
-    offers: (key: string) => ({
+    products: (key: string) => ({
       displayName: key,
       groupId: undefined,
       customerType: "user",
@@ -691,18 +691,18 @@ export async function sanitizeOrganizationConfig(config: OrganizationRenderedCon
     ...DEFAULT_EMAIL_TEMPLATES,
     ...prepared.emails.templates,
   };
-  const offers = typedFromEntries(typedEntries(prepared.payments.offers).map(([key, offer]) => {
-    const isAddOnTo = offer.isAddOnTo === false ?
+  const products = typedFromEntries(typedEntries(prepared.payments.products).map(([key, product]) => {
+    const isAddOnTo = product.isAddOnTo === false ?
       false as const :
-      typedFromEntries(Object.keys(offer.isAddOnTo).map((key) => [key, true as const]));
-    const prices = offer.prices === "include-by-default" ?
+      typedFromEntries(Object.keys(product.isAddOnTo).map((key) => [key, true as const]));
+    const prices = product.prices === "include-by-default" ?
       "include-by-default" as const :
-      typedFromEntries(typedEntries(offer.prices).map(([key, value]) => {
+      typedFromEntries(typedEntries(product.prices).map(([key, value]) => {
         const data = { serverOnly: false, ...(value ?? {}) };
         return [key, data];
       }));
     return [key, {
-      ...offer,
+      ...product,
       isAddOnTo,
       prices,
     }];
@@ -717,7 +717,7 @@ export async function sanitizeOrganizationConfig(config: OrganizationRenderedCon
     },
     payments: {
       ...prepared.payments,
-      offers
+      products
     }
   };
 }
diff --git a/packages/stack-shared/src/interface/client-interface.ts b/packages/stack-shared/src/interface/client-interface.ts
index 4c35c66b65..ac2fcba7f7 100644
--- a/packages/stack-shared/src/interface/client-interface.ts
+++ b/packages/stack-shared/src/interface/client-interface.ts
@@ -2,7 +2,7 @@ import * as oauth from 'oauth4webapi';
 
 import * as yup from 'yup';
 import { KnownError, KnownErrors } from '../known-errors';
-import { inlineOfferSchema } from '../schema-fields';
+import { inlineProductSchema } from '../schema-fields';
 import { AccessToken, InternalSession, RefreshToken } from '../sessions';
 import { generateSecureRandomString } from '../utils/crypto';
 import { StackAssertionError, throwErr } from '../utils/errors';
@@ -1777,12 +1777,12 @@ export class StackClientInterface {
   async createCheckoutUrl(
     customer_type: "user" | "team" | "custom",
     customer_id: string,
-    offerIdOrInline: string | yup.InferType<typeof inlineOfferSchema>,
+    productIdOrInline: string | yup.InferType<typeof inlineProductSchema>,
     session: InternalSession | null,
   ): Promise<string> {
-    const offerBody = typeof offerIdOrInline === "string" ?
-      { offer_id: offerIdOrInline } :
-      { inline_offer: offerIdOrInline };
+    const productBody = typeof productIdOrInline === "string" ?
+      { product_id: productIdOrInline } :
+      { inline_product: productIdOrInline };
     const response = await this.sendClientRequest(
       "/payments/purchases/create-purchase-url",
       {
@@ -1790,7 +1790,7 @@ export class StackClientInterface {
         headers: {
           "content-type": "application/json",
         },
-        body: JSON.stringify({ customer_type, customer_id, ...offerBody }),
+        body: JSON.stringify({ customer_type, customer_id, ...productBody }),
       },
       session
     );
diff --git a/packages/stack-shared/src/interface/crud/transactions.ts b/packages/stack-shared/src/interface/crud/transactions.ts
index ba5bda16a6..6bc84f139f 100644
--- a/packages/stack-shared/src/interface/crud/transactions.ts
+++ b/packages/stack-shared/src/interface/crud/transactions.ts
@@ -1,5 +1,5 @@
 import type { InferType } from "yup";
-import { customerTypeSchema, offerPriceSchema, yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
+import { customerTypeSchema, productPriceSchema, yupBoolean, yupNumber, yupObject, yupString } from "../../schema-fields";
 
 export const adminTransaction = yupObject({
   id: yupString().defined(),
@@ -9,8 +9,8 @@ export const adminTransaction = yupObject({
   customer_id: yupString().defined(),
   quantity: yupNumber().defined(),
   test_mode: yupBoolean().defined(),
-  offer_display_name: yupString().nullable().defined(),
-  price: offerPriceSchema.omit(["serverOnly", "freeTrial"]).nullable().defined(),
+  product_display_name: yupString().nullable().defined(),
+  price: productPriceSchema.omit(["serverOnly", "freeTrial"]).nullable().defined(),
   status: yupString().nullable().defined(),
   item_id: yupString().optional(),
   description: yupString().nullable().optional(),
diff --git a/packages/stack-shared/src/known-errors.tsx b/packages/stack-shared/src/known-errors.tsx
index 89a93bd22f..b303473a85 100644
--- a/packages/stack-shared/src/known-errors.tsx
+++ b/packages/stack-shared/src/known-errors.tsx
@@ -1492,34 +1492,34 @@ const CustomerDoesNotExist = createKnownErrorConstructor(
   (json) => [json.customer_id] as const,
 );
 
-const OfferDoesNotExist = createKnownErrorConstructor(
+const ProductDoesNotExist = createKnownErrorConstructor(
   KnownError,
-  "OFFER_DOES_NOT_EXIST",
-  (offerId: string, accessType: "client" | "server" | "admin") => [
+  "PRODUCT_DOES_NOT_EXIST",
+  (productId: string, accessType: "client" | "server" | "admin") => [
     400,
-    `Offer with ID ${JSON.stringify(offerId)} does not exist${accessType === "client" ? " or you don't have permissions to access it." : "."}`,
+    `Product with ID ${JSON.stringify(productId)} does not exist${accessType === "client" ? " or you don't have permissions to access it." : "."}`,
     {
-      offer_id: offerId,
+      product_id: productId,
       access_type: accessType,
     },
   ] as const,
-  (json) => [json.offer_id, json.access_type] as const,
+  (json) => [json.product_id, json.access_type] as const,
 );
 
-const OfferCustomerTypeDoesNotMatch = createKnownErrorConstructor(
+const ProductCustomerTypeDoesNotMatch = createKnownErrorConstructor(
   KnownError,
-  "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
-  (offerId: string | undefined, customerId: string, offerCustomerType: "user" | "team" | "custom" | undefined, actualCustomerType: "user" | "team" | "custom") => [
+  "PRODUCT_CUSTOMER_TYPE_DOES_NOT_MATCH",
+  (productId: string | undefined, customerId: string, productCustomerType: "user" | "team" | "custom" | undefined, actualCustomerType: "user" | "team" | "custom") => [
     400,
-    `The ${actualCustomerType} with ID ${JSON.stringify(customerId)} is not a valid customer for the inline offer that has been passed in. ${offerCustomerType ? `The offer is configured to only be available for ${offerCustomerType} customers, but the customer is a ${actualCustomerType}.` : `The offer is missing a customer type field. Please make sure it is set up correctly in your project configuration.`}`,
+    `The ${actualCustomerType} with ID ${JSON.stringify(customerId)} is not a valid customer for the inline product that has been passed in. ${productCustomerType ? `The product is configured to only be available for ${productCustomerType} customers, but the customer is a ${actualCustomerType}.` : `The product is missing a customer type field. Please make sure it is set up correctly in your project configuration.`}`,
     {
-      offer_id: offerId ?? null,
+      product_id: productId ?? null,
       customer_id: customerId,
-      offer_customer_type: offerCustomerType ?? null,
+      product_customer_type: productCustomerType ?? null,
       actual_customer_type: actualCustomerType,
     },
   ] as const,
-  (json) => [json.offer_id ?? undefined, json.customer_id, json.offer_customer_type ?? undefined, json.actual_customer_type] as const,
+  (json) => [json.product_id ?? undefined, json.customer_id, json.product_customer_type ?? undefined, json.actual_customer_type] as const,
 );
 
 const ItemQuantityInsufficientAmount = createKnownErrorConstructor(
@@ -1685,8 +1685,8 @@ export const KnownErrors = {
   ItemNotFound,
   ItemCustomerTypeDoesNotMatch,
   CustomerDoesNotExist,
-  OfferDoesNotExist,
-  OfferCustomerTypeDoesNotMatch,
+  ProductDoesNotExist,
+  ProductCustomerTypeDoesNotMatch,
   ItemQuantityInsufficientAmount,
   StripeAccountInfoNotFound,
   DataVaultStoreDoesNotExist,
diff --git a/packages/stack-shared/src/schema-fields.ts b/packages/stack-shared/src/schema-fields.ts
index 0151ce6c52..8e4687e34d 100644
--- a/packages/stack-shared/src/schema-fields.ts
+++ b/packages/stack-shared/src/schema-fields.ts
@@ -553,7 +553,7 @@ const validateHasAtLeastOneSupportedCurrency = (value: Record<string, unknown> |
   }
   return true;
 };
-export const offerPriceSchema = yupObject({
+export const productPriceSchema = yupObject({
   ...typedFromEntries(SUPPORTED_CURRENCIES.map(currency => [currency.code, moneyAmountSchema(currency).optional()])),
   interval: dayIntervalSchema.optional(),
   serverOnly: yupBoolean(),
@@ -563,19 +563,19 @@ export const priceOrIncludeByDefaultSchema = yupUnion(
   yupString().oneOf(['include-by-default']).meta({ openapiField: { description: 'Makes this item free and includes it by default for all customers.', exampleValue: 'include-by-default' } }),
   yupRecord(
     userSpecifiedIdSchema("priceId"),
-    offerPriceSchema,
+    productPriceSchema,
   ),
 );
-export const offerSchema = yupObject({
+export const productSchema = yupObject({
   displayName: yupString(),
-  groupId: userSpecifiedIdSchema("groupId").optional().meta({ openapiField: { description: 'The ID of the group this offer belongs to. Within a group, all offers are mutually exclusive unless they are an add-on to another offer in the group.', exampleValue: 'group-id' } }),
+  groupId: userSpecifiedIdSchema("groupId").optional().meta({ openapiField: { description: 'The ID of the group this product belongs to. Within a group, all products are mutually exclusive unless they are an add-on to another product in the group.', exampleValue: 'group-id' } }),
   isAddOnTo: yupUnion(
     yupBoolean().isFalse(),
     yupRecord(
-      userSpecifiedIdSchema("offerId"),
+      userSpecifiedIdSchema("productId"),
       yupBoolean().isTrue().defined(),
     ),
-  ).optional().meta({ openapiField: { description: 'The offers that this offer is an add-on to. If this is set, the customer must already have one of the offers in the record to be able to purchase this offer.', exampleValue: { "offer-id": true } } }),
+  ).optional().meta({ openapiField: { description: 'The products that this product is an add-on to. If this is set, the customer must already have one of the products in the record to be able to purchase this product.', exampleValue: { "product-id": true } } }),
   customerType: customerTypeSchema.defined(),
   freeTrial: dayIntervalSchema.optional(),
   serverOnly: yupBoolean(),
@@ -590,7 +590,7 @@ export const offerSchema = yupObject({
     }),
   ),
 });
-export const inlineOfferSchema = yupObject({
+export const inlineProductSchema = yupObject({
   display_name: yupString().defined(),
   customer_type: customerTypeSchema.defined(),
   free_trial: dayIntervalSchema.optional(),
diff --git a/packages/template/src/lib/stack-app/apps/implementations/client-app-impl.ts b/packages/template/src/lib/stack-app/apps/implementations/client-app-impl.ts
index d5432dcb1b..9e29e82405 100644
--- a/packages/template/src/lib/stack-app/apps/implementations/client-app-impl.ts
+++ b/packages/template/src/lib/stack-app/apps/implementations/client-app-impl.ts
@@ -1267,8 +1267,8 @@ export class _StackClientAppImplIncomplete<HasTokenStore extends boolean, Projec
         return app._clientItemFromCrud(result);
       },
       // END_PLATFORM
-      async createCheckoutUrl(options: { offerId: string }) {
-        return await app._interface.createCheckoutUrl(type, userIdOrTeamId, options.offerId, session);
+      async createCheckoutUrl(options: { productId: string }) {
+        return await app._interface.createCheckoutUrl(type, userIdOrTeamId, options.productId, session);
       },
     };
   }
diff --git a/packages/template/src/lib/stack-app/apps/implementations/server-app-impl.ts b/packages/template/src/lib/stack-app/apps/implementations/server-app-impl.ts
index d22319ad02..b43ceb9b81 100644
--- a/packages/template/src/lib/stack-app/apps/implementations/server-app-impl.ts
+++ b/packages/template/src/lib/stack-app/apps/implementations/server-app-impl.ts
@@ -24,7 +24,7 @@ import { ApiKey, ApiKeyCreationOptions, ApiKeyUpdateOptions, apiKeyCreationOptio
 import { GetUserOptions, HandlerUrls, OAuthScopesOnSignIn, TokenStoreInit } from "../../common";
 import { OAuthConnection } from "../../connected-accounts";
 import { ServerContactChannel, ServerContactChannelCreateOptions, ServerContactChannelUpdateOptions, serverContactChannelCreateOptionsToCrud, serverContactChannelUpdateOptionsToCrud } from "../../contact-channels";
-import { InlineOffer, ServerItem } from "../../customers";
+import { InlineProduct, ServerItem } from "../../customers";
 import { DataVaultStore } from "../../data-vault";
 import { SendEmailOptions } from "../../email";
 import { NotificationCategory } from "../../notification-categories";
@@ -646,9 +646,9 @@ export class _StackServerAppImplIncomplete<HasTokenStore extends boolean, Projec
         const providers = await this.listOAuthProviders();
         return providers.find((p) => p.id === id) ?? null;
       },
-      async createCheckoutUrl(options: { offerId: string } | { offer: InlineOffer }) {
-        const offerIdOrInline = "offerId" in options ? options.offerId : options.offer;
-        return await app._interface.createCheckoutUrl("user", crud.id, offerIdOrInline, null);
+      async createCheckoutUrl(options: { productId: string } | { product: InlineProduct }) {
+        const productIdOrInline = "productId" in options ? options.productId : options.product;
+        return await app._interface.createCheckoutUrl("user", crud.id, productIdOrInline, null);
       },
       async getItem(itemId: string) {
         const result = Result.orThrow(await app._serverUserItemsCache.getOrWait([crud.id, itemId], "write-only"));
@@ -785,9 +785,9 @@ export class _StackServerAppImplIncomplete<HasTokenStore extends boolean, Projec
         return useMemo(() => app._serverItemFromCrud({ type: "team", id: crud.id }, result), [result]);
       },
       // END_PLATFORM
-      async createCheckoutUrl(options: { offerId: string } | { offer: InlineOffer }) {
-        const offerIdOrInline = "offerId" in options ? options.offerId : options.offer;
-        return await app._interface.createCheckoutUrl("team", crud.id, offerIdOrInline, null);
+      async createCheckoutUrl(options: { productId: string } | { product: InlineProduct }) {
+        const productIdOrInline = "productId" in options ? options.productId : options.product;
+        return await app._interface.createCheckoutUrl("team", crud.id, productIdOrInline, null);
       },
     };
   }
diff --git a/packages/template/src/lib/stack-app/customers/index.ts b/packages/template/src/lib/stack-app/customers/index.ts
index 7dd05e54c7..9decc0a6b6 100644
--- a/packages/template/src/lib/stack-app/customers/index.ts
+++ b/packages/template/src/lib/stack-app/customers/index.ts
@@ -1,8 +1,8 @@
-import { inlineOfferSchema } from "@stackframe/stack-shared/dist/schema-fields";
+import { inlineProductSchema } from "@stackframe/stack-shared/dist/schema-fields";
 import * as yup from "yup";
 import { AsyncStoreProperty } from "../common";
 
-export type InlineOffer = yup.InferType<typeof inlineOfferSchema>;
+export type InlineProduct = yup.InferType<typeof inlineProductSchema>;
 
 export type Item = {
   displayName: string,
@@ -37,8 +37,8 @@ export type Customer<IsServer extends boolean = false> =
     readonly id: string,
 
     createCheckoutUrl(options: (
-      | { offerId: string }
-      | (IsServer extends true ? { offer: InlineOffer } : never)
+      | { productId: string }
+      | (IsServer extends true ? { product: InlineProduct } : never)
     )): Promise<string>,
   }
   & AsyncStoreProperty<

From 8d167d8c3506ef17770c45f87ee661f753a9ca59 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 12:16:02 -0700
Subject: [PATCH 03/23] Schema migration

---
 packages/stack-shared/src/config/schema.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 16288a875d..be66afec5d 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -296,6 +296,12 @@ export function migrateConfigOverride(type: "project" | "branch" | "environment"
   }
   // END
 
+  // BEGIN 2025-09-23: payments.offers is now payments.products
+  if (isBranchOrHigher) {
+    res = renameProperty(res, "payments.offers", "payments.products");
+  }
+  // END
+
   // return the result
   return res;
 };

From 5fe50f91f294b0653822404be3bded8f3c94bec8 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 12:21:07 -0700
Subject: [PATCH 04/23] Migration

---
 .../migration.sql                                 | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 apps/backend/prisma/migrations/20250923191615_rename_offers_to_products/migration.sql

diff --git a/apps/backend/prisma/migrations/20250923191615_rename_offers_to_products/migration.sql b/apps/backend/prisma/migrations/20250923191615_rename_offers_to_products/migration.sql
new file mode 100644
index 0000000000..27295b9c63
--- /dev/null
+++ b/apps/backend/prisma/migrations/20250923191615_rename_offers_to_products/migration.sql
@@ -0,0 +1,15 @@
+-- AlterTable
+ALTER TABLE "OneTimePurchase" 
+RENAME COLUMN "offer" TO "product";
+
+-- AlterTable
+ALTER TABLE "OneTimePurchase" 
+RENAME COLUMN "offerId" TO "productId";
+
+-- AlterTable
+ALTER TABLE "Subscription" 
+RENAME COLUMN "offer" TO "product";
+
+-- AlterTable
+ALTER TABLE "Subscription" 
+RENAME COLUMN "offerId" TO "productId";

From ccc90eae5f8f65c3c98e161f003bb7d0a115d54d Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 13:35:49 -0700
Subject: [PATCH 05/23] Endpoint compat

---
 .claude/CLAUDE-KNOWLEDGE.md                   |  3 +
 apps/backend/src/app/api/migrations/README.md |  2 +-
 .../purchases/create-purchase-url/route.ts    | 28 +++++++++
 .../payments/purchases/offers-compat.ts       | 61 +++++++++++++++++++
 .../payments/purchases/validate-code/route.ts | 34 +++++++++++
 5 files changed, 127 insertions(+), 1 deletion(-)
 create mode 100644 apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts
 create mode 100644 apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
 create mode 100644 apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts

diff --git a/.claude/CLAUDE-KNOWLEDGE.md b/.claude/CLAUDE-KNOWLEDGE.md
index 6b07510097..cedbec1773 100644
--- a/.claude/CLAUDE-KNOWLEDGE.md
+++ b/.claude/CLAUDE-KNOWLEDGE.md
@@ -366,3 +366,6 @@ A: This happens when packages haven't been built yet. Run these commands in orde
 pnpm clean && pnpm i && pnpm codegen && pnpm build:packages
 ```
 Then restart the dev server. This rebuilds all packages and generates the necessary TypeScript declarations.
+
+## Q: How is backwards compatibility for the offer→product rename handled in the payments purchase APIs?
+A: API v1 requests are routed through the `v2beta1` migration. The migration wraps the latest handlers, accepts legacy `offer_id`/`offer_inline` request fields, translates product-related errors back to the old offer error codes/messages, and augments responses (like `validate-code`) with `offer`/`conflicting_group_offers` aliases alongside the new `product` fields. Newer API versions keep the product-only contract.
diff --git a/apps/backend/src/app/api/migrations/README.md b/apps/backend/src/app/api/migrations/README.md
index ce2772d7d3..7f0314eda8 100644
--- a/apps/backend/src/app/api/migrations/README.md
+++ b/apps/backend/src/app/api/migrations/README.md
@@ -13,7 +13,7 @@ Examples of changes that are breaking and hence require an API migration:
 
 Release versions (eg. v1, v2) are documented thoroughly, while beta versions (eg. v2beta1, v3beta2) are mostly used by our own packages/SDKs and some external beta testers. **We still need to maintain backwards compatibility for beta versions**, so the only purpose of differentiating is to prevent "migration fatigue" if we were to announce a new API version every week. Beta versions come before release versions: `v1 < v2beta1 < v2beta2 < v2`, etc.
 
-Each folder in `src/app/api/migrations` is a migration. The name of the folder is the name of the version you're migrating **to** — so, if you're migrating from `v2beta3` to `v2beta4`, the folder is called `v2beta4`. (Make sure you don't get confused because it means the file `migrations/v2beta4/route.tsx` is the migration file TO `v2beta4`, hence never served to clients in `v2beta4`.)
+Each folder in `src/app/api/migrations` is a migration. The name of the folder is the name of the version you're migrating **to** — so, if you're migrating from `v2beta3` to `v2beta4`, the folder is called `v2beta4`. In other words, the files in `v2beta4` will process all requests for versions LESS than `v2beta4` (but not `v2beta4` itself).
 
 To create a new migration, simply add a new folder in `src/app/api/migrations`. This folder has the same structure as `src/app/api/latest`, although it will fall back to that folder for routes that are not found. Additionally, this new folder should contain extra files: `beta-changes.txt` (the list of changes since the last beta version), and `release-changes.txt` (the list of changes since the last release version — only required for release versions). For every endpoint you migrate, you will likely also have to modify the most recent migration of that endpoint in previous versions (if any) to call your newly created endpoint, instead of the one that can be found in `latest`.
 
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts
new file mode 100644
index 0000000000..686e21d854
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts
@@ -0,0 +1,28 @@
+import { POST as latestHandler } from "@/app/api/latest/payments/purchases/create-purchase-url/route";
+import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
+import { ensureObjectSchema, inlineProductSchema, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
+import { normalizePurchaseBody } from "../offers-compat";
+
+const latestInit = latestHandler.initArgs[0];
+
+const requestSchema = ensureObjectSchema(latestInit.request);
+const requestBodySchema = ensureObjectSchema(requestSchema.getNested("body"));
+
+export const POST = createSmartRouteHandler({
+  ...latestInit,
+  request: requestSchema.concat(yupObject({
+    body: requestBodySchema.concat(yupObject({
+      offer_id: yupString().optional(),
+      offer_inline: inlineProductSchema.optional(),
+    })),
+  })),
+  handler: async (_req, fullReq) => {
+    const body = normalizePurchaseBody(fullReq.body as Record<string, any>);
+    const translatedRequest = {
+      ...fullReq,
+      body,
+    };
+
+    return await latestHandler.invoke(translatedRequest);
+  },
+});
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
new file mode 100644
index 0000000000..79662a82ad
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
@@ -0,0 +1,61 @@
+
+
+export function normalizePurchaseBody(body: Record<string, any>): Record<string, any> {
+  const productId = body.product_id ?? body.offer_id;
+  const productInline = body.product_inline ?? body.offer_inline;
+  const result: Record<string, any> = { ...body, product_id: productId, product_inline: productInline };
+  delete result.offer_id;
+  delete result.offer_inline;
+  return result;
+}
+
+type ValidateCodeBody = {
+  product: any,
+  conflicting_group_products: Array<{ product_id: string, display_name: string }>,
+};
+
+export function addOfferAliasesToValidateCodeBody<T extends ValidateCodeBody & Record<string, any>>(body: T): T & {
+  offer: T["product"],
+  conflicting_group_offers: Array<{ offer_id: string, display_name: string }>,
+} {
+  return {
+    ...body,
+    offer: body.product,
+    conflicting_group_offers: body.conflicting_group_products.map(({ product_id, display_name }) => ({
+      offer_id: product_id,
+      display_name,
+    })),
+  };
+}
+
+
+import.meta.vitest?.test("normalizePurchaseBody maps offer fields to product equivalents", ({ expect }) => {
+  const legacyBody = { offer_id: "legacy_offer", offer_inline: { foo: "bar" } } as Record<string, any>;
+
+  const normalized = normalizePurchaseBody(legacyBody);
+
+  expect(normalized.product_id).toBe("legacy_offer");
+  expect(normalized.product_inline).toBe(legacyBody.offer_inline);
+  expect(normalized).not.toHaveProperty("offer_id");
+  expect(normalized).not.toHaveProperty("offer_inline");
+  expect(legacyBody).toEqual({ offer_id: "legacy_offer", offer_inline: { foo: "bar" } });
+});
+
+import.meta.vitest?.test("addOfferAliasesToValidateCodeBody adds offer aliases", ({ expect }) => {
+  const body = {
+    product: { id: "prod" },
+    conflicting_group_products: [
+      { product_id: "prodA", display_name: "Product A" },
+      { product_id: "prodB", display_name: "Product B" },
+    ],
+  };
+
+  const result = addOfferAliasesToValidateCodeBody({ ...body });
+
+  expect(result.offer).toBe(body.product);
+  expect(result.conflicting_group_offers).toEqual([
+    { offer_id: "prodA", display_name: "Product A" },
+    { offer_id: "prodB", display_name: "Product B" },
+  ]);
+  expect((result as any).conflicting_group_products).toEqual(body.conflicting_group_products);
+});
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts
new file mode 100644
index 0000000000..5341818b39
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts
@@ -0,0 +1,34 @@
+import { POST as latestHandler } from "@/app/api/latest/payments/purchases/validate-code/route";
+import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
+import { ensureObjectSchema, yupObject } from "@stackframe/stack-shared/dist/schema-fields";
+import { addOfferAliasesToValidateCodeBody } from "../offers-compat";
+
+const latestInit = latestHandler.initArgs[0];
+const responseSchema = ensureObjectSchema(latestInit.response);
+const responseBodySchema = ensureObjectSchema(responseSchema.getNested("body"));
+const productSchema = responseBodySchema.getNested("product");
+const conflictingGroupProductsSchema = responseBodySchema.getNested("conflicting_group_products") as any;
+const conflictingGroupProductItemSchema = ensureObjectSchema(conflictingGroupProductsSchema.innerType as any);
+
+const conflictingGroupOffersSchema = conflictingGroupProductsSchema.clone().of(
+  conflictingGroupProductItemSchema.clone().concat(yupObject({
+    offer_id: conflictingGroupProductItemSchema.getNested("product_id"),
+  })),
+);
+
+export const POST = createSmartRouteHandler({
+  ...latestInit,
+  response: responseSchema.concat(yupObject({
+    body: responseBodySchema.concat(yupObject({
+      offer: productSchema,
+      conflicting_group_offers: conflictingGroupOffersSchema,
+    })),
+  })),
+  handler: async (_req, fullReq) => {
+    const response = await latestHandler.invoke(fullReq);
+    return {
+      ...response,
+      body: addOfferAliasesToValidateCodeBody(response.body as any),
+    };
+  },
+});

From c4b860a30b2e95e2ffebaf447d0c9ba092b9f074 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 15:24:34 -0700
Subject: [PATCH 06/23] Fix tests

---
 .../payments/purchases/validate-code/route.ts |   4 +-
 .../payments/purchases/offers-compat.ts       |  61 ---
 .../payments/purchases/validate-code/route.ts |  34 --
 .../api/migrations/v2beta5/beta-changes.txt   |   1 +
 .../purchases/create-purchase-url/route.ts    |   0
 .../payments/purchases/offers-compat.ts       |  23 +
 .../payments/purchases/validate-code/route.ts |  35 ++
 .../{offer-dialog.tsx => product-dialog.tsx}  |   0
 .../(main)/purchase/[code]/page-client.tsx    |   8 +-
 ...er-table.tsx => payment-product-table.tsx} |   0
 .../{offer-dialog.tsx => product-dialog.tsx}  |   0
 .../endpoints/api/v1/old-name/items.test.ts   | 472 ------------------
 .../outdated--create-purchase-url.test.ts}    |  62 +--
 .../outdated--purchase-session.test.ts}       | 141 +++---
 .../outdated--validate-code.test.ts}          |  80 ++-
 .../api/v1/payments/validate-code.test.ts     |   8 +-
 16 files changed, 230 insertions(+), 699 deletions(-)
 delete mode 100644 apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
 delete mode 100644 apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts
 create mode 100644 apps/backend/src/app/api/migrations/v2beta5/beta-changes.txt
 rename apps/backend/src/app/api/migrations/{v2beta1 => v2beta5}/payments/purchases/create-purchase-url/route.ts (100%)
 create mode 100644 apps/backend/src/app/api/migrations/v2beta5/payments/purchases/offers-compat.ts
 create mode 100644 apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/{offer-dialog.tsx => product-dialog.tsx} (100%)
 rename apps/dashboard/src/components/data-table/{payment-offer-table.tsx => payment-product-table.tsx} (100%)
 rename apps/dashboard/src/components/payments/{offer-dialog.tsx => product-dialog.tsx} (100%)
 delete mode 100644 apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
 rename apps/e2e/tests/backend/endpoints/api/v1/{old-name/create-purchase-url.test.ts => payments/before-offer-to-product-rename/outdated--create-purchase-url.test.ts} (76%)
 rename apps/e2e/tests/backend/endpoints/api/v1/{old-name/purchase-session.test.ts => payments/before-offer-to-product-rename/outdated--purchase-session.test.ts} (81%)
 rename apps/e2e/tests/backend/endpoints/api/v1/{old-name/validate-code.test.ts => payments/before-offer-to-product-rename/outdated--validate-code.test.ts} (74%)

diff --git a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
index d8615e5265..2e36953de1 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
+++ b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
@@ -32,7 +32,7 @@ export const POST = createSmartRouteHandler({
       stripe_account_id: yupString().defined(),
       project_id: yupString().defined(),
       already_bought_non_stackable: yupBoolean().defined(),
-      conflicting_group_products: yupArray(yupObject({
+      conflicting_products: yupArray(yupObject({
         product_id: yupString().defined(),
         display_name: yupString().defined(),
       }).defined()).defined(),
@@ -95,7 +95,7 @@ export const POST = createSmartRouteHandler({
         stripe_account_id: verificationCode.data.stripeAccountId,
         project_id: tenancy.project.id,
         already_bought_non_stackable: alreadyBoughtNonStackable,
-        conflicting_group_products: conflictingGroupProducts,
+        conflicting_products: conflictingGroupProducts,
       },
     };
   },
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
deleted file mode 100644
index 79662a82ad..0000000000
--- a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/offers-compat.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-export function normalizePurchaseBody(body: Record<string, any>): Record<string, any> {
-  const productId = body.product_id ?? body.offer_id;
-  const productInline = body.product_inline ?? body.offer_inline;
-  const result: Record<string, any> = { ...body, product_id: productId, product_inline: productInline };
-  delete result.offer_id;
-  delete result.offer_inline;
-  return result;
-}
-
-type ValidateCodeBody = {
-  product: any,
-  conflicting_group_products: Array<{ product_id: string, display_name: string }>,
-};
-
-export function addOfferAliasesToValidateCodeBody<T extends ValidateCodeBody & Record<string, any>>(body: T): T & {
-  offer: T["product"],
-  conflicting_group_offers: Array<{ offer_id: string, display_name: string }>,
-} {
-  return {
-    ...body,
-    offer: body.product,
-    conflicting_group_offers: body.conflicting_group_products.map(({ product_id, display_name }) => ({
-      offer_id: product_id,
-      display_name,
-    })),
-  };
-}
-
-
-import.meta.vitest?.test("normalizePurchaseBody maps offer fields to product equivalents", ({ expect }) => {
-  const legacyBody = { offer_id: "legacy_offer", offer_inline: { foo: "bar" } } as Record<string, any>;
-
-  const normalized = normalizePurchaseBody(legacyBody);
-
-  expect(normalized.product_id).toBe("legacy_offer");
-  expect(normalized.product_inline).toBe(legacyBody.offer_inline);
-  expect(normalized).not.toHaveProperty("offer_id");
-  expect(normalized).not.toHaveProperty("offer_inline");
-  expect(legacyBody).toEqual({ offer_id: "legacy_offer", offer_inline: { foo: "bar" } });
-});
-
-import.meta.vitest?.test("addOfferAliasesToValidateCodeBody adds offer aliases", ({ expect }) => {
-  const body = {
-    product: { id: "prod" },
-    conflicting_group_products: [
-      { product_id: "prodA", display_name: "Product A" },
-      { product_id: "prodB", display_name: "Product B" },
-    ],
-  };
-
-  const result = addOfferAliasesToValidateCodeBody({ ...body });
-
-  expect(result.offer).toBe(body.product);
-  expect(result.conflicting_group_offers).toEqual([
-    { offer_id: "prodA", display_name: "Product A" },
-    { offer_id: "prodB", display_name: "Product B" },
-  ]);
-  expect((result as any).conflicting_group_products).toEqual(body.conflicting_group_products);
-});
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts
deleted file mode 100644
index 5341818b39..0000000000
--- a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/validate-code/route.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { POST as latestHandler } from "@/app/api/latest/payments/purchases/validate-code/route";
-import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
-import { ensureObjectSchema, yupObject } from "@stackframe/stack-shared/dist/schema-fields";
-import { addOfferAliasesToValidateCodeBody } from "../offers-compat";
-
-const latestInit = latestHandler.initArgs[0];
-const responseSchema = ensureObjectSchema(latestInit.response);
-const responseBodySchema = ensureObjectSchema(responseSchema.getNested("body"));
-const productSchema = responseBodySchema.getNested("product");
-const conflictingGroupProductsSchema = responseBodySchema.getNested("conflicting_group_products") as any;
-const conflictingGroupProductItemSchema = ensureObjectSchema(conflictingGroupProductsSchema.innerType as any);
-
-const conflictingGroupOffersSchema = conflictingGroupProductsSchema.clone().of(
-  conflictingGroupProductItemSchema.clone().concat(yupObject({
-    offer_id: conflictingGroupProductItemSchema.getNested("product_id"),
-  })),
-);
-
-export const POST = createSmartRouteHandler({
-  ...latestInit,
-  response: responseSchema.concat(yupObject({
-    body: responseBodySchema.concat(yupObject({
-      offer: productSchema,
-      conflicting_group_offers: conflictingGroupOffersSchema,
-    })),
-  })),
-  handler: async (_req, fullReq) => {
-    const response = await latestHandler.invoke(fullReq);
-    return {
-      ...response,
-      body: addOfferAliasesToValidateCodeBody(response.body as any),
-    };
-  },
-});
diff --git a/apps/backend/src/app/api/migrations/v2beta5/beta-changes.txt b/apps/backend/src/app/api/migrations/v2beta5/beta-changes.txt
new file mode 100644
index 0000000000..d941bdb148
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta5/beta-changes.txt
@@ -0,0 +1 @@
+Removes the offer_id and offer_inline parameters that previously acted as aliases for product_id and product_inline on some endpoints.
diff --git a/apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/create-purchase-url/route.ts
similarity index 100%
rename from apps/backend/src/app/api/migrations/v2beta1/payments/purchases/create-purchase-url/route.ts
rename to apps/backend/src/app/api/migrations/v2beta5/payments/purchases/create-purchase-url/route.ts
diff --git a/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/offers-compat.ts b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/offers-compat.ts
new file mode 100644
index 0000000000..ba54fd3fe8
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/offers-compat.ts
@@ -0,0 +1,23 @@
+
+
+export function normalizePurchaseBody(body: Record<string, any>): Record<string, any> {
+  const productId = body.product_id ?? body.offer_id;
+  const productInline = body.product_inline ?? body.offer_inline;
+  const result: Record<string, any> = { ...body, product_id: productId, product_inline: productInline };
+  delete result.offer_id;
+  delete result.offer_inline;
+  return result;
+}
+
+
+import.meta.vitest?.test("normalizePurchaseBody maps offer fields to product equivalents", ({ expect }) => {
+  const legacyBody = { offer_id: "legacy_offer", offer_inline: { foo: "bar" } } as Record<string, any>;
+
+  const normalized = normalizePurchaseBody(legacyBody);
+
+  expect(normalized.product_id).toBe("legacy_offer");
+  expect(normalized.product_inline).toBe(legacyBody.offer_inline);
+  expect(normalized).not.toHaveProperty("offer_id");
+  expect(normalized).not.toHaveProperty("offer_inline");
+  expect(legacyBody).toEqual({ offer_id: "legacy_offer", offer_inline: { foo: "bar" } });
+});
diff --git a/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts
new file mode 100644
index 0000000000..32fb25a849
--- /dev/null
+++ b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts
@@ -0,0 +1,35 @@
+import { POST as latestHandler } from "@/app/api/latest/payments/purchases/validate-code/route";
+import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
+import { ensureObjectSchema, yupArray, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
+
+const latestInit = latestHandler.initArgs[0];
+const responseSchema = ensureObjectSchema(latestInit.response);
+const responseBodySchema = ensureObjectSchema(responseSchema.getNested("body"));
+
+
+export const POST = createSmartRouteHandler({
+  ...latestInit,
+  response: responseSchema.concat(yupObject({
+    body: responseBodySchema.concat(yupObject({
+      offer: responseBodySchema.getNested("product").meta({ openapiField: { hidden: true } }),
+      conflicting_group_offers: yupArray(yupObject({
+        offer_id: yupString().defined(),
+        display_name: yupString().defined(),
+      }).defined()).defined().meta({ openapiField: { hidden: true } }),
+    })),
+  })),
+  handler: async (_req, fullReq) => {
+    const response = await latestHandler.invoke(fullReq);
+    return {
+      ...response,
+      body: {
+        ...response.body,
+        offer: response.body.product,
+        conflicting_group_offers: response.body.conflicting_products.map(({ product_id, display_name }) => ({
+          offer_id: product_id,
+          display_name,
+        })),
+      }
+    };
+  },
+});
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/offer-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
diff --git a/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx b/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
index ac47a5ef0f..4dbc6bc970 100644
--- a/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
+++ b/apps/dashboard/src/app/(main)/purchase/[code]/page-client.tsx
@@ -18,7 +18,7 @@ type ProductData = {
   stripe_account_id: string,
   project_id: string,
   already_bought_non_stackable?: boolean,
-  conflicting_group_products?: { product_id: string, display_name: string }[],
+  conflicting_products?: { product_id: string, display_name: string }[],
 };
 
 const apiUrl = getPublicEnvVar("NEXT_PUBLIC_STACK_API_URL") ?? throwErr("NEXT_PUBLIC_STACK_API_URL is not set");
@@ -166,12 +166,12 @@ export default function PageClient({ code }: { code: string }) {
                     You already have this product.
                   </AlertDescription>
                 </Alert>
-              ) : data?.conflicting_group_products && data.conflicting_group_products.length > 0 ? (
+              ) : data?.conflicting_products && data.conflicting_products.length > 0 ? (
                 <Alert>
                   <AlertTitle>Plan change</AlertTitle>
                   <AlertDescription>
-                    {data.conflicting_group_products.length === 1 ? (
-                      <>This purchase will change your plan from {data.conflicting_group_products[0].display_name}.</>
+                    {data.conflicting_products.length === 1 ? (
+                      <>This purchase will change your plan from {data.conflicting_products[0].display_name}.</>
                     ) : (
                       <>This purchase will change your plan from one of your existing plans.</>
                     )}
diff --git a/apps/dashboard/src/components/data-table/payment-offer-table.tsx b/apps/dashboard/src/components/data-table/payment-product-table.tsx
similarity index 100%
rename from apps/dashboard/src/components/data-table/payment-offer-table.tsx
rename to apps/dashboard/src/components/data-table/payment-product-table.tsx
diff --git a/apps/dashboard/src/components/payments/offer-dialog.tsx b/apps/dashboard/src/components/payments/product-dialog.tsx
similarity index 100%
rename from apps/dashboard/src/components/payments/offer-dialog.tsx
rename to apps/dashboard/src/components/payments/product-dialog.tsx
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
deleted file mode 100644
index 793b462a65..0000000000
--- a/apps/e2e/tests/backend/endpoints/api/v1/old-name/items.test.ts
+++ /dev/null
@@ -1,472 +0,0 @@
-import { describe, expect } from "vitest";
-import { it } from "../../../../../helpers";
-import { Auth, InternalProjectKeys, Project, User, backendContext, createMailbox, niceBackendFetch } from "../../../../backend-helpers";
-
-async function updateConfig(config: any) {
-  const response = await niceBackendFetch(`/api/latest/internal/config/override`, {
-    accessType: "admin",
-    method: "PATCH",
-    body: { config_override_string: JSON.stringify(config) },
-  });
-  expect(response.status).toBe(200);
-}
-
-describe("without authentication", () => {
-  it("should not be able to get item without access type", async ({ expect }) => {
-    await Project.createAndSwitch();
-
-    const response = await niceBackendFetch("/api/latest/payments/items/user/user-123/test-item");
-    expect(response).toMatchInlineSnapshot(`
-        NiceResponse {
-          "status": 400,
-          "body": {
-            "code": "ACCESS_TYPE_REQUIRED",
-            "error": deindent\`
-              You must specify an access level for this Stack project. Make sure project API keys are provided (eg. x-stack-publishable-client-key) and you set the x-stack-access-type header to 'client', 'server', or 'admin'.
-              
-              For more information, see the docs on REST API authentication: https://docs.stack-auth.com/rest-api/overview#authentication
-            \`,
-          },
-          "headers": Headers {
-            "x-stack-known-error": "ACCESS_TYPE_REQUIRED",
-            <some fields may have been hidden>,
-          },
-        }
-      `);
-  });
-});
-
-it("should be able to get item information with valid customer and item IDs", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(response).toMatchInlineSnapshot(`
-        NiceResponse {
-          "status": 200,
-          "body": {
-            "display_name": "Test Item",
-            "id": "test-item",
-            "quantity": 0,
-          },
-          "headers": Headers { <some fields may have been hidden> },
-        }
-      `);
-});
-
-it("should return ItemNotFound error for non-existent item", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/non-existent-item`, {
-    accessType: "client",
-  });
-  expect(response).toMatchInlineSnapshot(`
-        NiceResponse {
-          "status": 404,
-          "body": {
-            "code": "ITEM_NOT_FOUND",
-            "details": { "item_id": "non-existent-item" },
-            "error": "Item with ID \\\"non-existent-item\\\" not found.",
-          },
-          "headers": Headers {
-            "x-stack-known-error": "ITEM_NOT_FOUND",
-            <some fields may have been hidden>,
-          },
-        }
-      `);
-});
-
-it("should return ItemCustomerTypeDoesNotMatch error for user accessing team item", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "team",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(response).toMatchInlineSnapshot(`
-      NiceResponse {
-        "status": 400,
-        "body": {
-          "code": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
-          "details": {
-            "actual_customer_type": "user",
-            "customer_id": "<stripped UUID>",
-            "item_customer_type": "team",
-            "item_id": "test-item",
-          },
-          "error": "The user with ID \\"<stripped UUID>\\" is not a valid customer for the item with ID \\"test-item\\". The item is configured to only be available for team customers, but the customer is a user.",
-        },
-        "headers": Headers {
-          "x-stack-known-error": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
-          <some fields may have been hidden>,
-        },
-      }
-    `);
-});
-
-it("creates an item quantity change and returns id", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
-    method: "POST",
-    accessType: "admin",
-    body: {
-      delta: 3,
-      description: "manual grant",
-    },
-  });
-
-  expect(response.status).toBe(200);
-  expect(response.body).toMatchObject({ id: expect.any(String) });
-});
-
-it("aggregates item quantity changes in item quantity", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  const post1 = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: 2 },
-  });
-  expect(post1.status).toBe(200);
-
-  const get1 = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(get1.status).toBe(200);
-  expect(get1.body.quantity).toBe(2);
-});
-
-it("ignores expired changes", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  const post = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: 4, expires_at: new Date(Date.now() - 1000).toISOString() },
-  });
-  expect(post.status).toBe(200);
-
-  const get = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(get.status).toBe(200);
-  expect(get.body.quantity).toBe(0);
-});
-
-it("sums multiple non-expired changes", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  for (const q of [2, -1, 5]) {
-    const r = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
-      method: "POST",
-      accessType: "admin",
-      body: { delta: q },
-    });
-    expect(r.status).toBe(200);
-  }
-
-  const get = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(get.status).toBe(200);
-  expect(get.body.quantity).toBe(6);
-});
-
-it("validates item and customer type", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "team-item": {
-          displayName: "Team Item",
-          customerType: "team",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/team-item/update-quantity?allow_negative=true`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: 1 },
-  });
-  expect(response).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 400,
-      "body": {
-        "code": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
-        "details": {
-          "actual_customer_type": "user",
-          "customer_id": "<stripped UUID>",
-          "item_customer_type": "team",
-          "item_id": "team-item",
-        },
-        "error": "The user with ID \\"<stripped UUID>\\" is not a valid customer for the item with ID \\"team-item\\". The item is configured to only be available for team customers, but the customer is a user.",
-      },
-      "headers": Headers {
-        "x-stack-known-error": "ITEM_CUSTOMER_TYPE_DOES_NOT_MATCH",
-        <some fields may have been hidden>,
-      },
-    }
-  `);
-});
-
-it("should error when deducting more quantity than available", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=false`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: -1 },
-  });
-
-  expect(response).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 400,
-      "body": {
-        "code": "ITEM_QUANTITY_INSUFFICIENT_AMOUNT",
-        "details": {
-          "customer_id": "<stripped UUID>",
-          "item_id": "test-item",
-          "quantity": -1,
-        },
-        "error": "The item with ID \\"test-item\\" has an insufficient quantity for the customer with ID \\"<stripped UUID>\\". An attempt was made to charge -1 credits.",
-      },
-      "headers": Headers {
-        "x-stack-known-error": "ITEM_QUANTITY_INSUFFICIENT_AMOUNT",
-        <some fields may have been hidden>,
-      },
-    }
-  `);
-});
-
-it("allows team admins to be added when item quantity is increased", async ({ expect }) => {
-  backendContext.set({ projectKeys: InternalProjectKeys });
-  await Auth.Otp.signIn();
-  const { createProjectResponse } = await Project.create();
-  const ownerTeamId: string = createProjectResponse.body.owner_team_id;
-
-  await niceBackendFetch(`/api/v1/payments/items/team/${ownerTeamId}/dashboard_admins/update-quantity?allow_negative=true`, {
-    method: "POST",
-    accessType: "admin",
-    body: {
-      delta: 1,
-    },
-  });
-
-  const mailboxB = createMailbox();
-  const sendInvitationResponse = await niceBackendFetch("/api/v1/team-invitations/send-code", {
-    method: "POST",
-    accessType: "server",
-    body: {
-      email: mailboxB.emailAddress,
-      team_id: ownerTeamId,
-      callback_url: "http://localhost:12345/some-callback-url",
-    },
-  });
-  expect(sendInvitationResponse).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": {
-        "id": "<stripped UUID>",
-        "success": true,
-      },
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
-
-  backendContext.set({ mailbox: mailboxB });
-  await Auth.Otp.signIn();
-
-  const acceptResponse = await niceBackendFetch("/api/v1/team-invitations/accept", {
-    method: "POST",
-    accessType: "client",
-    body: {
-      code: (await mailboxB.fetchMessages()).findLast((m) => m.subject.includes("join"))?.body?.text.match(/http:\/\/localhost:12345\/some-callback-url\?code=([a-zA-Z0-9]+)/)?.[1],
-    },
-  });
-
-  expect(acceptResponse).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": {},
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
-});
-
-it("should allow negative quantity changes when allow_negative is true", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "test-item": {
-          displayName: "Test Item",
-          customerType: "user",
-        },
-      },
-    },
-  });
-
-  const user = await User.create();
-
-  const response = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item/update-quantity?allow_negative=true`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: -3 },
-  });
-
-  expect(response.status).toBe(200);
-  expect(response).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": { "id": "<stripped UUID>" },
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
-
-  const getItemResponse = await niceBackendFetch(`/api/latest/payments/items/user/${user.userId}/test-item`, {
-    accessType: "client",
-  });
-  expect(getItemResponse).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": {
-        "display_name": "Test Item",
-        "id": "test-item",
-        "quantity": -3,
-      },
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
-});
-
-it("supports custom customer type for items (GET and update-quantity)", async ({ expect }) => {
-  await Project.createAndSwitch();
-  await updateConfig({
-    payments: {
-      items: {
-        "custom-item": {
-          displayName: "Custom Item",
-          customerType: "custom",
-        },
-      },
-    },
-  });
-
-  const customCustomerId = "custom-xyz";
-
-  const getBefore = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item`, {
-    accessType: "client",
-  });
-  expect(getBefore.status).toBe(200);
-  expect(getBefore.body.quantity).toBe(0);
-
-  const postChange = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item/update-quantity?allow_negative=false`, {
-    method: "POST",
-    accessType: "admin",
-    body: { delta: 3, description: "grant" },
-  });
-  expect(postChange.status).toBe(200);
-
-  const getAfter = await niceBackendFetch(`/api/latest/payments/items/custom/${customCustomerId}/custom-item`, {
-    accessType: "client",
-  });
-  expect(getAfter.status).toBe(200);
-  expect(getAfter.body.quantity).toBe(3);
-});
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--create-purchase-url.test.ts
similarity index 76%
rename from apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts
rename to apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--create-purchase-url.test.ts
index c09c22c5ac..6178baf4b3 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/old-name/create-purchase-url.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--create-purchase-url.test.ts
@@ -1,11 +1,11 @@
-import { it } from "../../../../../helpers";
-import { Auth, Project, User, niceBackendFetch, Payments } from "../../../../backend-helpers";
 import { generateUuid } from "@stackframe/stack-shared/dist/utils/uuids";
+import { it } from "../../../../../../helpers";
+import { Auth, Payments, Project, User, niceBackendFetch } from "../../../../../backend-helpers";
 
 it("should not be able to create purchase URL without offer_id or offer_inline", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -16,7 +16,7 @@ it("should not be able to create purchase URL without offer_id or offer_inline",
   expect(response).toMatchInlineSnapshot(`
       NiceResponse {
         "status": 400,
-        "body": "Must specify either offer_id or offer_inline!",
+        "body": "Must specify either product_id or product_inline!",
         "headers": Headers { <some fields may have been hidden> },
       }
     `);
@@ -27,7 +27,7 @@ it("should error for non-existent offer_id", async ({ expect }) => {
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -45,7 +45,7 @@ it("should error for non-existent offer_id", async ({ expect }) => {
     },
   });
 
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -58,15 +58,15 @@ it("should error for non-existent offer_id", async ({ expect }) => {
       NiceResponse {
         "status": 400,
         "body": {
-          "code": "OFFER_DOES_NOT_EXIST",
+          "code": "PRODUCT_DOES_NOT_EXIST",
           "details": {
             "access_type": "client",
-            "offer_id": "non-existent-offer",
+            "product_id": "non-existent-offer",
           },
-          "error": "Offer with ID \\"non-existent-offer\\" does not exist or you don't have permissions to access it.",
+          "error": "Product with ID \\"non-existent-offer\\" does not exist or you don't have permissions to access it.",
         },
         "headers": Headers {
-          "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+          "x-stack-known-error": "PRODUCT_DOES_NOT_EXIST",
           <some fields may have been hidden>,
         },
       }
@@ -78,7 +78,7 @@ it("should error for invalid customer_id", async ({ expect }) => {
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -97,7 +97,7 @@ it("should error for invalid customer_id", async ({ expect }) => {
   });
 
   await Auth.Otp.signIn();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -110,17 +110,17 @@ it("should error for invalid customer_id", async ({ expect }) => {
     NiceResponse {
       "status": 400,
       "body": {
-        "code": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "code": "PRODUCT_CUSTOMER_TYPE_DOES_NOT_MATCH",
         "details": {
           "actual_customer_type": "team",
           "customer_id": "<stripped UUID>",
-          "offer_customer_type": "user",
-          "offer_id": "test-offer",
+          "product_customer_type": "user",
+          "product_id": "test-offer",
         },
-        "error": "The team with ID \\"<stripped UUID>\\" is not a valid customer for the inline offer that has been passed in. The offer is configured to only be available for user customers, but the customer is a team.",
+        "error": "The team with ID \\"<stripped UUID>\\" is not a valid customer for the inline product that has been passed in. The product is configured to only be available for user customers, but the customer is a team.",
       },
       "headers": Headers {
-        "x-stack-known-error": "OFFER_CUSTOMER_TYPE_DOES_NOT_MATCH",
+        "x-stack-known-error": "PRODUCT_CUSTOMER_TYPE_DOES_NOT_MATCH",
         <some fields may have been hidden>,
       },
     }
@@ -131,7 +131,7 @@ it("should error for no connected stripe account", async ({ expect }) => {
   await Project.createAndSwitch({ config: { magic_link_enabled: true } });
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -150,13 +150,13 @@ it("should error for no connected stripe account", async ({ expect }) => {
   });
 
   const user = await User.create();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
       customer_type: "user",
       customer_id: user.userId,
-      offer_id: "test-offer",
+      product_id: "test-product",
     },
   });
   expect(response).toMatchInlineSnapshot(`
@@ -174,7 +174,7 @@ it("should not allow offer_inline when calling from client", async ({ expect })
   await Payments.setup();
 
   const { userId } = await Auth.Otp.signIn();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -194,7 +194,7 @@ it("should not allow offer_inline when calling from client", async ({ expect })
       },
     },
   });
-  expect(response.body).toMatchInlineSnapshot(`"Cannot specify offer_inline when calling from client! Please call with a server API key, or use the offer_id parameter."`);
+  expect(response.body).toMatchInlineSnapshot(`"Cannot specify product_inline when calling from client! Please call with a server API key, or use the product_id parameter."`);
 });
 
 it("should error for server-only offer when calling from client", async ({ expect }) => {
@@ -202,7 +202,7 @@ it("should error for server-only offer when calling from client", async ({ expec
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -221,7 +221,7 @@ it("should error for server-only offer when calling from client", async ({ expec
   });
 
   const { userId } = await User.create();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -234,15 +234,15 @@ it("should error for server-only offer when calling from client", async ({ expec
     NiceResponse {
       "status": 400,
       "body": {
-        "code": "OFFER_DOES_NOT_EXIST",
+        "code": "PRODUCT_DOES_NOT_EXIST",
         "details": {
           "access_type": "client",
-          "offer_id": "test-offer",
+          "product_id": "test-offer",
         },
-        "error": "Offer with ID \\"test-offer\\" does not exist or you don't have permissions to access it.",
+        "error": "Product with ID \\"test-offer\\" does not exist or you don't have permissions to access it.",
       },
       "headers": Headers {
-        "x-stack-known-error": "OFFER_DOES_NOT_EXIST",
+        "x-stack-known-error": "PRODUCT_DOES_NOT_EXIST",
         <some fields may have been hidden>,
       },
     }
@@ -254,7 +254,7 @@ it("should allow offer_inline when calling from server", async ({ expect }) => {
   await Payments.setup();
 
   const { userId } = await Auth.Otp.signIn();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "server",
     body: {
@@ -283,7 +283,7 @@ it("should allow valid offer_id", async ({ expect }) => {
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -302,7 +302,7 @@ it("should allow valid offer_id", async ({ expect }) => {
   });
 
   const { userId } = await User.create();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
similarity index 81%
rename from apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts
rename to apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
index 9c028e6007..1067d5dc05 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/old-name/purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
@@ -1,9 +1,9 @@
-import { it } from "../../../../../helpers";
-import { Auth, Payments, Project, User, niceBackendFetch } from "../../../../backend-helpers";
+import { it } from "../../../../../../helpers";
+import { Auth, Payments, Project, User, niceBackendFetch } from "../../../../../backend-helpers";
 
 it("should error on invalid code", async ({ expect }) => {
   await Project.createAndSwitch();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -28,7 +28,7 @@ it("should error on invalid code", async ({ expect }) => {
 
 it("should error on invalid price_id", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -39,7 +39,7 @@ it("should error on invalid price_id", async ({ expect }) => {
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "Price not found on offer associated with this purchase code",
+      "body": "Price not found on product associated with this purchase code",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -47,7 +47,7 @@ it("should error on invalid price_id", async ({ expect }) => {
 
 it("should properly create subscription", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -56,13 +56,8 @@ it("should properly create subscription", async ({ expect }) => {
       quantity: 1,
     },
   });
-  expect(response).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": { "client_secret": "" },
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
+  expect(response.status).toBe(200);
+  expect(response.body).toEqual({ client_secret: expect.any(String) });
 });
 
 it("should return client secret for one-time price (no interval)", async ({ expect }) => {
@@ -70,7 +65,7 @@ it("should return client secret for one-time price (no interval)", async ({ expe
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "ot-offer": {
           displayName: "One Time Offer",
           customerType: "user",
@@ -88,7 +83,7 @@ it("should return client secret for one-time price (no interval)", async ({ expe
   });
 
   const { userId } = await User.create();
-  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const urlRes = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -100,7 +95,7 @@ it("should return client secret for one-time price (no interval)", async ({ expe
   expect(urlRes.status).toBe(200);
   const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
 
-  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const res = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -118,7 +113,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "ot-non-stack": {
           displayName: "One Time Non-Stackable",
           customerType: "user",
@@ -134,7 +129,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
   });
 
   const { userId } = await User.create();
-  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const urlRes = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -146,7 +141,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
   expect(urlRes.status).toBe(200);
   const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
 
-  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const res = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -155,13 +150,7 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
       quantity: 2,
     },
   });
-  expect(res).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
+  expect(res).toMatchInlineSnapshot(`{ "client_secret": "pi_3SAe2C2KCgi1aqUo1EpPjb95_secret_L8CPurjiGtbxopdDmeLkJpR6y" }`);
 });
 
 it("should return client secret for one-time price even if a conflicting group subscription exists (DB-only)", async ({ expect }) => {
@@ -170,7 +159,7 @@ it("should return client secret for one-time price even if a conflicting group s
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Test Group" } },
-      offers: {
+      products: {
         subOffer: {
           displayName: "Sub Offer",
           customerType: "user",
@@ -196,7 +185,7 @@ it("should return client secret for one-time price even if a conflicting group s
   const { userId } = await User.create();
 
   // Create test-mode DB-only subscription for subOffer
-  const createUrlRespA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlRespA = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -207,7 +196,7 @@ it("should return client secret for one-time price even if a conflicting group s
   });
   expect(createUrlRespA.status).toBe(200);
   const codeA = (createUrlRespA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
-  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const testModeRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: { full_code: codeA, price_id: "monthly", quantity: 1 },
@@ -215,7 +204,7 @@ it("should return client secret for one-time price even if a conflicting group s
   expect(testModeRes.status).toBe(200);
 
   // Now purchase one-time offer in same group; should succeed and return client secret
-  const createUrlRespB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlRespB = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -227,7 +216,7 @@ it("should return client secret for one-time price even if a conflicting group s
   expect(createUrlRespB.status).toBe(200);
   const codeB = (createUrlRespB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
 
-  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const res = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: { full_code: codeB, price_id: "one", quantity: 1 },
@@ -246,7 +235,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         tmOneTime: {
           displayName: "TM One Time",
           customerType: "user",
@@ -260,7 +249,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   });
 
   const { userId } = await User.create();
-  const urlRes = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const urlRes = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "tmOneTime" },
@@ -268,7 +257,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   expect(urlRes.status).toBe(200);
   const code = (urlRes.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1]!;
 
-  const res = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const res = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: { full_code: code, price_id: "one", quantity: 2 },
@@ -276,7 +265,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
   expect(res).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
+      "body": "This product is not stackable; quantity must be 1",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -284,7 +273,7 @@ it("test-mode should error on one-time price quantity > 1 when offer is not stac
 
 it("should create purchase URL, validate code, and create purchase session", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -296,7 +285,7 @@ it("should create purchase URL, validate code, and create purchase session", asy
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "This offer is not stackable; quantity must be 1",
+      "body": "This product is not stackable; quantity must be 1",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -307,7 +296,7 @@ it("should create purchase URL with inline offer, validate code, and create purc
   await Payments.setup();
 
   const { userId } = await Auth.Otp.signIn();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "server",
     body: {
@@ -334,7 +323,7 @@ it("should create purchase URL with inline offer, validate code, and create purc
   const code = codeMatch ? codeMatch[1] : undefined;
   expect(code).toBeDefined();
 
-  const purchaseSessionResponse = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const purchaseSessionResponse = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -355,7 +344,7 @@ it("should error when admin tenancy differs from code tenancy", async ({ expect
   const { code } = await Payments.createPurchaseUrlAndGetCode();
   await Project.createAndSwitch();
 
-  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const response = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -384,7 +373,7 @@ it("creates subscription in test mode and increases included item quantity", asy
           customerType: "user",
         },
       },
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -405,7 +394,7 @@ it("creates subscription in test mode and increases included item quantity", asy
   });
 
   const { userId } = await User.create();
-  const createUrlResponse = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlResponse = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -420,13 +409,13 @@ it("creates subscription in test mode and increases included item quantity", asy
   const code = codeMatch ? codeMatch[1] : undefined;
   expect(code).toBeDefined();
 
-  const getBefore = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+  const getBefore = await niceBackendFetch(`/api/v1/payments/items/user/${userId}/test-item`, {
     accessType: "client",
   });
   expect(getBefore.status).toBe(200);
   expect(getBefore.body.quantity).toBe(0);
 
-  const purchaseSessionResponse = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const purchaseSessionResponse = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -437,7 +426,7 @@ it("creates subscription in test mode and increases included item quantity", asy
   expect(purchaseSessionResponse.status).toBe(200);
   expect(purchaseSessionResponse.body).toEqual({ success: true });
 
-  const getAfter = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+  const getAfter = await niceBackendFetch(`/api/v1/payments/items/user/${userId}/test-item`, {
     accessType: "client",
   });
   expect(getAfter.status).toBe(200);
@@ -446,7 +435,7 @@ it("creates subscription in test mode and increases included item quantity", asy
 
 it("test-mode should error when access type is not admin", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const response = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -475,7 +464,7 @@ it("test-mode should error when access type is not admin", async ({ expect }) =>
 
 it("test-mode should error on invalid code", async ({ expect }) => {
   await Project.createAndSwitch();
-  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const response = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -500,7 +489,7 @@ it("test-mode should error on invalid code", async ({ expect }) => {
 
 it("test-mode should error on invalid price_id", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const response = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const response = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -511,7 +500,7 @@ it("test-mode should error on invalid price_id", async ({ expect }) => {
   expect(response).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "Price not found on offer associated with this purchase code",
+      "body": "Price not found on product associated with this purchase code",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -528,7 +517,7 @@ it("allows stackable quantity in test mode and multiplies included items", async
           customerType: "user",
         },
       },
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -549,7 +538,7 @@ it("allows stackable quantity in test mode and multiplies included items", async
   });
 
   const { userId } = await User.create();
-  const createUrlResponse = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlResponse = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -564,13 +553,13 @@ it("allows stackable quantity in test mode and multiplies included items", async
   const code = codeMatch ? codeMatch[1] : undefined;
   expect(code).toBeDefined();
 
-  const getBefore = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+  const getBefore = await niceBackendFetch(`/api/v1/payments/items/user/${userId}/test-item`, {
     accessType: "client",
   });
   expect(getBefore.status).toBe(200);
   expect(getBefore.body.quantity).toBe(0);
 
-  const purchaseSessionResponse = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const purchaseSessionResponse = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -582,7 +571,7 @@ it("allows stackable quantity in test mode and multiplies included items", async
   expect(purchaseSessionResponse.status).toBe(200);
   expect(purchaseSessionResponse.body).toEqual({ success: true });
 
-  const getAfter = await niceBackendFetch(`/api/latest/payments/items/user/${userId}/test-item`, {
+  const getAfter = await niceBackendFetch(`/api/v1/payments/items/user/${userId}/test-item`, {
     accessType: "client",
   });
   expect(getAfter.status).toBe(200);
@@ -597,7 +586,7 @@ it("should update existing stripe subscription when switching offers within a gr
       groups: {
         grp: { displayName: "Test Group" },
       },
-      offers: {
+      products: {
         offerA: {
           displayName: "Offer A",
           customerType: "user",
@@ -633,7 +622,7 @@ it("should update existing stripe subscription when switching offers within a gr
   const { userId } = await User.create();
 
   // First purchase: Offer A
-  const createUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlA = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -646,7 +635,7 @@ it("should update existing stripe subscription when switching offers within a gr
   const codeA = (createUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeA).toBeDefined();
 
-  const purchaseA = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const purchaseA = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -664,7 +653,7 @@ it("should update existing stripe subscription when switching offers within a gr
   `);
 
   // Second purchase: Offer B in same group (should update existing Stripe subscription)
-  const createUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlB = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -677,7 +666,7 @@ it("should update existing stripe subscription when switching offers within a gr
   const codeB = (createUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeB).toBeDefined();
 
-  const purchaseB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const purchaseB = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -703,7 +692,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
       groups: {
         grp: { displayName: "Test Group" },
       },
-      offers: {
+      products: {
         offerA: {
           displayName: "Offer A",
           customerType: "user",
@@ -739,7 +728,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   const { userId } = await User.create();
 
   // Create test-mode DB-only subscription for offerA
-  const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const resUrlA = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -752,7 +741,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   const codeA = (resUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeA).toBeDefined();
 
-  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const testModeRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -764,7 +753,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   expect(testModeRes.status).toBe(200);
 
   // Now purchase offerB in non test-mode; should cancel DB-only sub and create Stripe subscription
-  const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const resUrlB = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -777,7 +766,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   const codeB = (resUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeB).toBeDefined();
 
-  const purchaseB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const purchaseB = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: {
@@ -795,12 +784,12 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   `);
 });
 
-it("should block one-time purchase for same offer after prior one-time purchase (test-mode persisted)", async ({ expect }) => {
+it("should block one-time purchase for same product after prior one-time purchase (test-mode persisted)", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         ot: {
           displayName: "One Time Offer",
           customerType: "user",
@@ -815,7 +804,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
 
   const { userId } = await User.create();
   // First: create code and complete in TEST_MODE (persists OneTimePurchase)
-  const createUrl1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrl1 = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
@@ -824,7 +813,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
   const code1 = (createUrl1.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(code1).toBeDefined();
 
-  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const testModeRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: { full_code: code1, price_id: "one", quantity: 1 },
@@ -832,7 +821,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
   expect(testModeRes.status).toBe(200);
 
   // Second: attempt another purchase for same offer (should be blocked by OneTimePurchase)
-  const createUrl2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrl2 = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "ot" },
@@ -841,7 +830,7 @@ it("should block one-time purchase for same offer after prior one-time purchase
   const code2 = (createUrl2.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(code2).toBeDefined();
 
-  const res = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const res = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: { full_code: code2, price_id: "one", quantity: 1 },
@@ -856,7 +845,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Group" } },
-      offers: {
+      products: {
         offerA: {
           displayName: "Offer A",
           customerType: "user",
@@ -881,7 +870,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
 
   const { userId } = await User.create();
   // Purchase offerA in TEST_MODE (persists OneTimePurchase)
-  const urlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const urlA = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
@@ -890,7 +879,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
   const codeA = (urlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeA).toBeDefined();
 
-  const tmRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const tmRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: { full_code: codeA, price_id: "one", quantity: 1 },
@@ -898,7 +887,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
   expect(tmRes.status).toBe(200);
 
   // Attempt to purchase offerB in same group (should be blocked)
-  const urlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const urlB = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
@@ -907,11 +896,11 @@ it("should block one-time purchase in same group after prior one-time purchase i
   const codeB = (urlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeB).toBeDefined();
 
-  const resB = await niceBackendFetch("/api/latest/payments/purchases/purchase-session", {
+  const resB = await niceBackendFetch("/api/v1/payments/purchases/purchase-session", {
     method: "POST",
     accessType: "client",
     body: { full_code: codeB, price_id: "one", quantity: 1 },
   });
   expect(resB.status).toBe(400);
-  expect(String(resB.body)).toContain("one-time purchase in this offer group");
+  expect(String(resB.body)).toContain("one-time purchase in this product group");
 });
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
similarity index 74%
rename from apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts
rename to apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
index 7b78026a63..0d6755a2ca 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/old-name/validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
@@ -1,10 +1,10 @@
-import { it } from "../../../../../helpers";
-import { Payments, Project, User, niceBackendFetch } from "../../../../backend-helpers";
+import { it } from "../../../../../../helpers";
+import { Payments, Project, User, niceBackendFetch } from "../../../../../backend-helpers";
 
 
 it("should error on invalid code", async ({ expect }) => {
   await Project.createAndSwitch();
-  const response = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+  const response = await niceBackendFetch("/api/v1/payments/purchases/validate-code", {
     method: "POST",
     accessType: "client",
     body: {
@@ -28,7 +28,7 @@ it("should error on invalid code", async ({ expect }) => {
 
 it("should allow valid code and return offer data", async ({ expect }) => {
   const { code } = await Payments.createPurchaseUrlAndGetCode();
-  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+  const validateResponse = await niceBackendFetch("/api/v1/payments/purchases/validate-code", {
     method: "POST",
     accessType: "client",
     body: { full_code: code },
@@ -39,9 +39,24 @@ it("should allow valid code and return offer data", async ({ expect }) => {
       "body": {
         "already_bought_non_stackable": false,
         "conflicting_group_offers": [],
+        "conflicting_products": [],
         "offer": {
           "customer_type": "user",
-          "display_name": "Test Offer",
+          "display_name": "Test Product",
+          "prices": {
+            "monthly": {
+              "USD": "1000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
+        "product": {
+          "customer_type": "user",
+          "display_name": "Test Product",
           "prices": {
             "monthly": {
               "USD": "1000",
@@ -66,7 +81,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      offers: {
+      products: {
         "test-offer": {
           displayName: "Test Offer",
           customerType: "user",
@@ -86,7 +101,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
 
   const { userId } = await User.create();
   // Create a code for test-offer and purchase it in test mode (creates DB subscription)
-  const createUrlRes1 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlRes1 = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -99,7 +114,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   const code1 = (createUrlRes1.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(code1).toBeDefined();
 
-  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const testModeRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: {
@@ -111,7 +126,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   expect(testModeRes.status).toBe(200);
 
   // Create a second code for the same offer and validate; should report already_bought_non_stackable
-  const createUrlRes2 = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const createUrlRes2 = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: {
@@ -124,7 +139,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   const code2 = (createUrlRes2.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(code2).toBeDefined();
 
-  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+  const validateResponse = await niceBackendFetch("/api/v1/payments/purchases/validate-code", {
     method: "POST",
     accessType: "client",
     body: { full_code: code2 },
@@ -135,6 +150,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
       "body": {
         "already_bought_non_stackable": true,
         "conflicting_group_offers": [],
+        "conflicting_products": [],
         "offer": {
           "customer_type": "user",
           "display_name": "Test Offer",
@@ -149,6 +165,20 @@ it("should set already_bought_non_stackable when user already owns non-stackable
           },
           "stackable": false,
         },
+        "product": {
+          "customer_type": "user",
+          "display_name": "Test Offer",
+          "prices": {
+            "monthly": {
+              "USD": "1000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
         "project_id": "<stripped UUID>",
         "stripe_account_id": <stripped field 'stripe_account_id'>,
       },
@@ -163,7 +193,7 @@ it("should include conflicting_group_offers when switching within the same group
   await Project.updateConfig({
     payments: {
       groups: { grp: { displayName: "Group" } },
-      offers: {
+      products: {
         offerA: {
           displayName: "Offer A",
           customerType: "user",
@@ -189,7 +219,7 @@ it("should include conflicting_group_offers when switching within the same group
   const { userId } = await User.create();
 
   // Subscribe to offerA in test mode
-  const resUrlA = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const resUrlA = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "offerA" },
@@ -198,7 +228,7 @@ it("should include conflicting_group_offers when switching within the same group
   const codeA = (resUrlA.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeA).toBeDefined();
 
-  const testModeRes = await niceBackendFetch("/api/latest/internal/payments/test-mode-purchase-session", {
+  const testModeRes = await niceBackendFetch("/api/v1/internal/payments/test-mode-purchase-session", {
     method: "POST",
     accessType: "admin",
     body: { full_code: codeA, price_id: "monthly", quantity: 1 },
@@ -206,7 +236,7 @@ it("should include conflicting_group_offers when switching within the same group
   expect(testModeRes.status).toBe(200);
 
   // Now validate code for offerB; should report conflict with offerA
-  const resUrlB = await niceBackendFetch("/api/latest/payments/purchases/create-purchase-url", {
+  const resUrlB = await niceBackendFetch("/api/v1/payments/purchases/create-purchase-url", {
     method: "POST",
     accessType: "client",
     body: { customer_type: "user", customer_id: userId, offer_id: "offerB" },
@@ -215,7 +245,7 @@ it("should include conflicting_group_offers when switching within the same group
   const codeB = (resUrlB.body as { url: string }).url.match(/\/purchase\/([a-z0-9-_]+)/)?.[1];
   expect(codeB).toBeDefined();
 
-  const validateResponse = await niceBackendFetch("/api/latest/payments/purchases/validate-code", {
+  const validateResponse = await niceBackendFetch("/api/v1/payments/purchases/validate-code", {
     method: "POST",
     accessType: "client",
     body: { full_code: codeB },
@@ -231,6 +261,12 @@ it("should include conflicting_group_offers when switching within the same group
             "offer_id": "offerA",
           },
         ],
+        "conflicting_products": [
+          {
+            "display_name": "Offer A",
+            "product_id": "offerA",
+          },
+        ],
         "offer": {
           "customer_type": "user",
           "display_name": "Offer B",
@@ -245,6 +281,20 @@ it("should include conflicting_group_offers when switching within the same group
           },
           "stackable": false,
         },
+        "product": {
+          "customer_type": "user",
+          "display_name": "Offer B",
+          "prices": {
+            "monthly": {
+              "USD": "2000",
+              "interval": [
+                1,
+                "month",
+              ],
+            },
+          },
+          "stackable": false,
+        },
         "project_id": "<stripped UUID>",
         "stripe_account_id": <stripped field 'stripe_account_id'>,
       },
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
index d36c702e55..e68d93826a 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
@@ -38,7 +38,7 @@ it("should allow valid code and return product data", async ({ expect }) => {
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_products": [],
+        "conflicting_products": [],
         "product": {
           "customer_type": "user",
           "display_name": "Test Product",
@@ -134,7 +134,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
       "status": 200,
       "body": {
         "already_bought_non_stackable": true,
-        "conflicting_group_products": [],
+        "conflicting_products": [],
         "product": {
           "customer_type": "user",
           "display_name": "Test Product",
@@ -157,7 +157,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
   `);
 });
 
-it("should include conflicting_group_products when switching within the same group", async ({ expect }) => {
+it("should include conflicting_products when switching within the same group", async ({ expect }) => {
   await Project.createAndSwitch();
   await Payments.setup();
   await Project.updateConfig({
@@ -225,7 +225,7 @@ it("should include conflicting_group_products when switching within the same gro
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_products": [
+        "conflicting_products": [
           {
             "display_name": "Product A",
             "product_id": "productA",

From b2da2f041af8206f5e48eb0e0da7f0ba2b0dce84 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Tue, 23 Sep 2025 15:27:42 -0700
Subject: [PATCH 07/23] Remove validateCode migration

---
 .../payments/purchases/validate-code/route.ts | 35 -------------
 .../outdated--validate-code.test.ts           | 50 -------------------
 2 files changed, 85 deletions(-)
 delete mode 100644 apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts

diff --git a/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts
deleted file mode 100644
index 32fb25a849..0000000000
--- a/apps/backend/src/app/api/migrations/v2beta5/payments/purchases/validate-code/route.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { POST as latestHandler } from "@/app/api/latest/payments/purchases/validate-code/route";
-import { createSmartRouteHandler } from "@/route-handlers/smart-route-handler";
-import { ensureObjectSchema, yupArray, yupObject, yupString } from "@stackframe/stack-shared/dist/schema-fields";
-
-const latestInit = latestHandler.initArgs[0];
-const responseSchema = ensureObjectSchema(latestInit.response);
-const responseBodySchema = ensureObjectSchema(responseSchema.getNested("body"));
-
-
-export const POST = createSmartRouteHandler({
-  ...latestInit,
-  response: responseSchema.concat(yupObject({
-    body: responseBodySchema.concat(yupObject({
-      offer: responseBodySchema.getNested("product").meta({ openapiField: { hidden: true } }),
-      conflicting_group_offers: yupArray(yupObject({
-        offer_id: yupString().defined(),
-        display_name: yupString().defined(),
-      }).defined()).defined().meta({ openapiField: { hidden: true } }),
-    })),
-  })),
-  handler: async (_req, fullReq) => {
-    const response = await latestHandler.invoke(fullReq);
-    return {
-      ...response,
-      body: {
-        ...response.body,
-        offer: response.body.product,
-        conflicting_group_offers: response.body.conflicting_products.map(({ product_id, display_name }) => ({
-          offer_id: product_id,
-          display_name,
-        })),
-      }
-    };
-  },
-});
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
index 0d6755a2ca..0c2faa7392 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
@@ -38,22 +38,7 @@ it("should allow valid code and return offer data", async ({ expect }) => {
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_offers": [],
         "conflicting_products": [],
-        "offer": {
-          "customer_type": "user",
-          "display_name": "Test Product",
-          "prices": {
-            "monthly": {
-              "USD": "1000",
-              "interval": [
-                1,
-                "month",
-              ],
-            },
-          },
-          "stackable": false,
-        },
         "product": {
           "customer_type": "user",
           "display_name": "Test Product",
@@ -149,22 +134,7 @@ it("should set already_bought_non_stackable when user already owns non-stackable
       "status": 200,
       "body": {
         "already_bought_non_stackable": true,
-        "conflicting_group_offers": [],
         "conflicting_products": [],
-        "offer": {
-          "customer_type": "user",
-          "display_name": "Test Offer",
-          "prices": {
-            "monthly": {
-              "USD": "1000",
-              "interval": [
-                1,
-                "month",
-              ],
-            },
-          },
-          "stackable": false,
-        },
         "product": {
           "customer_type": "user",
           "display_name": "Test Offer",
@@ -255,32 +225,12 @@ it("should include conflicting_group_offers when switching within the same group
       "status": 200,
       "body": {
         "already_bought_non_stackable": false,
-        "conflicting_group_offers": [
-          {
-            "display_name": "Offer A",
-            "offer_id": "offerA",
-          },
-        ],
         "conflicting_products": [
           {
             "display_name": "Offer A",
             "product_id": "offerA",
           },
         ],
-        "offer": {
-          "customer_type": "user",
-          "display_name": "Offer B",
-          "prices": {
-            "monthly": {
-              "USD": "2000",
-              "interval": [
-                1,
-                "month",
-              ],
-            },
-          },
-          "stackable": false,
-        },
         "product": {
           "customer_type": "user",
           "display_name": "Offer B",

From 4790eb352c99dd1d3c117d8e0ed2e4931b495d92 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Wed, 24 Sep 2025 15:38:52 -0700
Subject: [PATCH 08/23] Groups -> catalogs

---
 apps/backend/prisma/seed.ts                   |  10 +-
 .../test-mode-purchase-session/route.tsx      |   6 +-
 .../purchases/purchase-session/route.tsx      |   6 +-
 .../payments/purchases/validate-code/route.ts |   8 +-
 apps/backend/src/lib/payments.test.tsx        |  94 +++---
 apps/backend/src/lib/payments.tsx             |  58 ++--
 .../payments/offers/create-group-dialog.tsx   |  16 +-
 .../payments/offers/dummy-data.tsx            | 278 ------------------
 .../offers/page-client-catalogs-view.tsx      | 143 +++++----
 .../payments/offers/page-client-list-view.tsx |  42 ++-
 .../payments/offers/product-dialog.tsx        |  22 +-
 .../outdated--purchase-session.test.ts        |   8 +-
 .../outdated--validate-code.test.ts           |   2 +-
 .../api/v1/payments/purchase-session.test.ts  |  33 +--
 .../api/v1/payments/validate-code.test.ts     |   6 +-
 .../components/layouts/api/api-sidebar.tsx    |   2 +-
 packages/stack-shared/src/config/schema.ts    |  72 +++--
 packages/stack-shared/src/schema-fields.ts    |   2 +-
 18 files changed, 269 insertions(+), 539 deletions(-)
 delete mode 100644 apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx

diff --git a/apps/backend/prisma/seed.ts b/apps/backend/prisma/seed.ts
index b7cf165f85..45aea975af 100644
--- a/apps/backend/prisma/seed.ts
+++ b/apps/backend/prisma/seed.ts
@@ -98,14 +98,14 @@ async function seed() {
         }
       },
       payments: {
-        groups: {
+        catalogs: {
           plans: {
             displayName: "Plans",
           }
         },
         products: {
           team: {
-            groupId: "plans",
+            catalogId: "plans",
             displayName: "Team",
             customerType: "team",
             serverOnly: false,
@@ -126,7 +126,7 @@ async function seed() {
             }
           },
           growth: {
-            groupId: "plans",
+            catalogId: "plans",
             displayName: "Growth",
             customerType: "team",
             serverOnly: false,
@@ -147,7 +147,7 @@ async function seed() {
             }
           },
           free: {
-            groupId: "plans",
+            catalogId: "plans",
             displayName: "Free",
             customerType: "team",
             serverOnly: false,
@@ -162,7 +162,7 @@ async function seed() {
             }
           },
           "extra-admins": {
-            groupId: "plans",
+            catalogId: "plans",
             displayName: "Extra Admins",
             customerType: "team",
             serverOnly: false,
diff --git a/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx b/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
index 5e5a4e1575..5144bd308f 100644
--- a/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
+++ b/apps/backend/src/app/api/latest/internal/payments/test-mode-purchase-session/route.tsx
@@ -37,7 +37,7 @@ export const POST = createSmartRouteHandler({
     }
     const prisma = await getPrismaClientForTenancy(auth.tenancy);
 
-    const { selectedPrice, conflictingGroupSubscriptions } = await validatePurchaseSession({
+    const { selectedPrice, conflictingCatalogSubscriptions } = await validatePurchaseSession({
       prisma,
       tenancy: auth.tenancy,
       codeData: data,
@@ -63,8 +63,8 @@ export const POST = createSmartRouteHandler({
       });
     } else {
       // Cancel conflicting subscriptions for TEST_MODE as well, then create new TEST_MODE subscription
-      if (conflictingGroupSubscriptions.length > 0) {
-        const conflicting = conflictingGroupSubscriptions[0];
+      if (conflictingCatalogSubscriptions.length > 0) {
+        const conflicting = conflictingCatalogSubscriptions[0];
         if (conflicting.stripeSubscriptionId) {
           const stripe = await getStripeForAccount({ tenancy: auth.tenancy });
           await stripe.subscriptions.cancel(conflicting.stripeSubscriptionId);
diff --git a/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx b/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
index 9226adfa00..9f97ac6280 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
+++ b/apps/backend/src/app/api/latest/payments/purchases/purchase-session/route.tsx
@@ -35,7 +35,7 @@ export const POST = createSmartRouteHandler({
     }
     const stripe = await getStripeForAccount({ accountId: data.stripeAccountId });
     const prisma = await getPrismaClientForTenancy(tenancy);
-    const { selectedPrice, conflictingGroupSubscriptions } = await validatePurchaseSession({
+    const { selectedPrice, conflictingCatalogSubscriptions } = await validatePurchaseSession({
       prisma,
       tenancy,
       codeData: data,
@@ -46,8 +46,8 @@ export const POST = createSmartRouteHandler({
       throw new StackAssertionError("Price not resolved for purchase session");
     }
 
-    if (conflictingGroupSubscriptions.length > 0) {
-      const conflicting = conflictingGroupSubscriptions[0];
+    if (conflictingCatalogSubscriptions.length > 0) {
+      const conflicting = conflictingCatalogSubscriptions[0];
       if (conflicting.stripeSubscriptionId) {
         const existingStripeSub = await stripe.subscriptions.retrieve(conflicting.stripeSubscriptionId);
         const existingItem = existingStripeSub.items.data[0];
diff --git a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
index 2e36953de1..ac8be16ff5 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
+++ b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
@@ -67,15 +67,15 @@ export const POST = createSmartRouteHandler({
 
     const alreadyBoughtNonStackable = !!(subscriptions.find((s) => s.productId === verificationCode.data.productId) && product.stackable !== true);
 
-    const groups = tenancy.config.payments.groups;
-    const groupId = Object.keys(groups).find((g) => product.groupId === g);
+    const groups = tenancy.config.payments.catalogs;
+    const catalogId = Object.keys(groups).find((g) => product.catalogId === g);
     let conflictingGroupProducts: { product_id: string, display_name: string }[] = [];
-    if (groupId) {
+    if (catalogId) {
       const isSubscribable = product.prices !== "include-by-default" && Object.values(product.prices).some((p: any) => p && p.interval);
       if (isSubscribable) {
         const conflicts = subscriptions.filter((subscription) => (
           subscription.productId &&
-          subscription.product.groupId === groupId &&
+          subscription.product.catalogId === catalogId &&
           isActiveSubscription(subscription) &&
           subscription.product.prices !== "include-by-default" &&
           (!product.isAddOnTo || !Object.keys(product.isAddOnTo).includes(subscription.productId))
diff --git a/apps/backend/src/lib/payments.test.tsx b/apps/backend/src/lib/payments.test.tsx
index b3efbc7670..0f9145b470 100644
--- a/apps/backend/src/lib/payments.test.tsx
+++ b/apps/backend/src/lib/payments.test.tsx
@@ -57,7 +57,7 @@ describe('getItemQuantityForCustomer - manual changes (no subscription)', () =>
         },
       },
       products: {},
-      groups: {},
+      catalogs: {},
     });
 
     const prisma = createMockPrisma({
@@ -101,7 +101,7 @@ describe('getItemQuantityForCustomer - manual changes (no subscription)', () =>
         },
       },
       products: {},
-      groups: {},
+      catalogs: {},
     });
 
     const prisma = createMockPrisma({
@@ -146,10 +146,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         off1: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 3, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
@@ -184,10 +184,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offW: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 4, repeat: [1, 'week'], expires: 'when-purchase-expires' } },
           isAddOnTo: false,
@@ -223,10 +223,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offW: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 4, repeat: [1, 'week'], expires: 'never' } },
           isAddOnTo: false,
@@ -262,10 +262,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offR: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 7, repeat: [1, 'week'], expires: 'when-repeated' } },
           isAddOnTo: false,
@@ -301,10 +301,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offN: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 2, repeat: 'never', expires: 'never' } },
           isAddOnTo: false,
@@ -336,10 +336,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offRC: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 7, repeat: [1, 'week'], expires: 'when-repeated' } },
           isAddOnTo: false,
@@ -379,10 +379,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offRR: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 7, repeat: [1, 'week'], expires: 'when-repeated' } },
           isAddOnTo: false,
@@ -428,10 +428,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
       items: {
         [itemId]: { displayName: 'S', customerType: 'user' },
       },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offMD: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 10, repeat: [1, 'week'], expires: 'when-repeated' } },
           isAddOnTo: false,
@@ -476,10 +476,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
     const itemId = 'subPersistentWhenRepeated';
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'S', customerType: 'user' } },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offBF: {
-          displayName: 'O', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 5, repeat: 'never', expires: 'when-repeated' } },
           isAddOnTo: false,
@@ -524,16 +524,16 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
 
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'S', customerType: 'user' } },
-      groups: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } },
+      catalogs: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } },
       products: {
         off1: {
-          displayName: 'O1', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O1', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 2, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
         },
         off2: {
-          displayName: 'O2', groupId: 'g2', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'O2', catalogId: 'g2', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 1, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
@@ -575,10 +575,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
 
     const tenancy = createMockTenancy({
       items: { [itemA]: { displayName: 'A', customerType: 'user' }, [itemB]: { displayName: 'B', customerType: 'user' } },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offBundle: {
-          displayName: 'OB', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'OB', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: {
             [itemA]: { quantity: 2, repeat: 'never', expires: 'when-purchase-expires' },
@@ -615,10 +615,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
 
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'T', customerType: 'user' } },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offT: {
-          displayName: 'OT', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'OT', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 5, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
@@ -650,10 +650,10 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
 
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'C', customerType: 'user' } },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offC: {
-          displayName: 'OC', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'OC', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 9, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
@@ -685,11 +685,11 @@ describe('getItemQuantityForCustomer - subscriptions', () => {
 
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'U', customerType: 'user' } },
-      groups: {},
+      catalogs: {},
       products: {
         offU: {
           displayName: 'OU',
-          groupId: undefined,
+          catalogId: undefined,
           customerType: 'user',
           freeTrial: undefined,
           serverOnly: false,
@@ -726,7 +726,7 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'I', customerType: 'custom' } },
       products: {},
-      groups: {},
+      catalogs: {},
     });
 
     const prisma = createMockPrisma({
@@ -755,7 +755,7 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'I', customerType: 'custom' } },
       products: {},
-      groups: {},
+      catalogs: {},
     });
 
     const prisma = createMockPrisma({
@@ -781,10 +781,10 @@ describe('getItemQuantityForCustomer - one-time purchases', () => {
 
 describe('validatePurchaseSession - one-time purchase rules', () => {
   it('blocks duplicate one-time purchase for same productId', async () => {
-    const tenancy = createMockTenancy({ items: {}, products: {}, groups: {} });
+    const tenancy = createMockTenancy({ items: {}, products: {}, catalogs: {} });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ productId: 'product-dup', product: { groupId: undefined }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'product-dup', product: { catalogId: undefined }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -798,7 +798,7 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
         productId: 'product-dup',
         product: {
           displayName: 'X',
-          groupId: undefined,
+          catalogId: undefined,
           customerType: 'custom',
           freeTrial: undefined,
           serverOnly: false,
@@ -814,10 +814,10 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
   });
 
   it('blocks one-time purchase when another one exists in the same group', async () => {
-    const tenancy = createMockTenancy({ items: {}, products: {}, groups: { g1: { displayName: 'G1' } } });
+    const tenancy = createMockTenancy({ items: {}, products: {}, catalogs: { g1: { displayName: 'G1' } } });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ productId: 'other-product', product: { groupId: 'g1' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'other-product', product: { catalogId: 'g1' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -831,7 +831,7 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
         productId: 'product-y',
         product: {
           displayName: 'Y',
-          groupId: 'g1',
+          catalogId: 'g1',
           customerType: 'custom',
           freeTrial: undefined,
           serverOnly: false,
@@ -843,14 +843,14 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       },
       priceId: 'price-any',
       quantity: 1,
-    })).rejects.toThrowError('Customer already has a one-time purchase in this product group');
+    })).rejects.toThrowError('Customer already has a one-time purchase in this product catalog');
   });
 
   it('allows purchase when existing one-time is in a different group', async () => {
-    const tenancy = createMockTenancy({ items: {}, products: {}, groups: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } } });
+    const tenancy = createMockTenancy({ items: {}, products: {}, catalogs: { g1: { displayName: 'G1' }, g2: { displayName: 'G2' } } });
     const prisma = createMockPrisma({
       oneTimePurchase: {
-        findMany: async () => [{ productId: 'other-product', product: { groupId: 'g2' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
+        findMany: async () => [{ productId: 'other-product', product: { catalogId: 'g2' }, quantity: 1, createdAt: new Date('2025-01-01T00:00:00.000Z') }],
       },
       subscription: { findMany: async () => [] },
     } as any);
@@ -864,7 +864,7 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
         productId: 'product-z',
         product: {
           displayName: 'Z',
-          groupId: 'g1',
+          catalogId: 'g1',
           customerType: 'custom',
           freeTrial: undefined,
           serverOnly: false,
@@ -877,8 +877,8 @@ describe('validatePurchaseSession - one-time purchase rules', () => {
       priceId: 'price-any',
       quantity: 1,
     });
-    expect(res.groupId).toBe('g1');
-    expect(res.conflictingGroupSubscriptions.length).toBe(0);
+    expect(res.catalogId).toBe('g1');
+    expect(res.conflictingCatalogSubscriptions.length).toBe(0);
   });
 });
 
@@ -890,10 +890,10 @@ describe('combined sources - one-time purchases + manual changes + subscriptions
     const itemId = 'comboItem';
     const tenancy = createMockTenancy({
       items: { [itemId]: { displayName: 'Combo', customerType: 'user' } },
-      groups: { g1: { displayName: 'G' } },
+      catalogs: { g1: { displayName: 'G' } },
       products: {
         offSub: {
-          displayName: 'Sub', groupId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
+          displayName: 'Sub', catalogId: 'g1', customerType: 'user', freeTrial: undefined, serverOnly: false, stackable: false,
           prices: {},
           includedItems: { [itemId]: { quantity: 5, repeat: 'never', expires: 'when-purchase-expires' } },
           isAddOnTo: false,
diff --git a/apps/backend/src/lib/payments.tsx b/apps/backend/src/lib/payments.tsx
index 4c8d1b1720..8c38cda976 100644
--- a/apps/backend/src/lib/payments.tsx
+++ b/apps/backend/src/lib/payments.tsx
@@ -40,7 +40,7 @@ export async function ensureProductIdOrInlineProduct(
       throw new StackAssertionError("Inline product does not exist, this should never happen", { inlineProduct, productId });
     }
     return {
-      groupId: undefined,
+      catalogId: undefined,
       isAddOnTo: false,
       displayName: inlineProduct.display_name,
       customerType: inlineProduct.customer_type,
@@ -246,7 +246,7 @@ type Subscription = {
    */
   productId: string | null,
   /**
-   * `null` for test mode purchases and group default products
+   * `null` for test mode purchases and catalog default products
    */
   stripeSubscriptionId: string | null,
   product: yup.InferType<typeof productSchema>,
@@ -267,7 +267,7 @@ export async function getSubscriptions(options: {
   customerType: "user" | "team" | "custom",
   customerId: string,
 }) {
-  const groups = options.tenancy.config.payments.groups;
+  const catalogs = options.tenancy.config.payments.catalogs;
   const products = options.tenancy.config.payments.products;
   const subscriptions: Subscription[] = [];
   const dbSubscriptions = await options.prisma.subscription.findMany({
@@ -278,7 +278,7 @@ export async function getSubscriptions(options: {
     },
   });
 
-  const groupsWithDbSubscriptions = new Set<string>();
+  const catalogsWithDbSubscriptions = new Set<string>();
   for (const s of dbSubscriptions) {
     const product = s.productId ? getOrUndefined(products, s.productId) : s.product as yup.InferType<typeof productSchema>;
     if (!product) continue;
@@ -293,20 +293,20 @@ export async function getSubscriptions(options: {
       createdAt: s.createdAt,
       stripeSubscriptionId: s.stripeSubscriptionId,
     });
-    if (product.groupId !== undefined) {
-      groupsWithDbSubscriptions.add(product.groupId);
+    if (product.catalogId !== undefined) {
+      catalogsWithDbSubscriptions.add(product.catalogId);
     }
   }
 
-  for (const groupId of Object.keys(groups)) {
-    if (groupsWithDbSubscriptions.has(groupId)) continue;
-    const productsInGroup = typedEntries(products).filter(([_, product]) => product.groupId === groupId);
-    const defaultGroupProduct = productsInGroup.find(([_, product]) => product.prices === "include-by-default");
-    if (defaultGroupProduct) {
+  for (const catalogId of Object.keys(catalogs)) {
+    if (catalogsWithDbSubscriptions.has(catalogId)) continue;
+    const productsInCatalog = typedEntries(products).filter(([_, product]) => product.catalogId === catalogId);
+    const defaultCatalogProduct = productsInCatalog.find(([_, product]) => product.prices === "include-by-default");
+    if (defaultCatalogProduct) {
       subscriptions.push({
         id: null,
-        productId: defaultGroupProduct[0],
-        product: defaultGroupProduct[1],
+        productId: defaultCatalogProduct[0],
+        product: defaultCatalogProduct[1],
         quantity: 1,
         currentPeriodStart: DEFAULT_PRODUCT_START_DATE,
         currentPeriodEnd: null,
@@ -375,9 +375,9 @@ export async function validatePurchaseSession(options: {
   quantity: number,
 }): Promise<{
   selectedPrice: SelectedPrice | undefined,
-  groupId: string | undefined,
+  catalogId: string | undefined,
   subscriptions: Subscription[],
-  conflictingGroupSubscriptions: Subscription[],
+  conflictingCatalogSubscriptions: Subscription[],
 }> {
   const { prisma, tenancy, codeData, priceId, quantity } = options;
   const product = codeData.product;
@@ -424,36 +424,36 @@ export async function validatePurchaseSession(options: {
   }
   const addOnProductIds = product.isAddOnTo ? typedKeys(product.isAddOnTo) : [];
   if (product.isAddOnTo && !subscriptions.some((s) => s.productId && addOnProductIds.includes(s.productId))) {
-    throw new StatusError(400, "This product is an add-on to an product that the customer does not have");
+    throw new StatusError(400, "This product is an add-on to a product that the customer does not have");
   }
 
-  const groups = tenancy.config.payments.groups;
-  const groupId = typedKeys(groups).find((g) => product.groupId === g);
+  const catalogs = tenancy.config.payments.catalogs;
+  const catalogId = typedKeys(catalogs).find((g) => product.catalogId === g);
 
-  // Block purchasing any product in the same group if a one-time purchase exists in that group
-  if (groupId) {
-    const hasOneTimeInGroup = existingOneTimePurchases.some((p) => {
+  // Block purchasing any product in the same catalog if a one-time purchase exists in that catalog
+  if (catalogId) {
+    const hasOneTimeInCatalog = existingOneTimePurchases.some((p) => {
       const product = p.product as yup.InferType<typeof productSchema>;
-      return product.groupId === groupId;
+      return product.catalogId === catalogId;
     });
-    if (hasOneTimeInGroup) {
-      throw new StatusError(400, "Customer already has a one-time purchase in this product group");
+    if (hasOneTimeInCatalog) {
+      throw new StatusError(400, "Customer already has a one-time purchase in this product catalog");
     }
   }
 
-  let conflictingGroupSubscriptions: Subscription[] = [];
-  if (groupId) {
-    conflictingGroupSubscriptions = subscriptions.filter((subscription) => (
+  let conflictingCatalogSubscriptions: Subscription[] = [];
+  if (catalogId) {
+    conflictingCatalogSubscriptions = subscriptions.filter((subscription) => (
       subscription.id &&
       subscription.productId &&
-      subscription.product.groupId === groupId &&
+      subscription.product.catalogId === catalogId &&
       isActiveSubscription(subscription) &&
       subscription.product.prices !== "include-by-default" &&
       (!product.isAddOnTo || !addOnProductIds.includes(subscription.productId))
     ));
   }
 
-  return { selectedPrice, groupId, subscriptions, conflictingGroupSubscriptions };
+  return { selectedPrice, catalogId, subscriptions, conflictingCatalogSubscriptions };
 }
 
 export function getClientSecretFromStripeSubscription(subscription: Stripe.Subscription): string {
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
index ce9402b963..0608b879b4 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
@@ -10,7 +10,7 @@ type CreateGroupDialogProps = {
 };
 
 export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupDialogProps) {
-  const [groupId, setGroupId] = useState("");
+  const [catalogId, setCatalogId] = useState("");
   const [displayName, setDisplayName] = useState("");
   const [errors, setErrors] = useState<{ id?: string, displayName?: string }>({});
 
@@ -18,9 +18,9 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
     const newErrors: { id?: string, displayName?: string } = {};
 
     // Validate group ID
-    if (!groupId.trim()) {
+    if (!catalogId.trim()) {
       newErrors.id = "Group ID is required";
-    } else if (!/^[a-z0-9-]+$/.test(groupId)) {
+    } else if (!/^[a-z0-9-]+$/.test(catalogId)) {
       newErrors.id = "Group ID must contain only lowercase letters, numbers, and hyphens";
     }
 
@@ -34,17 +34,17 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
       return;
     }
 
-    onCreate({ id: groupId.trim(), displayName: displayName.trim() });
+    onCreate({ id: catalogId.trim(), displayName: displayName.trim() });
 
     // Reset form
-    setGroupId("");
+    setCatalogId("");
     setDisplayName("");
     setErrors({});
     onOpenChange(false);
   };
 
   const handleClose = () => {
-    setGroupId("");
+    setCatalogId("");
     setDisplayName("");
     setErrors({});
     onOpenChange(false);
@@ -69,9 +69,9 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
             </Label>
             <Input
               id="group-id"
-              value={groupId}
+              value={catalogId}
               onChange={(e) => {
-                setGroupId(e.target.value);
+                setCatalogId(e.target.value);
                 setErrors(prev => ({ ...prev, id: undefined }));
               }}
               placeholder="e.g., pricing-tiers"
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx
deleted file mode 100644
index cf2f5948aa..0000000000
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/dummy-data.tsx
+++ /dev/null
@@ -1,278 +0,0 @@
-// Dummy data for development
-export const DUMMY_PAYMENTS_CONFIG: any = {
-  groups: {
-    "basic-plans": { displayName: "Basic Plans" },
-    "pro-plans": { displayName: "Professional Plans" },
-    "enterprise": { displayName: "Enterprise" },
-    "add-ons": { displayName: "Add-ons" },
-  },
-  products: {
-    "free-trial": {
-      displayName: "Free Trial",
-      customerType: "user" as const,
-      groupId: "basic-plans",
-      freeTrial: [14, "day"] as [number, "day"],
-      stackable: false,
-      serverOnly: false,
-      prices: "include-by-default" as const,
-      includedItems: {
-        "basic-features": { quantity: 1 },
-        "cloud-storage-5gb": { quantity: 1 },
-      },
-    },
-    "starter": {
-      displayName: "Starter",
-      customerType: "user" as const,
-      groupId: "basic-plans",
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "9.99", interval: [1, "month"] as [number, "month"] },
-        "yearly": { USD: "99.90", interval: [1, "year"] as [number, "year"] },
-      },
-      includedItems: {
-        "basic-features": { quantity: 1 },
-        "cloud-storage-10gb": { quantity: 1 },
-        "email-support": { quantity: 1 },
-        "api-calls": { quantity: 1000 },
-      },
-    },
-    "professional": {
-      displayName: "Professional",
-      customerType: "user" as const,
-      groupId: "pro-plans",
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "29.99", interval: [1, "month"] as [number, "month"] },
-        "yearly": { USD: "299.90", interval: [1, "year"] as [number, "year"] },
-        "quarterly": { USD: "89.97", interval: [3, "month"] as [number, "month"] },
-      },
-      includedItems: {
-        "pro-features": { quantity: 1 },
-        "cloud-storage-100gb": { quantity: 1 },
-        "priority-support": { quantity: 1 },
-        "api-calls": { quantity: 10000 },
-        "team-members": { quantity: 5 },
-        "custom-domain": { quantity: 1 },
-      },
-    },
-    "business": {
-      displayName: "Business",
-      customerType: "team" as const,
-      groupId: "pro-plans",
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "99.99", interval: [1, "month"] as [number, "month"] },
-        "yearly": { USD: "999.90", interval: [1, "year"] as [number, "year"] },
-      },
-      includedItems: {
-        "pro-features": { quantity: 1 },
-        "cloud-storage-1tb": { quantity: 1 },
-        "priority-support": { quantity: 1 },
-        "api-calls": { quantity: 100000 },
-        "team-members": { quantity: 20 },
-        "custom-domain": { quantity: 3 },
-        "advanced-analytics": { quantity: 1 },
-        "sso": { quantity: 1 },
-      },
-    },
-    "enterprise-standard": {
-      displayName: "Enterprise Standard",
-      customerType: "team" as const,
-      groupId: "enterprise",
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "yearly": { USD: "2999.00", interval: [1, "year"] as [number, "year"] },
-      },
-      includedItems: {
-        "enterprise-features": { quantity: 1 },
-        "cloud-storage-unlimited": { quantity: 1 },
-        "dedicated-support": { quantity: 1 },
-        "api-calls": { quantity: 1000000 },
-        "team-members": { quantity: 100 },
-        "custom-domain": { quantity: 10 },
-        "advanced-analytics": { quantity: 1 },
-        "sso": { quantity: 1 },
-        "audit-logs": { quantity: 1 },
-        "sla": { quantity: 1 },
-      },
-    },
-    "enterprise-plus": {
-      displayName: "Enterprise Plus",
-      customerType: "custom" as const,
-      groupId: "enterprise",
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "custom": { USD: "0.00" },
-      },
-      includedItems: {
-        "enterprise-features": { quantity: 1 },
-        "cloud-storage-unlimited": { quantity: 1 },
-        "white-glove-support": { quantity: 1 },
-        "api-calls": { quantity: 999999 },
-        "team-members": { quantity: 999 },
-        "custom-domain": { quantity: 999 },
-        "advanced-analytics": { quantity: 1 },
-        "sso": { quantity: 1 },
-        "audit-logs": { quantity: 1 },
-        "sla": { quantity: 1 },
-        "custom-integrations": { quantity: 1 },
-        "dedicated-infrastructure": { quantity: 1 },
-      },
-    },
-    "extra-storage": {
-      displayName: "Extra Storage",
-      customerType: "user" as const,
-      groupId: "add-ons",
-      stackable: true,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "4.99", interval: [1, "month"] as [number, "month"] },
-      },
-      includedItems: {
-        "cloud-storage-50gb": { quantity: 1 },
-      },
-    },
-    "additional-api-calls": {
-      displayName: "API Call Pack",
-      customerType: "user" as const,
-      groupId: "add-ons",
-      stackable: true,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "9.99", interval: [1, "month"] as [number, "month"] },
-      },
-      includedItems: {
-        "api-calls": { quantity: 5000 },
-      },
-    },
-    "team-member-addon": {
-      displayName: "Extra Team Member",
-      customerType: "team" as const,
-      groupId: "add-ons",
-      stackable: true,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "14.99", interval: [1, "month"] as [number, "month"] },
-      },
-      includedItems: {
-        "team-members": { quantity: 1 },
-      },
-    },
-    "premium-support": {
-      displayName: "Premium Support",
-      customerType: "team" as const,
-      stackable: false,
-      serverOnly: false,
-      prices: {
-        "monthly": { USD: "299.00", interval: [1, "month"] as [number, "month"] },
-      },
-      includedItems: {
-        "24-7-support": { quantity: 1 },
-        "dedicated-account-manager": { quantity: 1 },
-      },
-    },
-  },
-  items: {
-    "basic-features": {
-      displayName: "Basic Features",
-      customerType: "user" as const,
-    },
-    "pro-features": {
-      displayName: "Professional Features",
-      customerType: "user" as const,
-    },
-    "enterprise-features": {
-      displayName: "Enterprise Features",
-      customerType: "team" as const,
-    },
-    "cloud-storage-5gb": {
-      displayName: "5GB Cloud Storage",
-      customerType: "user" as const,
-    },
-    "cloud-storage-10gb": {
-      displayName: "10GB Cloud Storage",
-      customerType: "user" as const,
-    },
-    "cloud-storage-50gb": {
-      displayName: "50GB Cloud Storage",
-      customerType: "user" as const,
-    },
-    "cloud-storage-100gb": {
-      displayName: "100GB Cloud Storage",
-      customerType: "user" as const,
-    },
-    "cloud-storage-1tb": {
-      displayName: "1TB Cloud Storage",
-      customerType: "team" as const,
-    },
-    "cloud-storage-unlimited": {
-      displayName: "Unlimited Cloud Storage",
-      customerType: "team" as const,
-    },
-    "email-support": {
-      displayName: "Email Support",
-      customerType: "user" as const,
-    },
-    "priority-support": {
-      displayName: "Priority Support",
-      customerType: "user" as const,
-    },
-    "dedicated-support": {
-      displayName: "Dedicated Support",
-      customerType: "team" as const,
-    },
-    "white-glove-support": {
-      displayName: "White Glove Support",
-      customerType: "custom" as const,
-    },
-    "24-7-support": {
-      displayName: "24/7 Phone Support",
-      customerType: "team" as const,
-    },
-    "api-calls": {
-      displayName: "API Calls",
-      customerType: "user" as const,
-    },
-    "team-members": {
-      displayName: "Team Members",
-      customerType: "team" as const,
-    },
-    "custom-domain": {
-      displayName: "Custom Domain",
-      customerType: "user" as const,
-    },
-    "advanced-analytics": {
-      displayName: "Advanced Analytics",
-      customerType: "team" as const,
-    },
-    "sso": {
-      displayName: "Single Sign-On (SSO)",
-      customerType: "team" as const,
-    },
-    "audit-logs": {
-      displayName: "Audit Logs",
-      customerType: "team" as const,
-    },
-    "sla": {
-      displayName: "Service Level Agreement",
-      customerType: "team" as const,
-    },
-    "custom-integrations": {
-      displayName: "Custom Integrations",
-      customerType: "custom" as const,
-    },
-    "dedicated-infrastructure": {
-      displayName: "Dedicated Infrastructure",
-      customerType: "custom" as const,
-    },
-    "dedicated-account-manager": {
-      displayName: "Dedicated Account Manager",
-      customerType: "team" as const,
-    },
-  },
-};
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
index 5dedd76670..1acf52153b 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
@@ -9,38 +9,37 @@ import { prettyPrintWithMagnitudes } from "@stackframe/stack-shared/dist/utils/n
 import { typedEntries } from "@stackframe/stack-shared/dist/utils/objects";
 import { stringCompare } from "@stackframe/stack-shared/dist/utils/strings";
 import {
-    ActionDialog,
-    Button,
-    Collapsible,
-    CollapsibleContent,
-    CollapsibleTrigger,
-    DropdownMenu,
-    DropdownMenuCheckboxItem,
-    DropdownMenuContent,
-    DropdownMenuItem,
-    DropdownMenuSeparator,
-    DropdownMenuTrigger,
-    Input,
-    Label,
-    Popover,
-    PopoverContent,
-    PopoverTrigger,
-    Select,
-    SelectContent,
-    SelectItem,
-    SelectTrigger,
-    SelectValue,
-    Separator,
-    SimpleTooltip,
-    Switch,
-    toast
+  ActionDialog,
+  Button,
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  Input,
+  Label,
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Separator,
+  SimpleTooltip,
+  Switch,
+  toast
 } from "@stackframe/stack-ui";
 import { Check, ChevronDown, ChevronsUpDown, Layers, MoreVertical, Pencil, PencilIcon, Plus, Puzzle, Server, Trash2, X } from "lucide-react";
 import { Fragment, useEffect, useId, useMemo, useRef, useState } from "react";
 import { IllustratedInfo } from "../../../../../../../components/illustrated-info";
 import { PageLayout } from "../../page-layout";
 import { useAdminApp } from "../../use-admin-app";
-import { DUMMY_PAYMENTS_CONFIG } from "./dummy-data";
 import { ItemDialog } from "./item-dialog";
 import { ProductDialog } from "./product-dialog";
 
@@ -741,7 +740,7 @@ function ProductCard({ id, activeType, product, allProducts, existingItems, onSa
 
   const itemsList = Object.entries(draft.includedItems);
 
-  const couldBeAddOnTo = allProducts.filter(o => o.product.groupId === draft.groupId && o.id !== id);
+  const couldBeAddOnTo = allProducts.filter(o => o.product.catalogId === draft.catalogId && o.id !== id);
   const isAddOnTo = allProducts.filter(o => draft.isAddOnTo && o.id in draft.isAddOnTo);
 
   const PRODUCT_TOGGLE_OPTIONS = [{
@@ -1045,14 +1044,14 @@ type CatalogViewProps = {
   onDeleteProduct: (id: string) => Promise<void>,
   onCreateNewItem: () => void,
   onOpenProductDetails: (product: Product) => void,
-  onSaveProductWithGroup: (groupId: string, productId: string, product: Product) => Promise<void>,
+  onSaveProductWithGroup: (catalogId: string, productId: string, product: Product) => Promise<void>,
 };
 
 function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, onDeleteProduct, onCreateNewItem, onOpenProductDetails, onSaveProductWithGroup }: CatalogViewProps) {
   const [activeType, setActiveType] = useState<'user' | 'team' | 'custom'>('user');
-  const [drafts, setDrafts] = useState<Array<{ key: string, groupId: string | undefined, product: Product }>>([]);
+  const [drafts, setDrafts] = useState<Array<{ key: string, catalogId: string | undefined, product: Product }>>([]);
   const [creatingGroupKey, setCreatingGroupKey] = useState<string | undefined>(undefined);
-  const [newGroupId, setNewGroupId] = useState("");
+  const [newCatalogId, setNewCatalogId] = useState("");
   const newGroupInputRef = useRef<HTMLInputElement | null>(null);
 
   const filtered = useMemo(() => {
@@ -1078,9 +1077,9 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
     prevActiveTypeRef.current = activeType;
     if (!tabChanged) return;
     if (!creatingGroupKey) return;
-    setDrafts(prev => prev.filter(d => d.groupId !== creatingGroupKey));
+    setDrafts(prev => prev.filter(d => d.catalogId !== creatingGroupKey));
     setCreatingGroupKey(undefined);
-    setNewGroupId("");
+    setNewCatalogId("");
   }, [activeType, creatingGroupKey]);
 
 
@@ -1098,7 +1097,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
     return id;
   };
 
-  const groupIdsToRender = useMemo(() => {
+  const catalogIdsToRender = useMemo(() => {
     const s = new Set<string | undefined>();
     filtered.forEach((_products, gid) => s.add(gid));
     const arr = Array.from(s.values());
@@ -1126,18 +1125,18 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
         </div>
       </div>
 
-      {groupIdsToRender.map((groupId) => {
-        const isNewGroupPlaceholder = !!creatingGroupKey && groupId === creatingGroupKey;
-        const products = isNewGroupPlaceholder ? [] : (filtered.get(groupId) || []);
-        const groupName = !isNewGroupPlaceholder ? (groupId ? ((groups[groupId].displayName || groupId)) : 'No catalog') : '';
+      {catalogIdsToRender.map((catalogId) => {
+        const isNewGroupPlaceholder = !!creatingGroupKey && catalogId === creatingGroupKey;
+        const products = isNewGroupPlaceholder ? [] : (filtered.get(catalogId) || []);
+        const groupName = !isNewGroupPlaceholder ? (catalogId ? ((groups[catalogId].displayName || catalogId)) : 'No catalog') : '';
         return (
-          <div key={groupId || 'ungrouped'}>
+          <div key={catalogId || 'ungrouped'}>
             {isNewGroupPlaceholder ? (
               <div className="mb-3 flex items-center gap-2">
                 <Input
                   ref={newGroupInputRef}
-                  value={newGroupId}
-                  onChange={(e) => setNewGroupId(e.target.value)}
+                  value={newCatalogId}
+                  onChange={(e) => setNewCatalogId(e.target.value)}
                   placeholder="catalog-id"
                   className="w-56"
                 />
@@ -1145,8 +1144,8 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                   className="h-8 w-8 inline-flex items-center justify-center rounded hover:bg-muted"
                   onClick={() => {
                     setCreatingGroupKey(undefined);
-                    setNewGroupId("");
-                    setDrafts(prev => prev.filter(d => d.groupId !== groupId));
+                    setNewCatalogId("");
+                    setDrafts(prev => prev.filter(d => d.catalogId !== catalogId));
                   }}
                   aria-label="Cancel new catalog"
                 >
@@ -1175,13 +1174,13 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                           ...srcProduct,
                           displayName: `${srcProduct.displayName || id} Copy`,
                         };
-                        setDrafts(prev => [...prev, { key, groupId, product: duplicated }]);
+                        setDrafts(prev => [...prev, { key, catalogId, product: duplicated }]);
                       }}
                       onCreateNewItem={onCreateNewItem}
                       onOpenDetails={(o) => onOpenProductDetails(o)}
                     />
                   ))}
-                  {drafts.filter(d => d.groupId === groupId && d.product.customerType === activeType).map((d) => (
+                  {drafts.filter(d => d.catalogId === catalogId && d.product.customerType === activeType).map((d) => (
                     <ProductCard
                       key={d.key}
                       id={d.key}
@@ -1193,7 +1192,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                       onSave={async (_ignoredId, product) => {
                         const newId = generateProductId('product');
                         if (isNewGroupPlaceholder) {
-                          const id = newGroupId.trim();
+                          const id = newCatalogId.trim();
                           if (!id) {
                             alert("Catalog ID is required");
                             return;
@@ -1206,10 +1205,10 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                             alert("Catalog ID already exists");
                             return;
                           }
-                          const productWithGroup: Product = { ...product, groupId: id };
+                          const productWithGroup: Product = { ...product, catalogId: id };
                           await onSaveProductWithGroup(id, newId, productWithGroup);
                           setCreatingGroupKey(undefined);
-                          setNewGroupId("");
+                          setNewCatalogId("");
                           setDrafts(prev => prev.filter(x => x.key !== d.key));
                           return;
                         }
@@ -1220,12 +1219,12 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                         setDrafts(prev => prev.filter(x => x.key !== d.key));
                         if (isNewGroupPlaceholder) {
                           setCreatingGroupKey(undefined);
-                          setNewGroupId("");
+                          setNewCatalogId("");
                         }
                       }}
                       onDuplicate={() => {
                         const cloneKey = `${d.key}-copy`;
-                        setDrafts(prev => ([...prev, { key: cloneKey, groupId: d.groupId, product: { ...d.product, displayName: `${d.product.displayName} Copy` } }]));
+                        setDrafts(prev => ([...prev, { key: cloneKey, catalogId: d.catalogId, product: { ...d.product, displayName: `${d.product.displayName} Copy` } }]));
                       }}
                       onCreateNewItem={onCreateNewItem}
                       onOpenDetails={(o) => onOpenProductDetails(o)}
@@ -1233,7 +1232,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                         setDrafts(prev => prev.filter(x => x.key !== d.key));
                         if (isNewGroupPlaceholder) {
                           setCreatingGroupKey(undefined);
-                          setNewGroupId("");
+                          setNewCatalogId("");
                         }
                       }}
                     />
@@ -1249,7 +1248,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                             const newProduct: Product = {
                               displayName: 'New Product',
                               customerType: activeType,
-                              groupId: groupId || undefined,
+                              catalogId: catalogId || undefined,
                               isAddOnTo: false,
                               stackable: false,
                               prices: {},
@@ -1257,7 +1256,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                               serverOnly: false,
                               freeTrial: undefined,
                             };
-                            setDrafts(prev => [...prev, { key, groupId, product: newProduct }]);
+                            setDrafts(prev => [...prev, { key, catalogId, product: newProduct }]);
                           }}
                         >
                           <Plus className="h-8 w-8" />
@@ -1282,12 +1281,12 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
             onClick={() => {
               const tempKey = `__new_catalog__${Date.now().toString(36).slice(2, 8)}`;
               setCreatingGroupKey(tempKey);
-              setNewGroupId("");
+              setNewCatalogId("");
               const draftKey = generateProductId("product");
               const newProduct: Product = {
                 displayName: 'New Product',
                 customerType: activeType,
-                groupId: tempKey,
+                catalogId: tempKey,
                 isAddOnTo: false,
                 stackable: false,
                 prices: {},
@@ -1295,7 +1294,7 @@ function CatalogView({ groupedProducts, groups, existingItems, onSaveProduct, on
                 serverOnly: false,
                 freeTrial: undefined,
               };
-              setDrafts(prev => [...prev, { key: draftKey, groupId: tempKey, product: newProduct }]);
+              setDrafts(prev => [...prev, { key: draftKey, catalogId: tempKey, product: newProduct }]);
             }}
           >
             <Plus className="h-8 w-8" />
@@ -1370,20 +1369,20 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   const config = project.useConfig();
   const [shouldUseDummyData, setShouldUseDummyData] = useState(false);
   const switchId = useId();
-  const paymentsConfig: CompleteConfig['payments'] = shouldUseDummyData ? (DUMMY_PAYMENTS_CONFIG as CompleteConfig['payments']) : config.payments;
+  const paymentsConfig: CompleteConfig['payments'] = config.payments;
 
 
-  // Group products by groupId and sort by customer type priority
+  // Group products by catalogId and sort by customer type priority
   const groupedProducts = useMemo(() => {
     const groups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
     // Group products
     for (const [id, product] of typedEntries(paymentsConfig.products)) {
-      const groupId = product.groupId;
-      if (!groups.has(groupId)) {
-        groups.set(groupId, []);
+      const catalogId = product.catalogId;
+      if (!groups.has(catalogId)) {
+        groups.set(catalogId, []);
       }
-      groups.get(groupId)!.push({ id, product });
+      groups.get(catalogId)!.push({ id, product });
     }
 
     // Sort products within each group by customer type, then by ID
@@ -1419,10 +1418,10 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     const sortedGroups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
     // Helper to get group priority
-    const getGroupPriority = (groupId: string | undefined) => {
-      if (!groupId) return 999; // Ungrouped always last
+    const getGroupPriority = (catalogId: string | undefined) => {
+      if (!catalogId) return 999; // Ungrouped always last
 
-      const products = groups.get(groupId) || [];
+      const products = groups.get(catalogId) || [];
       if (products.length === 0) return 999;
 
       // Get the most common customer type in the group
@@ -1447,8 +1446,8 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Rebuild map in sorted order
-    sortedEntries.forEach(([groupId, products]) => {
-      sortedGroups.set(groupId, products);
+    sortedEntries.forEach(([catalogId, products]) => {
+      sortedGroups.set(catalogId, products);
     });
 
     return sortedGroups;
@@ -1487,7 +1486,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   const existingProductsList = typedEntries(paymentsConfig.products).map(([id, product]) => ({
     id,
     displayName: product.displayName,
-    groupId: product.groupId,
+    catalogId: product.catalogId,
     customerType: product.customerType
   }));
 
@@ -1511,7 +1510,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   // If no products and items, show welcome screen instead of everything
   const innerContent = (
     <PageLayout
-      title='Product'
+      title='Products'
       actions={
         <div className="flex items-center gap-2 self-center">
           <Label htmlFor={switchId}>Pricing table</Label>
@@ -1523,7 +1522,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
       <div className="flex-1">
         <CatalogView
           groupedProducts={groupedProducts}
-          groups={paymentsConfig.groups}
+          groups={paymentsConfig.catalogs}
           existingItems={existingItemsList}
           onSaveProduct={handleInlineSaveProduct}
           onDeleteProduct={handleDeleteProduct}
@@ -1532,9 +1531,9 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
             setEditingProduct(product);
             setShowProductDialog(true);
           }}
-          onSaveProductWithGroup={async (groupId, productId, product) => {
+          onSaveProductWithGroup={async (catalogId, productId, product) => {
             await project.updateConfig({
-              [`payments.groups.${groupId}`]: {},
+              [`payments.catalogs.${catalogId}`]: {},
               [`payments.products.${productId}`]: product,
             });
             toast({ title: "Product created" });
@@ -1560,7 +1559,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
         onSave={async (productId, product) => await handleSaveProduct(productId, product)}
         editingProduct={editingProduct ?? undefined}
         existingProducts={existingProductsList}
-        existingGroups={Object.fromEntries(Object.entries(paymentsConfig.groups).map(([id, g]) => [id, { displayName: g.displayName || id }]))}
+        existingGroups={Object.fromEntries(Object.entries(paymentsConfig.catalogs).map(([id, g]) => [id, { displayName: g.displayName || id }]))}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
       />
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
index f8c023717d..7c8e794a85 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
@@ -12,7 +12,6 @@ import React, { ReactNode, useEffect, useId, useMemo, useRef, useState } from "r
 import { IllustratedInfo } from "../../../../../../../components/illustrated-info";
 import { PageLayout } from "../../page-layout";
 import { useAdminApp } from "../../use-admin-app";
-import { DUMMY_PAYMENTS_CONFIG } from "./dummy-data";
 import { ItemDialog } from "./item-dialog";
 import { ListSection } from "./list-section";
 import { ProductDialog } from "./product-dialog";
@@ -338,7 +337,7 @@ function ProductsList({
 
     const filtered = new Map<string | undefined, Array<{ id: string, product: any }>>();
 
-    groupedProducts.forEach((products, groupId) => {
+    groupedProducts.forEach((products, catalogId) => {
       const filteredProducts = products.filter(({ id, product }) => {
         const query = searchQuery.toLowerCase();
         return (
@@ -349,7 +348,7 @@ function ProductsList({
       });
 
       if (filteredProducts.length > 0) {
-        filtered.set(groupId, filteredProducts);
+        filtered.set(catalogId, filteredProducts);
       }
     });
 
@@ -369,12 +368,12 @@ function ProductsList({
       searchPlaceholder="Search products..."
     >
       <GroupedList>
-        {[...filteredGroupedProducts.entries()].map(([groupId, products]) => {
-          const group = groupId ? paymentsGroups[groupId] : undefined;
+        {[...filteredGroupedProducts.entries()].map(([catalogId, products]) => {
+          const group = catalogId ? paymentsGroups[catalogId] : undefined;
           const groupName = group?.displayName;
 
           return (
-            <ListGroup key={groupId || 'ungrouped'} title={groupId ? (groupName || groupId) : "Other"}>
+            <ListGroup key={catalogId || 'ungrouped'} title={catalogId ? (groupName || catalogId) : "Other"}>
               {products.map(({ id, product }) => {
                 const isEven = globalIndex % 2 === 0;
                 globalIndex++;
@@ -600,10 +599,9 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   const stackAdminApp = useAdminApp();
   const project = stackAdminApp.useProject();
   const config = project.useConfig();
-  const [shouldUseDummyData, setShouldUseDummyData] = useState(false);
   const switchId = useId();
 
-  const paymentsConfig = shouldUseDummyData ? DUMMY_PAYMENTS_CONFIG : config.payments;
+  const paymentsConfig = config.payments;
 
   // Refs for products and items
   const containerRef = useRef<HTMLDivElement>(null);
@@ -625,17 +623,17 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     return refs;
   }, [paymentsConfig.items]);
 
-  // Group products by groupId and sort by customer type priority
+  // Group products by catalogId and sort by customer type priority
   const groupedProducts = useMemo(() => {
     const groups = new Map<string | undefined, Array<{ id: string, product: typeof paymentsConfig.products[keyof typeof paymentsConfig.products] }>>();
 
     // Group products
     Object.entries(paymentsConfig.products).forEach(([id, product]: [string, any]) => {
-      const groupId = product.groupId;
-      if (!groups.has(groupId)) {
-        groups.set(groupId, []);
+      const catalogId = product.catalogId;
+      if (!groups.has(catalogId)) {
+        groups.set(catalogId, []);
       }
-      groups.get(groupId)!.push({ id, product });
+      groups.get(catalogId)!.push({ id, product });
     });
 
     // Sort products within each group by customer type, then by ID
@@ -671,10 +669,10 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     const sortedGroups = new Map<string | undefined, Array<{ id: string, product: Product }>>();
 
     // Helper to get group priority
-    const getGroupPriority = (groupId: string | undefined) => {
-      if (!groupId) return 999; // Ungrouped always last
+    const getGroupPriority = (catalogId: string | undefined) => {
+      if (!catalogId) return 999; // Ungrouped always last
 
-      const products = groups.get(groupId) || [];
+      const products = groups.get(catalogId) || [];
       if (products.length === 0) return 999;
 
       // Get the most common customer type in the group
@@ -699,8 +697,8 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
     });
 
     // Rebuild map in sorted order
-    sortedEntries.forEach(([groupId, products]) => {
-      sortedGroups.set(groupId, products);
+    sortedEntries.forEach(([catalogId, products]) => {
+      sortedGroups.set(catalogId, products);
     });
 
     return sortedGroups;
@@ -758,7 +756,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
   const existingProductsList = Object.entries(paymentsConfig.products).map(([id, product]: [string, any]) => ({
     id,
     displayName: product.displayName,
-    groupId: product.groupId,
+    catalogId: product.catalogId,
     customerType: product.customerType
   }));
 
@@ -824,7 +822,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
               <div className="flex-1">
                 <ProductsList
                   groupedProducts={groupedProducts}
-                  paymentsGroups={paymentsConfig.groups}
+                  paymentsGroups={paymentsConfig.catalogs}
                   hoveredItemId={hoveredItemId}
                   getConnectedProducts={getConnectedProducts}
                   productRefs={productRefs}
@@ -884,7 +882,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
             {activeTab === "products" ? (
               <ProductsList
                 groupedProducts={groupedProducts}
-                paymentsGroups={paymentsConfig.groups}
+                paymentsGroups={paymentsConfig.catalogs}
                 hoveredItemId={hoveredItemId}
                 getConnectedProducts={getConnectedProducts}
                 onProductMouseEnter={setHoveredProductId}
@@ -927,7 +925,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
         onSave={async (productId, product) => await handleSaveProduct(productId, product)}
         editingProduct={editingProduct}
         existingProducts={existingProductsList}
-        existingGroups={paymentsConfig.groups}
+        existingGroups={paymentsConfig.catalogs}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
       />
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
index 2a1f91b12c..d2e859dc59 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
@@ -22,7 +22,7 @@ type ProductDialogProps = {
   onSave: (productId: string, product: Product) => Promise<void>,
   editingProductId?: string,
   editingProduct?: Product,
-  existingProducts: Array<{ id: string, displayName: string, groupId?: string, customerType: string }>,
+  existingProducts: Array<{ id: string, displayName: string, catalogId?: string, customerType: string }>,
   existingGroups: Record<string, { displayName: string }>,
   existingItems: Array<{ id: string, displayName: string, customerType: string }>,
   onCreateNewItem?: () => void,
@@ -62,7 +62,7 @@ export function ProductDialog({
   const [productId, setProductId] = useState(editingProductId ?? "");
   const [displayName, setDisplayName] = useState(editingProduct?.displayName || "");
   const [customerType, setCustomerType] = useState<'user' | 'team' | 'custom'>(editingProduct?.customerType || 'user');
-  const [groupId, setGroupId] = useState(editingProduct?.groupId || "");
+  const [catalogId, setCatalogId] = useState(editingProduct?.catalogId || "");
   const [isAddOn, setIsAddOn] = useState(!!editingProduct?.isAddOnTo);
   const [isAddOnTo, setIsAddOnTo] = useState<string[]>(editingProduct?.isAddOnTo !== false ? Object.keys(editingProduct?.isAddOnTo || {}) : []);
   const [stackable, setStackable] = useState(editingProduct?.stackable || false);
@@ -135,7 +135,7 @@ export function ProductDialog({
 
     if (isAddOn && isAddOnTo.length > 0) {
       const addOnGroups = new Set(
-        isAddOnTo.map(productId => existingProducts.find(o => o.id === productId)?.groupId)
+        isAddOnTo.map(productId => existingProducts.find(o => o.id === productId)?.catalogId)
       );
       if (addOnGroups.size > 1) {
         newErrors.isAddOnTo = "All selected products must be in the same group";
@@ -166,7 +166,7 @@ export function ProductDialog({
     const product: Product = {
       displayName,
       customerType,
-      groupId: groupId || undefined,
+      catalogId: catalogId || undefined,
       isAddOnTo: isAddOn ? Object.fromEntries(isAddOnTo.map(id => [id, true])) : false,
       stackable,
       prices: freeByDefault ? "include-by-default" : prices,
@@ -186,7 +186,7 @@ export function ProductDialog({
       setProductId("");
       setDisplayName("");
       setCustomerType('user');
-      setGroupId("");
+      setCatalogId("");
       setIsAddOn(false);
       setIsAddOnTo([]);
       setStackable(false);
@@ -458,14 +458,14 @@ export function ProductDialog({
                   <div className="grid gap-2">
                     <Label htmlFor="group">Product Group (Optional)</Label>
                     <Select
-                      value={groupId || 'no-group'}
+                      value={catalogId || 'no-group'}
                       onValueChange={(value) => {
                         if (value === 'create-new') {
                           setShowGroupDialog(true);
                         } else if (value === 'no-group') {
-                          setGroupId('');
+                          setCatalogId('');
                         } else {
-                          setGroupId(value);
+                          setCatalogId(value);
                         }
                       }}
                     >
@@ -556,9 +556,9 @@ export function ProductDialog({
                                 />
                                 <Label htmlFor={`addon-to-${product.id}`} className="cursor-pointer text-sm">
                                   {product.displayName} ({product.id})
-                                  {product.groupId && (
+                                  {product.catalogId && (
                                     <span className="text-muted-foreground ml-1">
-                                      • {existingGroups[product.groupId].displayName || product.groupId}
+                                      • {existingGroups[product.catalogId].displayName || product.catalogId}
                                     </span>
                                   )}
                                 </Label>
@@ -774,7 +774,7 @@ export function ProductDialog({
         onOpenChange={setShowGroupDialog}
         onCreate={(group) => {
           // In a real app, you'd save the group to the backend
-          setGroupId(group.id);
+          setCatalogId(group.id);
           setShowGroupDialog(false);
         }}
       />
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
index 1067d5dc05..9d940c560e 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
@@ -158,7 +158,7 @@ it("should return client secret for one-time price even if a conflicting group s
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Test Group" } },
+      catalogs: { grp: { displayName: "Test Group" } },
       products: {
         subOffer: {
           displayName: "Sub Offer",
@@ -583,7 +583,7 @@ it("should update existing stripe subscription when switching offers within a gr
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: {
+      catalogs: {
         grp: { displayName: "Test Group" },
       },
       products: {
@@ -689,7 +689,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: {
+      catalogs: {
         grp: { displayName: "Test Group" },
       },
       products: {
@@ -844,7 +844,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Group" } },
+      catalogs: { grp: { displayName: "Group" } },
       products: {
         offerA: {
           displayName: "Offer A",
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
index 0c2faa7392..b1d7717e82 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--validate-code.test.ts
@@ -162,7 +162,7 @@ it("should include conflicting_group_offers when switching within the same group
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Group" } },
+      catalogs: { grp: { displayName: "Group" } },
       products: {
         offerA: {
           displayName: "Offer A",
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
index 7ac1e2b1bc..ba124cdd63 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
@@ -56,13 +56,8 @@ it("should properly create subscription", async ({ expect }) => {
       quantity: 1,
     },
   });
-  expect(response).toMatchInlineSnapshot(`
-    NiceResponse {
-      "status": 200,
-      "body": { "client_secret": "" },
-      "headers": Headers { <some fields may have been hidden> },
-    }
-  `);
+  expect(response.status).toBe(200);
+  expect(response.body).toEqual({ client_secret: expect.any(String) });
 });
 
 it("should return client secret for one-time price (no interval)", async ({ expect }) => {
@@ -169,13 +164,13 @@ it("should return client secret for one-time price even if a conflicting group s
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Test Group" } },
+      catalogs: { grp: { displayName: "Test Group" } },
       products: {
         subProduct: {
           displayName: "Sub Product",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: { monthly: { USD: "1000", interval: [1, "month"] } },
           includedItems: {},
@@ -184,7 +179,7 @@ it("should return client secret for one-time price even if a conflicting group s
           displayName: "One Time",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -594,7 +589,7 @@ it("should update existing stripe subscription when switching products within a
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: {
+      catalogs: {
         grp: { displayName: "Test Group" },
       },
       products: {
@@ -602,7 +597,7 @@ it("should update existing stripe subscription when switching products within a
           displayName: "Product A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -616,7 +611,7 @@ it("should update existing stripe subscription when switching products within a
           displayName: "Product B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -700,7 +695,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: {
+      catalogs: {
         grp: { displayName: "Test Group" },
       },
       products: {
@@ -708,7 +703,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Product A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -722,7 +717,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Product B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -855,13 +850,13 @@ it("should block one-time purchase in same group after prior one-time purchase i
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Group" } },
+      catalogs: { grp: { displayName: "Group" } },
       products: {
         productA: {
           displayName: "Product A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -870,7 +865,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
           displayName: "Product B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "700" } },
           includedItems: {},
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
index e68d93826a..6e4e4d726b 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/validate-code.test.ts
@@ -162,13 +162,13 @@ it("should include conflicting_products when switching within the same group", a
   await Payments.setup();
   await Project.updateConfig({
     payments: {
-      groups: { grp: { displayName: "Group" } },
+      catalogs: { grp: { displayName: "Group" } },
       products: {
         productA: {
           displayName: "Product A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: { monthly: { USD: "1000", interval: [1, "month"] } },
           includedItems: {},
@@ -177,7 +177,7 @@ it("should include conflicting_products when switching within the same group", a
           displayName: "Product B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: { monthly: { USD: "2000", interval: [1, "month"] } },
           includedItems: {},
diff --git a/docs/src/components/layouts/api/api-sidebar.tsx b/docs/src/components/layouts/api/api-sidebar.tsx
index 6f0cb11c75..c1666b7832 100644
--- a/docs/src/components/layouts/api/api-sidebar.tsx
+++ b/docs/src/components/layouts/api/api-sidebar.tsx
@@ -781,7 +781,7 @@ export function ApiSidebarContent({ pages = [] }: { pages?: PageData[] }) {
       organized[section] ??= {
         title: getApiSectionTitle(section),
         pages: [],
-        groups: {}
+        catalogs: {}
       };
 
       if (rest.length === 1) {
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index be66afec5d..8ea52a3921 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -4,11 +4,10 @@ import * as yup from "yup";
 import { DEFAULT_EMAIL_TEMPLATES, DEFAULT_EMAIL_THEMES, DEFAULT_EMAIL_THEME_ID } from "../helpers/emails";
 import * as schemaFields from "../schema-fields";
 import { productSchema, userSpecifiedIdSchema, yupBoolean, yupDate, yupMixed, yupNever, yupNumber, yupObject, yupRecord, yupString, yupTuple, yupUnion } from "../schema-fields";
-import { isShallowEqual } from "../utils/arrays";
 import { SUPPORTED_CURRENCIES } from "../utils/currency-constants";
 import { StackAssertionError } from "../utils/errors";
 import { allProviders } from "../utils/oauth";
-import { DeepFilterUndefined, DeepMerge, DeepRequiredOrUndefined, deleteKey, filterUndefined, get, has, isObjectLike, mapValues, set, typedAssign, typedEntries, typedFromEntries } from "../utils/objects";
+import { DeepFilterUndefined, DeepMerge, DeepRequiredOrUndefined, filterUndefined, get, has, isObjectLike, mapValues, set, typedAssign, typedEntries, typedFromEntries } from "../utils/objects";
 import { Result } from "../utils/results";
 import { CollapseObjectUnion, Expand, IntersectAll, IsUnion, typeAssert, typeAssertExtends, typeAssertIs } from "../utils/types";
 import { Config, NormalizationError, NormalizesTo, assertNormalized, getInvalidConfigReason, normalize } from "./format";
@@ -117,12 +116,12 @@ export const branchPaymentsSchema = yupObject({
   autoPay: yupObject({
     interval: schemaFields.dayIntervalSchema,
   }).optional(),
-  groups: yupRecord(
-    userSpecifiedIdSchema("groupId"),
+  catalogs: yupRecord(
+    userSpecifiedIdSchema("catalogId"),
     yupObject({
       displayName: yupString().optional(),
     }),
-  ).meta({ openapiField: { description: 'The groups that products can be in. All products in a group (besides add-ons) are mutually exclusive.', exampleValue: { "group-id": { displayName: "My Group" } } } }),
+  ).meta({ openapiField: { description: 'The catalogs that products can be in. All products in a catalog (besides add-ons) are mutually exclusive.', exampleValue: { "catalog-id": { displayName: "My Catalog" } } } }),
   products: yupRecord(
     userSpecifiedIdSchema("productId"),
     productSchema,
@@ -255,7 +254,7 @@ export function migrateConfigOverride(type: "project" | "branch" | "environment"
 
   // BEGIN 2025-07-28: emails.theme is now emails.selectedThemeId
   if (isBranchOrHigher) {
-    res = renameProperty(res, "emails.theme", "emails.selectedThemeId");
+    res = renameProperty(res, "emails.theme", "selectedThemeId");
   }
   // END
 
@@ -298,7 +297,19 @@ export function migrateConfigOverride(type: "project" | "branch" | "environment"
 
   // BEGIN 2025-09-23: payments.offers is now payments.products
   if (isBranchOrHigher) {
-    res = renameProperty(res, "payments.offers", "payments.products");
+    res = renameProperty(res, "payments.offers", "products");
+  }
+  // END
+
+  // BEGIN 2025-09-23: payments.groups is now payments.catalogs
+  if (isBranchOrHigher) {
+    res = renameProperty(res, "payments.groups", "catalogs");
+  }
+  // END
+
+  // BEGIN 2025-09-23: payments.products.*.groupId is now payments.products.*.catalogId
+  if (isBranchOrHigher) {
+    res = renameProperty(res, (p) => p.length === 4 && p[0] === "payments" && p[1] === "products" && p[3] === "groupId", (p) => "catalogId");
   }
   // END
 
@@ -340,32 +351,37 @@ import.meta.vitest?.test("mapProperty - basic property mapping", ({ expect }) =>
   expect(mapProperty({ a: { b: { c: 1 } } }, p => p.length === 3 && p[0] === "a" && p[1] === "b", (value) => value + 1)).toEqual({ a: { b: { c: 2 } } });
 });
 
-function renameProperty(obj: Record<string, any>, oldPath: string, newPath: string): any {
-  const oldKeyParts = oldPath.split(".");
-  const newKeyParts = newPath.split(".");
-  if (!isShallowEqual(oldKeyParts.slice(0, -1), newKeyParts.slice(0, -1))) throw new StackAssertionError(`oldPath and newPath must have the same prefix. Provided: ${oldPath} and ${newPath}`);
-
-  for (let i = 0; i < oldKeyParts.length; i++) {
-    const pathPrefix = oldKeyParts.slice(0, i).join(".");
-    const oldPathSuffix = oldKeyParts.slice(i).join(".");
-    const newPathSuffix = newKeyParts.slice(i).join(".");
-    if (has(obj, pathPrefix) && isObjectLike(get(obj, pathPrefix))) {
-      set(obj, pathPrefix, renameProperty(get(obj, pathPrefix), oldPathSuffix, newPathSuffix));
+function renameProperty(obj: Record<string, any>, oldPath: string | ((path: string[]) => boolean), newName: string | ((path: string[]) => string)): any {
+  const pathCond = typeof oldPath === "function" ? oldPath : (p: string[]) => p.join(".") === oldPath;
+  const pathMapper = typeof newName === "function" ? newName : (p: string[]) => (newName as string);
+
+  const res: Record<string, any> = Array.isArray(obj) ? [] : {};
+  for (const [key, originalValue] of typedEntries(obj)) {
+    const path = key.split(".");
+    const value = isObjectLike(originalValue) ? renameProperty(originalValue, p => pathCond([...path, ...p]), p => pathMapper([...path, ...p])) : originalValue;
+    if (pathCond(path)) {
+      const name = pathMapper(path);
+      if (name.includes(".")) throw new StackAssertionError(`newName must not contain a dot. Provided: ${name}`);
+      set(res, name, value);
+    } else {
+      set(res, key, value);
     }
   }
-  if (has(obj, oldPath)) {
-    set(obj, newPath, get(obj, oldPath));
-    deleteKey(obj, oldPath);
-  }
 
-  return obj;
+  return res;
 }
 import.meta.vitest?.test("renameProperty", ({ expect }) => {
   // Basic
   expect(renameProperty({ a: 1 }, "a", "b")).toEqual({ b: 1 });
-  expect(renameProperty({ b: { c: 1 } }, "b.c", "b.d")).toEqual({ b: { d: 1 } });
-  expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c", "a.b.d")).toEqual({ a: { b: { d: 1 } } });
-  expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c.d", "a.b.c.e")).toEqual({ a: { b: { c: 1 } } });
+  expect(renameProperty({ b: { c: 1 } }, "b.c", "d")).toEqual({ b: { d: 1 } });
+  expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 } } });
+  expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c.d", "e")).toEqual({ a: { b: { c: 1 } } });
+
+  // Functions
+  expect(renameProperty({ a: 1 }, (p) => p.length === 1 && p[0] === "a", (p) => "b")).toEqual({ b: 1 });
+  expect(renameProperty({ a: { b: { c: 1 } } }, (p) => p.length === 3 && p[0] === "a" && p[1] === "b" && p[2] === "c", (p) => "d")).toEqual({ a: { b: { d: 1 } } });
+  expect(renameProperty({ a: { b: { c: 1 } } }, (p) => false, (p) => "e")).toEqual({ a: { b: { c: 1 } } });
+  expect(renameProperty({ a: { b: { a: 1 } } }, (p) => p[p.length - 1] === "a", (p) => "c")).toEqual({ c: { b: { c: 1 } } });
 
   // Errors
   expect(() => renameProperty({ a: 1 }, "a", "b.c")).toThrow();
@@ -478,12 +494,12 @@ const organizationConfigDefaults = {
 
   payments: {
     autoPay: undefined,
-    groups: (key: string) => ({
+    catalogs: (key: string) => ({
       displayName: undefined,
     }),
     products: (key: string) => ({
       displayName: key,
-      groupId: undefined,
+      catalogId: undefined,
       customerType: "user",
       freeTrial: undefined,
       serverOnly: false,
diff --git a/packages/stack-shared/src/schema-fields.ts b/packages/stack-shared/src/schema-fields.ts
index 8e4687e34d..700733357e 100644
--- a/packages/stack-shared/src/schema-fields.ts
+++ b/packages/stack-shared/src/schema-fields.ts
@@ -568,7 +568,7 @@ export const priceOrIncludeByDefaultSchema = yupUnion(
 );
 export const productSchema = yupObject({
   displayName: yupString(),
-  groupId: userSpecifiedIdSchema("groupId").optional().meta({ openapiField: { description: 'The ID of the group this product belongs to. Within a group, all products are mutually exclusive unless they are an add-on to another product in the group.', exampleValue: 'group-id' } }),
+  catalogId: userSpecifiedIdSchema("catalogId").optional().meta({ openapiField: { description: 'The ID of the catalog this product belongs to. Within a catalog, all products are mutually exclusive unless they are an add-on to another product in the catalog.', exampleValue: 'catalog-id' } }),
   isAddOnTo: yupUnion(
     yupBoolean().isFalse(),
     yupRecord(

From e72849eb0d163215e404084b71ac6cab5067783b Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Wed, 24 Sep 2025 16:01:16 -0700
Subject: [PATCH 09/23] fixes

---
 packages/stack-shared/src/config/schema.ts | 23 +++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 8ea52a3921..4277d58581 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -358,14 +358,18 @@ function renameProperty(obj: Record<string, any>, oldPath: string | ((path: stri
   const res: Record<string, any> = Array.isArray(obj) ? [] : {};
   for (const [key, originalValue] of typedEntries(obj)) {
     const path = key.split(".");
-    const value = isObjectLike(originalValue) ? renameProperty(originalValue, p => pathCond([...path, ...p]), p => pathMapper([...path, ...p])) : originalValue;
-    if (pathCond(path)) {
-      const name = pathMapper(path);
-      if (name.includes(".")) throw new StackAssertionError(`newName must not contain a dot. Provided: ${name}`);
-      set(res, name, value);
-    } else {
-      set(res, key, value);
+
+    for (let i = 0; i < path.length; i++) {
+      const pathPrefix = path.slice(0, i + 1);
+      if (pathCond(pathPrefix)) {
+        const name = pathMapper(pathPrefix);
+        if (name.includes(".")) throw new StackAssertionError(`newName must not contain a dot. Provided: ${name}`);
+        path[i] = name;
+      }
     }
+
+    const value = isObjectLike(originalValue) ? renameProperty(originalValue, p => pathCond([...path, ...p]), p => pathMapper([...path, ...p])) : originalValue;
+    set(res, path.join("."), value);
   }
 
   return res;
@@ -376,6 +380,11 @@ import.meta.vitest?.test("renameProperty", ({ expect }) => {
   expect(renameProperty({ b: { c: 1 } }, "b.c", "d")).toEqual({ b: { d: 1 } });
   expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 } } });
   expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c.d", "e")).toEqual({ a: { b: { c: 1 } } });
+  expect(renameProperty({ a: { b: { c: 1 }, "b.c": 2 } }, "b.c", "d")).toEqual({ a: { b: { c: 1 }, "b.c": 2 } });
+  expect(renameProperty({ a: { "b.c.d": 2 } }, "a.b.c", "e")).toEqual({ a: { "b.e.d": 2 } });
+  expect(renameProperty({ a: { b: { c: 1 }, "b.c": 2 } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 }, "b.d": 2 } });
+  expect(renameProperty({ a: { b: { c: 1, d: 2 } } }, "a.b.c", "d")).toEqual({ a: { b: { d: 2 } } });
+  expect(renameProperty({ a: { b: { d: 2, c: 1 } } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 } } });
 
   // Functions
   expect(renameProperty({ a: 1 }, (p) => p.length === 1 && p[0] === "a", (p) => "b")).toEqual({ b: 1 });

From 6548cd498994097d92f348fc2e90ba9536fe0bcf Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Wed, 24 Sep 2025 16:08:48 -0700
Subject: [PATCH 10/23] --recent-first flag

---
 apps/backend/scripts/verify-data-integrity.ts | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/apps/backend/scripts/verify-data-integrity.ts b/apps/backend/scripts/verify-data-integrity.ts
index 2aeaef02a4..eda2aeea7d 100644
--- a/apps/backend/scripts/verify-data-integrity.ts
+++ b/apps/backend/scripts/verify-data-integrity.ts
@@ -76,6 +76,7 @@ async function main() {
   const shouldSaveOutput = flags.includes("--save-output");
   const shouldVerifyOutput = flags.includes("--verify-output");
   const shouldSkipNeon = flags.includes("--skip-neon");
+  const recentFirst = flags.includes("--recent-first");
 
 
   if (shouldSaveOutput) {
@@ -117,7 +118,9 @@ async function main() {
       displayName: true,
       description: true,
     },
-    orderBy: {
+    orderBy: recentFirst ? {
+      updatedAt: "desc",
+    } : {
       id: "asc",
     },
   });
@@ -126,7 +129,7 @@ async function main() {
     console.log(`Starting at project ${startAt}.`);
   }
 
-  const maxUsersPerProject = 10000;
+  const maxUsersPerProject = 100;
 
   const endAt = Math.min(startAt + count, projects.length);
   for (let i = startAt; i < endAt; i++) {
@@ -264,6 +267,7 @@ async function main() {
   console.log();
   console.log();
 }
+// eslint-disable-next-line no-restricted-syntax
 main().catch((...args) => {
   console.error();
   console.error();

From 687be846f0290df2d3f179aa81e978884a0cab4e Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Wed, 24 Sep 2025 19:34:20 -0700
Subject: [PATCH 11/23] Schema fuzzer

---
 apps/backend/src/lib/config.tsx               |   5 +-
 .../create-catalog-dialog.tsx}                |  28 +-
 .../included-item-dialog.tsx                  |   0
 .../{offers => products}/item-dialog.tsx      |   0
 .../payments/{offers => products}/layout.tsx  |   0
 .../{offers => products}/list-section.tsx     |   0
 .../page-client-catalogs-view.tsx             |   2 +-
 .../page-client-list-view.tsx                 |   2 +-
 .../{offers => products}/page-client.tsx      |   0
 .../payments/{offers => products}/page.tsx    |   0
 .../{offers => products}/price-dialog.tsx     |   0
 .../{offers => products}/product-dialog.tsx   |  56 ++--
 .../projects/[projectId]/sidebar-layout.tsx   |  62 ++--
 .../components/layouts/api/api-sidebar.tsx    |   2 +-
 .../src/config/schema-fuzzer.test.ts          | 313 ++++++++++++++++++
 packages/stack-shared/src/config/schema.ts    |  26 +-
 packages/stack-shared/src/schema-fields.ts    |   4 +-
 packages/stack-shared/src/utils/objects.tsx   |   4 +
 18 files changed, 417 insertions(+), 87 deletions(-)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers/create-group-dialog.tsx => products/create-catalog-dialog.tsx} (79%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/included-item-dialog.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/item-dialog.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/layout.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/list-section.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/page-client-catalogs-view.tsx (99%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/page-client-list-view.tsx (99%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/page-client.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/page.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/price-dialog.tsx (100%)
 rename apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/{offers => products}/product-dialog.tsx (95%)
 create mode 100644 packages/stack-shared/src/config/schema-fuzzer.test.ts

diff --git a/apps/backend/src/lib/config.tsx b/apps/backend/src/lib/config.tsx
index 93684e6af4..bc3da0e3d9 100644
--- a/apps/backend/src/lib/config.tsx
+++ b/apps/backend/src/lib/config.tsx
@@ -434,8 +434,9 @@ import.meta.vitest?.test('_validateConfigOverrideSchemaImpl(...)', async ({ expe
   expect(await validateConfigOverrideSchema(yupObject({ a: yupObject({ b: yupObject({ c: yupString().defined() }).defined() }).defined() }), { a: { b: {} } }, { "a.b": { c: 123 } })).toEqual(Result.error("[ERROR] a.b.c must be a `string` type, but the final value was: `123`."));
   expect(await validateConfigOverrideSchema(yupObject({ a: yupString().defined().oneOf(['b']) }), {}, { a: 'c' })).toEqual(Result.error("[ERROR] a must be one of the following values: b"));
   expect(await validateConfigOverrideSchema(yupObject({ a: yupString().defined() }), {}, {})).toEqual(Result.error("[WARNING] a must be defined"));
-  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), {}, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid for the schema.`));
-  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid for the schema.`));
+  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), {}, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a").`));
+  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a").`));
+  expect(await validateConfigOverrideSchema(yupObject({ a: yupObject({ c: yupString().optional() }) }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a.b").`));
   expect(await validateConfigOverrideSchema(schema1, {}, { a: 123 })).toEqual(Result.error('[ERROR] a must be a `string` type, but the final value was: `123`.'));
   expect(await validateConfigOverrideSchema(unionSchema, { a: { "time": "now" } }, { "a.morning": true })).toMatchInlineSnapshot(`
     {
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/create-catalog-dialog.tsx
similarity index 79%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/create-catalog-dialog.tsx
index 0608b879b4..297fc64f76 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/create-group-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/create-catalog-dialog.tsx
@@ -3,13 +3,13 @@
 import { Button, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, Input, Label, SimpleTooltip, Typography } from "@stackframe/stack-ui";
 import { useState } from "react";
 
-type CreateGroupDialogProps = {
+type CreateCatalogDialogProps = {
   open: boolean,
   onOpenChange: (open: boolean) => void,
-  onCreate: (group: { id: string, displayName: string }) => void,
+  onCreate: (catalog: { id: string, displayName: string }) => void,
 };
 
-export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupDialogProps) {
+export function CreateCatalogDialog({ open, onOpenChange, onCreate }: CreateCatalogDialogProps) {
   const [catalogId, setCatalogId] = useState("");
   const [displayName, setDisplayName] = useState("");
   const [errors, setErrors] = useState<{ id?: string, displayName?: string }>({});
@@ -17,11 +17,11 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
   const validateAndCreate = () => {
     const newErrors: { id?: string, displayName?: string } = {};
 
-    // Validate group ID
+    // Validate catalog ID
     if (!catalogId.trim()) {
-      newErrors.id = "Group ID is required";
+      newErrors.id = "Catalog ID is required";
     } else if (!/^[a-z0-9-]+$/.test(catalogId)) {
-      newErrors.id = "Group ID must contain only lowercase letters, numbers, and hyphens";
+      newErrors.id = "Catalog ID must contain only lowercase letters, numbers, and hyphens";
     }
 
     // Validate display name
@@ -54,21 +54,21 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
     <Dialog open={open} onOpenChange={handleClose}>
       <DialogContent className="sm:max-w-[425px]">
         <DialogHeader>
-          <DialogTitle>Create Product Group</DialogTitle>
+          <DialogTitle>Create Product Catalog</DialogTitle>
           <DialogDescription>
-            Product groups allow you to organize related products. Customers can only have one active product from each group at a time (except for add-ons).
+            Product catalogs allow you to organize related products. Customers can only have one active product from each catalog at a time (except for add-ons).
           </DialogDescription>
         </DialogHeader>
 
         <div className="grid gap-4 py-4">
           <div className="grid gap-2">
-            <Label htmlFor="group-id">
-              <SimpleTooltip tooltip="This is the unique identifier for your group, used in code">
-                Group ID
+            <Label htmlFor="catalog-id">
+              <SimpleTooltip tooltip="This is the unique identifier for your catalog, used in code">
+                Catalog ID
               </SimpleTooltip>
             </Label>
             <Input
-              id="group-id"
+              id="catalog-id"
               value={catalogId}
               onChange={(e) => {
                 setCatalogId(e.target.value);
@@ -86,7 +86,7 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
 
           <div className="grid gap-2">
             <Label htmlFor="display-name">
-              <SimpleTooltip tooltip="This is how the group will be displayed to users">
+              <SimpleTooltip tooltip="This is how the catalog will be displayed to users">
                 Display Name
               </SimpleTooltip>
             </Label>
@@ -113,7 +113,7 @@ export function CreateGroupDialog({ open, onOpenChange, onCreate }: CreateGroupD
             Cancel
           </Button>
           <Button onClick={validateAndCreate}>
-            Create Group
+            Create Catalog
           </Button>
         </DialogFooter>
       </DialogContent>
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/included-item-dialog.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/included-item-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/included-item-dialog.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/item-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/item-dialog.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/item-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/item-dialog.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/layout.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/layout.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/layout.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/layout.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/list-section.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/list-section.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/list-section.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/list-section.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-catalogs-view.tsx
similarity index 99%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-catalogs-view.tsx
index 1acf52153b..81c6599d44 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-catalogs-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-catalogs-view.tsx
@@ -1559,7 +1559,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
         onSave={async (productId, product) => await handleSaveProduct(productId, product)}
         editingProduct={editingProduct ?? undefined}
         existingProducts={existingProductsList}
-        existingGroups={Object.fromEntries(Object.entries(paymentsConfig.catalogs).map(([id, g]) => [id, { displayName: g.displayName || id }]))}
+        existingCatalogs={Object.fromEntries(Object.entries(paymentsConfig.catalogs).map(([id, g]) => [id, { displayName: g.displayName || id }]))}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
       />
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-list-view.tsx
similarity index 99%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-list-view.tsx
index 7c8e794a85..172578c670 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client-list-view.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client-list-view.tsx
@@ -925,7 +925,7 @@ export default function PageClient({ onViewChange }: { onViewChange: (view: "lis
         onSave={async (productId, product) => await handleSaveProduct(productId, product)}
         editingProduct={editingProduct}
         existingProducts={existingProductsList}
-        existingGroups={paymentsConfig.catalogs}
+        existingCatalogs={paymentsConfig.catalogs}
         existingItems={existingItemsList}
         onCreateNewItem={handleCreateItem}
       />
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page-client.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page-client.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/page.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/page.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/price-dialog.tsx
similarity index 100%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/price-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/price-dialog.tsx
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/product-dialog.tsx
similarity index 95%
rename from apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
rename to apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/product-dialog.tsx
index d2e859dc59..8121f540e9 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/offers/product-dialog.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/payments/products/product-dialog.tsx
@@ -5,7 +5,7 @@ import { CompleteConfig } from "@stackframe/stack-shared/dist/config/schema";
 import { Button, Card, CardDescription, CardHeader, CardTitle, Checkbox, Dialog, DialogContent, DialogFooter, DialogTitle, Input, Label, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, Typography } from "@stackframe/stack-ui";
 import { ArrowLeft, ArrowRight, CreditCard, Package, Plus, Repeat, Trash2 } from "lucide-react";
 import { useState } from "react";
-import { CreateGroupDialog } from "./create-group-dialog";
+import { CreateCatalogDialog } from "./create-catalog-dialog";
 import { IncludedItemDialog } from "./included-item-dialog";
 import { ListSection } from "./list-section";
 import { PriceDialog } from "./price-dialog";
@@ -23,7 +23,7 @@ type ProductDialogProps = {
   editingProductId?: string,
   editingProduct?: Product,
   existingProducts: Array<{ id: string, displayName: string, catalogId?: string, customerType: string }>,
-  existingGroups: Record<string, { displayName: string }>,
+  existingCatalogs: Record<string, { displayName?: string }>,
   existingItems: Array<{ id: string, displayName: string, customerType: string }>,
   onCreateNewItem?: () => void,
 };
@@ -52,7 +52,7 @@ export function ProductDialog({
   editingProductId,
   editingProduct,
   existingProducts,
-  existingGroups,
+  existingCatalogs,
   existingItems,
   onCreateNewItem
 }: ProductDialogProps) {
@@ -73,7 +73,7 @@ export function ProductDialog({
   const [serverOnly, setServerOnly] = useState(editingProduct?.serverOnly || false);
 
   // Dialog states
-  const [showGroupDialog, setShowGroupDialog] = useState(false);
+  const [showCatalogDialog, setShowCatalogDialog] = useState(false);
   const [showPriceDialog, setShowPriceDialog] = useState(false);
   const [editingPriceId, setEditingPriceId] = useState<string | undefined>();
   const [showItemDialog, setShowItemDialog] = useState(false);
@@ -134,11 +134,11 @@ export function ProductDialog({
     }
 
     if (isAddOn && isAddOnTo.length > 0) {
-      const addOnGroups = new Set(
+      const addOnCatalogs = new Set(
         isAddOnTo.map(productId => existingProducts.find(o => o.id === productId)?.catalogId)
       );
-      if (addOnGroups.size > 1) {
-        newErrors.isAddOnTo = "All selected products must be in the same group";
+      if (addOnCatalogs.size > 1) {
+        newErrors.isAddOnTo = "All selected products must be in the same catalog";
       }
     }
 
@@ -454,15 +454,15 @@ export function ProductDialog({
                     </Typography>
                   </div>
 
-                  {/* Group */}
+                  {/* Catalog */}
                   <div className="grid gap-2">
-                    <Label htmlFor="group">Product Group (Optional)</Label>
+                    <Label htmlFor="catalog">Product Catalog (Optional)</Label>
                     <Select
-                      value={catalogId || 'no-group'}
+                      value={catalogId || 'no-catalog'}
                       onValueChange={(value) => {
                         if (value === 'create-new') {
-                          setShowGroupDialog(true);
-                        } else if (value === 'no-group') {
+                          setShowCatalogDialog(true);
+                        } else if (value === 'no-catalog') {
                           setCatalogId('');
                         } else {
                           setCatalogId(value);
@@ -470,22 +470,22 @@ export function ProductDialog({
                       }}
                     >
                       <SelectTrigger>
-                        <SelectValue placeholder="No group" />
+                        <SelectValue placeholder="No catalog" />
                       </SelectTrigger>
                       <SelectContent>
-                        <SelectItem value="no-group">No group</SelectItem>
-                        {Object.entries(existingGroups).map(([id, group]) => (
+                        <SelectItem value="no-catalog">No catalog</SelectItem>
+                        {Object.entries(existingCatalogs).map(([id, catalog]) => (
                           <SelectItem key={id} value={id}>
-                            {group.displayName || id}
+                            {catalog.displayName || id}
                           </SelectItem>
                         ))}
                         <SelectItem value="create-new">
-                          <span className="text-primary">+ Create new group</span>
+                          <span className="text-primary">+ Create new catalog</span>
                         </SelectItem>
                       </SelectContent>
                     </Select>
                     <Typography type="label" className="text-muted-foreground">
-                      Customers can only have one active product per group (except add-ons)
+                      Customers can only have one active product per catalog (except add-ons)
                     </Typography>
                   </div>
 
@@ -558,7 +558,7 @@ export function ProductDialog({
                                   {product.displayName} ({product.id})
                                   {product.catalogId && (
                                     <span className="text-muted-foreground ml-1">
-                                      • {existingGroups[product.catalogId].displayName || product.catalogId}
+                                      • {existingCatalogs[product.catalogId].displayName || product.catalogId}
                                     </span>
                                   )}
                                 </Label>
@@ -634,7 +634,7 @@ export function ProductDialog({
                             {Object.entries(prices).map(([id, price]) => (
                               <div
                                 key={id}
-                                className="px-3 py-3 hover:bg-muted/50 flex items-center justify-between group transition-colors"
+                                className="px-3 py-3 hover:bg-muted/50 flex items-center justify-between catalog transition-colors"
                               >
                                 <div>
                                   <div className="font-medium">{formatPriceDisplay(price)}</div>
@@ -703,7 +703,7 @@ export function ProductDialog({
                         {Object.entries(includedItems).map(([itemId, item]) => (
                           <div
                             key={itemId}
-                            className="px-3 py-3 hover:bg-muted/50 flex items-center justify-between group transition-colors"
+                            className="px-3 py-3 hover:bg-muted/50 flex items-center justify-between catalog transition-colors"
                           >
                             <div>
                               <div className="font-medium">{getItemDisplay(itemId, item)}</div>
@@ -769,13 +769,13 @@ export function ProductDialog({
       </Dialog>
 
       {/* Sub-dialogs */}
-      <CreateGroupDialog
-        open={showGroupDialog}
-        onOpenChange={setShowGroupDialog}
-        onCreate={(group) => {
-          // In a real app, you'd save the group to the backend
-          setCatalogId(group.id);
-          setShowGroupDialog(false);
+      <CreateCatalogDialog
+        open={showCatalogDialog}
+        onOpenChange={setShowCatalogDialog}
+        onCreate={(catalog) => {
+          // In a real app, you'd save the catalog to the backend
+          setCatalogId(catalog.id);
+          setShowCatalogDialog(false);
         }}
       />
 
diff --git a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
index 24949858d5..021876f3d6 100644
--- a/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
+++ b/apps/dashboard/src/app/(main)/(protected)/projects/[projectId]/sidebar-layout.tsx
@@ -9,39 +9,39 @@ import { getPublicEnvVar } from '@/lib/env';
 import { cn, devFeaturesEnabledForProject } from "@/lib/utils";
 import { AdminProject, UserButton, useUser } from "@stackframe/stack";
 import {
-    Breadcrumb,
-    BreadcrumbItem,
-    BreadcrumbList,
-    BreadcrumbPage,
-    BreadcrumbSeparator,
-
-    Sheet,
-    SheetContent,
-    SheetTitle,
-    SheetTrigger,
-    Typography,
-    buttonVariants
+  Breadcrumb,
+  BreadcrumbItem,
+  BreadcrumbList,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+
+  Sheet,
+  SheetContent,
+  SheetTitle,
+  SheetTrigger,
+  Typography,
+  buttonVariants
 } from "@stackframe/stack-ui";
 import {
-    Book,
-    CreditCard,
-    FilePen,
-    Globe,
-    KeyRound,
-    LayoutTemplate,
-    Link as LinkIcon,
-    LockKeyhole,
-    LucideIcon,
-    Mail,
-    Menu,
-    Palette,
-    Receipt,
-    Settings,
-    Settings2,
-    ShieldEllipsis,
-    User,
-    Users,
-    Webhook,
+  Book,
+  CreditCard,
+  FilePen,
+  Globe,
+  KeyRound,
+  LayoutTemplate,
+  Link as LinkIcon,
+  LockKeyhole,
+  LucideIcon,
+  Mail,
+  Menu,
+  Palette,
+  Receipt,
+  Settings,
+  Settings2,
+  ShieldEllipsis,
+  User,
+  Users,
+  Webhook,
 } from "lucide-react";
 import { useTheme } from "next-themes";
 import { usePathname } from "next/navigation";
diff --git a/docs/src/components/layouts/api/api-sidebar.tsx b/docs/src/components/layouts/api/api-sidebar.tsx
index c1666b7832..6f0cb11c75 100644
--- a/docs/src/components/layouts/api/api-sidebar.tsx
+++ b/docs/src/components/layouts/api/api-sidebar.tsx
@@ -781,7 +781,7 @@ export function ApiSidebarContent({ pages = [] }: { pages?: PageData[] }) {
       organized[section] ??= {
         title: getApiSectionTitle(section),
         pages: [],
-        catalogs: {}
+        groups: {}
       };
 
       if (rest.length === 1) {
diff --git a/packages/stack-shared/src/config/schema-fuzzer.test.ts b/packages/stack-shared/src/config/schema-fuzzer.test.ts
new file mode 100644
index 0000000000..485358077d
--- /dev/null
+++ b/packages/stack-shared/src/config/schema-fuzzer.test.ts
@@ -0,0 +1,313 @@
+import { SUPPORTED_CURRENCIES } from "../utils/currency-constants";
+import { StackAssertionError } from "../utils/errors";
+import { getOrUndefined, isObjectLike, set, typedEntries, typedFromEntries } from "../utils/objects";
+import { nicify } from "../utils/strings";
+import { normalize, override } from "./format";
+import { BranchConfigNormalizedOverride, EnvironmentConfigNormalizedOverride, OrganizationConfigNormalizedOverride, ProjectConfigNormalizedOverride, applyBranchDefaults, applyEnvironmentDefaults, applyOrganizationDefaults, applyProjectDefaults, assertNoConfigOverrideErrors, branchConfigSchema, environmentConfigSchema, migrateConfigOverride, organizationConfigSchema, projectConfigSchema, sanitizeBranchConfig, sanitizeEnvironmentConfig, sanitizeOrganizationConfig, sanitizeProjectConfig } from "./schema";
+
+type FuzzerConfig<T> = ReadonlyArray<T extends object ? ([T] extends [any[]] ? { readonly [K in keyof T]: FuzzerConfig<T[K]> } : Required<{
+  [K in keyof T]: FuzzerConfig<T[K]>;
+}> & Record<string, FuzzerConfig<any>>) : T>;
+
+const projectSchemaFuzzerConfig = [{
+  sourceOfTruth: [{
+    type: ["hosted", "neon", "postgres"],
+    connectionString: ["", "postgres://user:password@host:port/database", "THIS IS A STRING LOLOL"],
+    connectionStrings: [{
+      "": ["", "THIS IS A CONNECTION STRING OR SO"],
+      "123-some-branch-id": ["", "THIS IS A CONNECTION STRING OR SO"],
+    }],
+  }],
+}] satisfies FuzzerConfig<ProjectConfigNormalizedOverride>;
+
+const branchSchemaFuzzerConfig = [{
+  apiKeys: [{
+    enabled: [{
+      team: [true, false],
+      user: [true, false],
+    }],
+  }],
+  auth: [{
+    allowSignUp: [true, false],
+    password: [{
+      allowSignIn: [true, false],
+    }],
+    otp: [{
+      allowSignIn: [true, false],
+    }],
+    passkey: [{
+      allowSignIn: [true, false],
+    }],
+    oauth: [{
+      accountMergeStrategy: ["link_method", "raise_error", "allow_duplicates"],
+      providers: [{
+        "google": [{
+          type: ["google", "github", "x"] as const,
+          allowSignIn: [true, false],
+          allowConnectedAccounts: [true, false],
+          isShared: [true, false],
+          clientId: ["some-client-id"],
+          facebookConfigId: ["some-facebook-config-id"],
+          microsoftTenantId: ["some-microsoft-tenant-id"],
+        }],
+      }],
+    }],
+  }],
+  dataVault: [{
+    stores: [{
+      "some-store-id": [{
+        displayName: ["Some Store", "Some Other Store"],
+      }],
+      "some-other-store-id": [{
+        displayName: ["Some Store", "Some Other Store"],
+      }],
+    }],
+  }],
+  payments: [{
+    autoPay: [{
+      interval: [[[0, 1, -3, 100, 0.333, Infinity], ["day", "week", "month", "year"]]] as const,
+    }],
+    catalogs: [{
+      "some-catalog-id": [{
+        displayName: ["Some Catalog", "Some Other Catalog"],
+      }],
+    }],
+    groups: [{
+      "some-catalog-id": [{
+        displayName: ["Some Catalog", "Some Other Catalog"],
+      }],
+    }],
+    items: [{
+      "some-item-id": [{
+        customerType: ["user", "team", "custom"] as const,
+        displayName: ["Some Item", "Some Other Item"],
+      }],
+    }],
+    products: [{
+      "some-product-id": [{
+        displayName: ["Some Product", "Some Other Product"],
+        customerType: ["user", "team", "custom"] as const,
+        freeTrial: [[[0, 1, -3, 100, 0.333, Infinity], ["day", "week", "month", "year"]]] as const,
+        serverOnly: [true, false],
+        stackable: [true, false],
+        catalogId: ["some-catalog-id", "some-other-catalog-id"],
+        groupId: ["some-catalog-id", "some-other-catalog-id"],  // ensure migration works
+        isAddOnTo: [false, { "some-product-id": [true], "some-other-product-id": [true] }] as const,
+        prices: ["include-by-default" as "include-by-default", {
+          "some-price-id": [{
+            ...typedFromEntries(SUPPORTED_CURRENCIES.map(currency => [currency.code, ["100_00", "not a number", "Infinity", "0"]])),
+            interval: [[[0, 1, -3, 100, 0.333, Infinity], ["day", "week", "month", "year"]]] as const,
+            serverOnly: [true, false],
+            freeTrial: [[[0, 1, -3, 100, 0.333, Infinity], ["day", "week", "month", "year"]]] as const,
+          }],
+        }],
+        includedItems: [{
+          "some-item-id": [{
+            quantity: [0, 1, -3, 100, 0.333, Infinity],
+            repeat: ["never", [[0, 1, -3, 100, 0.333, Infinity], ["day", "week", "month", "year"]]] as const,
+            expires: ["never", "when-purchase-expires", "when-repeated"] as const,
+          }],
+        }],
+      }],
+    }],
+  }],
+  emails: [{
+    themes: [{
+      "some-theme-id": [{
+        displayName: ["Some Theme", "Some Other Theme"],
+        tsxSource: ["", "some typescript source code"],
+      }],
+    }],
+    selectedThemeId: ["some-theme-id", "some-other-theme-id"],
+    templates: [{
+      "12345678-90ab-cdef-1234-567890abcdef": [{
+        themeId: ["some-theme-id", "some-other-theme-id"],
+        displayName: ["Some Template", "Some Other Template"],
+        tsxSource: ["", "some typescript source code"],
+      }],
+    }],
+  }],
+  workflows: [{
+    availableWorkflows: [{
+      "some-workflow-id": [{
+        displayName: ["Some Workflow", "Some Other Workflow"],
+        tsSource: ["", "some typescript source code"],
+        enabled: [true, false],
+      }],
+    }],
+  }],
+  teams: [{
+    createPersonalTeamOnSignUp: [true, false],
+    allowClientTeamCreation: [true, false],
+  }],
+  users: [{
+    allowClientUserDeletion: [true, false],
+  }],
+  rbac: [{
+    permissions: [{
+      "$some_permission_id": [{
+        containedPermissionIds: [{
+          "some_permission_id": [true],
+          "$some_other_permission_id": [true],
+        }] as const,
+        description: ["Some Permission", "Some Other Permission"],
+        scope: ["team", "project"] as const,
+      }],
+    }],
+    defaultPermissions: [{
+      teamCreator: [{
+        "some_permission_id": [true],
+        "$some_other_permission_id": [true],
+      }] as const,
+      teamMember: [{
+        "some_permission_id": [true],
+        "$some_other_permission_id": [true],
+      }] as const,
+      signUp: [{
+        "some_permission_id": [true],
+        "$some_other_permission_id": [true],
+      }] as const,
+    }],
+  }],
+  domains: [{
+    allowLocalhost: [true, false],
+  }],
+}] satisfies FuzzerConfig<BranchConfigNormalizedOverride>;
+
+const environmentSchemaFuzzerConfig = [{
+  ...branchSchemaFuzzerConfig[0],
+  auth: [{
+    ...branchSchemaFuzzerConfig[0].auth[0],
+    oauth: [{
+      ...branchSchemaFuzzerConfig[0].auth[0].oauth[0],
+      providers: [typedFromEntries(typedEntries(branchSchemaFuzzerConfig[0].auth[0].oauth[0].providers[0]).map(([key, value]) => [key, [{
+        ...value[0],
+        clientSecret: ["some-client-secret"],
+      }]]))] as const,
+    }],
+  }],
+  domains: [{
+    ...branchSchemaFuzzerConfig[0].domains[0],
+    trustedDomains: [{
+      "some-domain-id": [{
+        baseUrl: ["https://example.com/something-here"],
+        handlerPath: ["/something-here"],
+      }],
+    }],
+  }],
+  emails: [{
+    ...branchSchemaFuzzerConfig[0].emails[0],
+    server: [{
+      isShared: [true, false],
+      provider: ["resend", "smtp"] as const,
+      host: ["example.com", "://super weird host that's not valid"],
+      port: [1234, 0.12543, -100, Infinity],
+      username: ["some-username", "some username with a space"],
+      password: ["some-password", "some password with a space"],
+      senderName: ["Some Sender"],
+      senderEmail: ["some-sender@example.com", "some invalid email"],
+    }],
+  }],
+}] satisfies FuzzerConfig<EnvironmentConfigNormalizedOverride>;
+
+const organizationSchemaFuzzerConfig = environmentSchemaFuzzerConfig satisfies FuzzerConfig<OrganizationConfigNormalizedOverride>;
+
+function setDeep<T>(obj: T, path: string[], value: any) {
+  if (typeof obj !== "object" || obj === null) return obj;
+
+  if (path.length === 0) {
+    throw new Error("Path is empty");
+  } else if (path.length === 1) {
+    set(obj as any, path[0], value);
+  } else {
+    const [key, ...rest] = path;
+    setDeep(getOrUndefined(obj as any, key), rest, value);
+  }
+}
+
+function createFuzzerInput<T>(config: FuzzerConfig<T>, progress: number): T {
+  const createShouldRandom = (strength: number) => {
+    const chance = Math.random() * strength * 1.2 - 0.1;
+    return () => Math.random() < chance;
+  };
+  const createShouldObjectDependent = (strength: number) => {
+    const objectChance = Math.random() * strength * 1.2 - 0.1;
+    const primitiveChance = Math.random() * strength * 1.2 - 0.1;
+    return (v: any) => Math.random() * Math.random() < (isObjectLike(v) ? objectChance : primitiveChance);
+  };
+
+  const shouldKeep = createShouldObjectDependent(progress * 1);
+  const shouldMakeNested = createShouldObjectDependent(1.25);
+  const shouldNull = createShouldRandom(0.25);
+
+  let res: any;
+  const recurse = <U>(path: string[], config: FuzzerConfig<U>, force: boolean) => {
+    let subConfig: any = config[Math.floor(Math.random() * config.length)];
+    let value = typeof subConfig === "object" && subConfig !== null ? (Array.isArray(subConfig) ? [] : {}) : subConfig;
+    if (path.length === 0) {
+      res = value;
+    } else {
+      if (shouldKeep(value)) {
+        if (shouldNull()) value = null;
+        if (path.length >= 2 && shouldMakeNested(value)) {
+          setDeep(res, path, value);
+        } else {
+          setDeep(res, [path.join(".")], value);
+        }
+      }
+    }
+    if (typeof subConfig === "object" && subConfig !== null) {
+      for (const key of Object.keys(subConfig)) {
+        recurse([...path, key], subConfig[key], Array.isArray(subConfig));
+      }
+    }
+  };
+  recurse<T>([], config, false);
+  return res;
+}
+
+import.meta.vitest?.test("fuzz schemas", async ({ expect }) => {
+  const totalIterations = 10;
+  for (let i = 0; i < totalIterations; i++) {
+    const projectInput = createFuzzerInput<ProjectConfigNormalizedOverride>(projectSchemaFuzzerConfig, i / totalIterations);
+    const branchInput = createFuzzerInput<BranchConfigNormalizedOverride>(branchSchemaFuzzerConfig, i / totalIterations);
+    const environmentInput = createFuzzerInput<EnvironmentConfigNormalizedOverride>(environmentSchemaFuzzerConfig, i / totalIterations);
+    const organizationInput = createFuzzerInput<OrganizationConfigNormalizedOverride>(organizationSchemaFuzzerConfig, i / totalIterations);
+
+    try {
+      const projectMigrated = migrateConfigOverride("project", projectInput);
+      await assertNoConfigOverrideErrors(projectConfigSchema, projectMigrated);
+      const projectOverridden = override({}, projectMigrated);
+      await sanitizeProjectConfig(normalize(applyProjectDefaults(projectOverridden), { onDotIntoNonObject: "ignore" }) as any);
+
+      const branchMigrated = migrateConfigOverride("branch", branchInput);
+      await assertNoConfigOverrideErrors(branchConfigSchema, branchMigrated);
+      const branchOverridden = override(projectOverridden, branchMigrated);
+      await sanitizeBranchConfig(normalize(applyBranchDefaults(branchOverridden), { onDotIntoNonObject: "ignore" }) as any);
+
+      const environmentMigrated = migrateConfigOverride("environment", environmentInput);
+      await assertNoConfigOverrideErrors(environmentConfigSchema, environmentMigrated);
+      const environmentOverridden = override(branchOverridden, environmentMigrated);
+      await sanitizeEnvironmentConfig(normalize(applyEnvironmentDefaults(environmentOverridden), { onDotIntoNonObject: "ignore" }) as any);
+
+      const organizationMigrated = migrateConfigOverride("organization", organizationInput);
+      await assertNoConfigOverrideErrors(organizationConfigSchema, organizationMigrated);
+      const organizationOverridden = override(environmentOverridden, organizationMigrated);
+      await sanitizeOrganizationConfig(normalize(applyOrganizationDefaults(organizationOverridden), { onDotIntoNonObject: "ignore" }) as any);
+
+    } catch (e) {
+      const data = {
+        cause: e,
+        inputs: {
+          projectInput,
+          branchInput,
+          environmentInput,
+          organizationInput,
+        },
+      } as const;
+      console.error("Failed to fuzz schema in iteration ${i}/${totalIterations}!", nicify(data));
+      throw new StackAssertionError(`Error in iteration ${i}/${totalIterations} of schema fuzz: ${e}`, { cause: e });
+    }
+  }
+});
+
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 4277d58581..18282f124f 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -590,20 +590,21 @@ function applyDefaults<D extends object | ((key: string) => unknown), C extends
     let currentRes: any = res;
     for (const [index, part] of keyParts.entries()) {
       baseValue = has(baseValue, part) ? get(baseValue, part) : (typeof baseValue === 'function' ? (baseValue as any)(part) : undefined);
-      if (baseValue === undefined || !isObjectLike(baseValue)) {
+      if (baseValue === undefined || (!isObjectLike(baseValue) && mergeValue !== null)) {
         set(res, key, mergeValue);
         continue outer;
       }
       if (!has(currentRes, part)) set(currentRes, part, deepReplaceFunctionsWithObjects(baseValue) as never);
       currentRes = get(currentRes, part);
     }
-    set(res, key, isObjectLike(mergeValue) ? applyDefaults(baseValue, mergeValue) : mergeValue);
+    set(res, key, mergeValue === null ? baseValue : isObjectLike(mergeValue) ? applyDefaults(baseValue, mergeValue) : mergeValue);
   }
   return res as any;
 }
 import.meta.vitest?.test("applyDefaults", ({ expect }) => {
   // Basic
   expect(applyDefaults({ a: 1 }, { a: 2 })).toEqual({ a: 2 });
+  expect(applyDefaults({ a: 1 }, { a: null })).toEqual({ a: 1 });
   expect(applyDefaults({}, { a: 1 })).toEqual({ a: 1 });
   expect(applyDefaults({ a: { b: 1 } }, { a: { b: 2 } })).toEqual({ a: { b: 2 } });
   expect(applyDefaults({ a: { b: 1 } }, { a: { c: 2 } })).toEqual({ a: { b: 1, c: 2 } });
@@ -620,9 +621,11 @@ import.meta.vitest?.test("applyDefaults", ({ expect }) => {
 
   // Dot notation
   expect(applyDefaults({ a: { b: 1 } }, { "a.c": 2 })).toEqual({ a: { b: 1 }, "a.c": 2 });
+  expect(applyDefaults({ a: { b: 1 } }, { "a.c": null })).toEqual({ a: { b: 1 }, "a.c": null });
   expect(applyDefaults({ a: 1 }, { "a.b": 2 })).toEqual({ a: 1, "a.b": 2 });
   expect(applyDefaults({ a: null }, { "a.b": 2 })).toEqual({ a: null, "a.b": 2 });
   expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
+  expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1 } });
   expect(applyDefaults({ a: { b: { c: { d: 1 } } } }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
   expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
   expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
@@ -884,7 +887,16 @@ export async function getConfigOverrideErrors<T extends yup.AnySchema>(schema: T
     if (value === undefined) continue;
     const subSchema = getSubSchema(schema, key);
     if (!subSchema) {
-      return Result.error(`The key ${JSON.stringify(key)} is not valid for the schema.`);
+      // find smallest key prefix that is invalid
+      const keySplit = key.split(".");
+      for (let i = 0; i < keySplit.length; i++) {
+        const prefix = keySplit.slice(0, i).join(".");
+        const subSchema = getSubSchema(schema, prefix);
+        if (!subSchema) {
+          return Result.error(`The key ${JSON.stringify(key)} is not valid (nested object not found in schema: ${JSON.stringify(prefix)}).`);
+        }
+      }
+      throw new StackAssertionError("Something weird happened? Sub-schema for key is invalid but no prefix is invalid??", { key, subSchema });
     }
     let restrictedSchema = getRestrictedSchema(key, subSchema);
     try {
@@ -963,10 +975,10 @@ export type ValidatedToHaveNoIncompleteConfigWarnings<T extends yup.AnySchema> =
 
 // Normalized overrides
 // ex.: { a?: { b?: number, c?: string }, d?: number }
-type ProjectConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof projectConfigSchema>>;
-type BranchConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof branchConfigSchema>>;
-type EnvironmentConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof environmentConfigSchema>>;
-type OrganizationConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof organizationConfigSchema>>;
+export type ProjectConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof projectConfigSchema>>;
+export type BranchConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof branchConfigSchema>>;
+export type EnvironmentConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof environmentConfigSchema>>;
+export type OrganizationConfigNormalizedOverride = Expand<ValidatedToHaveNoConfigOverrideErrors<typeof organizationConfigSchema>>;
 
 
 // Overrides
diff --git a/packages/stack-shared/src/schema-fields.ts b/packages/stack-shared/src/schema-fields.ts
index 700733357e..87c1392827 100644
--- a/packages/stack-shared/src/schema-fields.ts
+++ b/packages/stack-shared/src/schema-fields.ts
@@ -63,7 +63,7 @@ yup.addMethod(yup.string, "nonEmpty", function (message?: string) {
 });
 
 yup.addMethod(yup.Schema, "hasNested", function (path: any) {
-  if (!path.match(/^[a-zA-Z0-9_$:-]+$/)) throw new StackAssertionError(`yupSchema.hasNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${JSON.stringify(path)}`);
+  if (!path.match(/^[a-zA-Z0-9_$:-]*$/)) throw new StackAssertionError(`yupSchema.hasNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${JSON.stringify(path)}`);
   const schemaInfo = this.meta()?.stackSchemaInfo as any;
   if (schemaInfo?.type === "record") {
     return schemaInfo.keySchema.isValidSync(path);
@@ -83,7 +83,7 @@ yup.addMethod(yup.Schema, "hasNested", function (path: any) {
 });
 
 yup.addMethod(yup.Schema, "getNested", function (path: any) {
-  if (!path.match(/^[a-zA-Z0-9_$:-]+$/)) throw new StackAssertionError(`yupSchema.getNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${path}`);
+  if (!path.match(/^[a-zA-Z0-9_$:-]*$/)) throw new StackAssertionError(`yupSchema.getNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${JSON.stringify(path)}`);
 
   if (!this.hasNested(path as never)) throw new StackAssertionError(`Tried to call yupSchema.getNested, but key is not present in the schema. Provided key: ${path}`, { path, schema: this });
 
diff --git a/packages/stack-shared/src/utils/objects.tsx b/packages/stack-shared/src/utils/objects.tsx
index 5a6a3cbc50..1fb17bbde3 100644
--- a/packages/stack-shared/src/utils/objects.tsx
+++ b/packages/stack-shared/src/utils/objects.tsx
@@ -531,20 +531,24 @@ import.meta.vitest?.test("deepSortKeys", ({ expect }) => {
 });
 
 export function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) {
+  if (!isObjectLike(obj)) throw new StackAssertionError("set: obj is not an object", { obj, key, value });
   Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
 }
 
 export function get<T extends object, K extends keyof T>(obj: T, key: K): T[K] {
+  if (!isObjectLike(obj)) throw new StackAssertionError("get: obj is not an object", { obj, key });
   const descriptor = Object.getOwnPropertyDescriptor(obj, key);
   if (!descriptor) throw new StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
   return descriptor.value;
 }
 
 export function getOrUndefined<T extends object, K extends keyof T>(obj: T, key: K): T[K] | undefined {
+  if (!isObjectLike(obj)) throw new StackAssertionError("getOrUndefined: obj is not an object", { obj, key });
   return has(obj, key) ? get(obj, key) : undefined;
 }
 
 export function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & { [k in K]: unknown } {
+  if (!isObjectLike(obj)) throw new StackAssertionError("has: obj is not an object", { obj, key });
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 

From f81279ebcc5f33f806a600f7415aa422bd135676 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Thu, 25 Sep 2025 17:14:19 -0700
Subject: [PATCH 12/23] fix tests

---
 packages/stack-shared/src/config/format.ts    |  4 +-
 .../src/config/schema-fuzzer.test.ts          | 48 +++++++++----------
 packages/stack-shared/src/config/schema.ts    | 33 +++++++------
 packages/stack-shared/src/schema-fields.ts    |  2 +-
 packages/stack-shared/src/utils/objects.tsx   |  8 ++--
 packages/stack-shared/src/utils/strings.tsx   |  3 +-
 6 files changed, 51 insertions(+), 47 deletions(-)

diff --git a/packages/stack-shared/src/config/format.ts b/packages/stack-shared/src/config/format.ts
index 406205aa6b..77613f5a6f 100644
--- a/packages/stack-shared/src/config/format.ts
+++ b/packages/stack-shared/src/config/format.ts
@@ -58,7 +58,9 @@ function getInvalidConfigValueReason(value: unknown, options: { valueName?: stri
         break;
       } else if (Array.isArray(value)) {
         for (const [index, v] of value.entries()) {
-          const reason = getInvalidConfigValueReason(v, { valueName: `${valueName}[${index}]` });
+          const elementValueName = `${valueName}[${index}]`;
+          if (v === null) return `${elementValueName} is null; tuple elements cannot be null`;
+          const reason = getInvalidConfigValueReason(v, { valueName: elementValueName });
           if (reason) return reason;
         }
       } else {
diff --git a/packages/stack-shared/src/config/schema-fuzzer.test.ts b/packages/stack-shared/src/config/schema-fuzzer.test.ts
index 485358077d..6ef07958ea 100644
--- a/packages/stack-shared/src/config/schema-fuzzer.test.ts
+++ b/packages/stack-shared/src/config/schema-fuzzer.test.ts
@@ -14,7 +14,6 @@ const projectSchemaFuzzerConfig = [{
     type: ["hosted", "neon", "postgres"],
     connectionString: ["", "postgres://user:password@host:port/database", "THIS IS A STRING LOLOL"],
     connectionStrings: [{
-      "": ["", "THIS IS A CONNECTION STRING OR SO"],
       "123-some-branch-id": ["", "THIS IS A CONNECTION STRING OR SO"],
     }],
   }],
@@ -45,10 +44,6 @@ const branchSchemaFuzzerConfig = [{
           type: ["google", "github", "x"] as const,
           allowSignIn: [true, false],
           allowConnectedAccounts: [true, false],
-          isShared: [true, false],
-          clientId: ["some-client-id"],
-          facebookConfigId: ["some-facebook-config-id"],
-          microsoftTenantId: ["some-microsoft-tenant-id"],
         }],
       }],
     }],
@@ -113,14 +108,14 @@ const branchSchemaFuzzerConfig = [{
   }],
   emails: [{
     themes: [{
-      "some-theme-id": [{
+      "12345678-1234-4234-9234-123456789012": [{
         displayName: ["Some Theme", "Some Other Theme"],
         tsxSource: ["", "some typescript source code"],
       }],
     }],
     selectedThemeId: ["some-theme-id", "some-other-theme-id"],
     templates: [{
-      "12345678-90ab-cdef-1234-567890abcdef": [{
+      "12345678-1234-4234-9234-123456789012": [{
         themeId: ["some-theme-id", "some-other-theme-id"],
         displayName: ["Some Template", "Some Other Template"],
         tsxSource: ["", "some typescript source code"],
@@ -145,7 +140,7 @@ const branchSchemaFuzzerConfig = [{
   }],
   rbac: [{
     permissions: [{
-      "$some_permission_id": [{
+      "some_permission_id": [{
         containedPermissionIds: [{
           "some_permission_id": [true],
           "$some_other_permission_id": [true],
@@ -182,7 +177,11 @@ const environmentSchemaFuzzerConfig = [{
       ...branchSchemaFuzzerConfig[0].auth[0].oauth[0],
       providers: [typedFromEntries(typedEntries(branchSchemaFuzzerConfig[0].auth[0].oauth[0].providers[0]).map(([key, value]) => [key, [{
         ...value[0],
+        isShared: [true, false],
+        clientId: ["some-client-id"],
         clientSecret: ["some-client-secret"],
+        facebookConfigId: ["some-facebook-config-id"],
+        microsoftTenantId: ["some-microsoft-tenant-id"],
       }]]))] as const,
     }],
   }],
@@ -213,7 +212,7 @@ const environmentSchemaFuzzerConfig = [{
 const organizationSchemaFuzzerConfig = environmentSchemaFuzzerConfig satisfies FuzzerConfig<OrganizationConfigNormalizedOverride>;
 
 function setDeep<T>(obj: T, path: string[], value: any) {
-  if (typeof obj !== "object" || obj === null) return obj;
+  if (!isObjectLike(obj)) return obj;
 
   if (path.length === 0) {
     throw new Error("Path is empty");
@@ -226,6 +225,7 @@ function setDeep<T>(obj: T, path: string[], value: any) {
 }
 
 function createFuzzerInput<T>(config: FuzzerConfig<T>, progress: number): T {
+  progress = Math.min(1, 2 * progress);
   const createShouldRandom = (strength: number) => {
     const chance = Math.random() * strength * 1.2 - 0.1;
     return () => Math.random() < chance;
@@ -241,33 +241,31 @@ function createFuzzerInput<T>(config: FuzzerConfig<T>, progress: number): T {
   const shouldNull = createShouldRandom(0.25);
 
   let res: any;
-  const recurse = <U>(path: string[], config: FuzzerConfig<U>, force: boolean) => {
+  const recurse = <U>(outputPath: string[], config: FuzzerConfig<U>, forceNested: boolean, forceNonNull: boolean) => {
     let subConfig: any = config[Math.floor(Math.random() * config.length)];
-    let value = typeof subConfig === "object" && subConfig !== null ? (Array.isArray(subConfig) ? [] : {}) : subConfig;
-    if (path.length === 0) {
-      res = value;
+    const originalValue = isObjectLike(subConfig) ? (Array.isArray(subConfig) ? [] : {}) : subConfig;
+
+    const newValue = forceNonNull || !shouldNull() ? originalValue : null;
+    const newOutputPath = forceNested || shouldMakeNested(originalValue) || outputPath.length === 0 ? outputPath : [outputPath.join(".")];
+    if (outputPath.length === 0) {
+      res = newValue;
     } else {
-      if (shouldKeep(value)) {
-        if (shouldNull()) value = null;
-        if (path.length >= 2 && shouldMakeNested(value)) {
-          setDeep(res, path, value);
-        } else {
-          setDeep(res, [path.join(".")], value);
-        }
+      if (forceNested || shouldKeep(originalValue)) {
+        setDeep(res, newOutputPath, newValue);
       }
     }
-    if (typeof subConfig === "object" && subConfig !== null) {
-      for (const key of Object.keys(subConfig)) {
-        recurse([...path, key], subConfig[key], Array.isArray(subConfig));
+    if (isObjectLike(subConfig)) {
+      for (const [key, newValue] of typedEntries(subConfig)) {
+        recurse([...newOutputPath, key], newValue, Array.isArray(subConfig), Array.isArray(subConfig));
       }
     }
   };
-  recurse<T>([], config, false);
+  recurse<T>([], config, false, true);
   return res;
 }
 
 import.meta.vitest?.test("fuzz schemas", async ({ expect }) => {
-  const totalIterations = 10;
+  const totalIterations = process.env.CI ? 1000 : 200;
   for (let i = 0; i < totalIterations; i++) {
     const projectInput = createFuzzerInput<ProjectConfigNormalizedOverride>(projectSchemaFuzzerConfig, i / totalIterations);
     const branchInput = createFuzzerInput<BranchConfigNormalizedOverride>(branchSchemaFuzzerConfig, i / totalIterations);
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 18282f124f..9cafa35c78 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -584,20 +584,21 @@ function applyDefaults<D extends object | ((key: string) => unknown), C extends
   const res: any = deepReplaceFunctionsWithObjects(defaults);
 
   outer: for (const [key, mergeValue] of Object.entries(config)) {
-    if (mergeValue === undefined) continue;
-    const keyParts = key.split(".");
-    let baseValue: any = defaults;
-    let currentRes: any = res;
-    for (const [index, part] of keyParts.entries()) {
-      baseValue = has(baseValue, part) ? get(baseValue, part) : (typeof baseValue === 'function' ? (baseValue as any)(part) : undefined);
-      if (baseValue === undefined || (!isObjectLike(baseValue) && mergeValue !== null)) {
-        set(res, key, mergeValue);
-        continue outer;
+    if (mergeValue == null) continue;
+    if (!isObjectLike(mergeValue)) {
+      set(res, key, mergeValue);
+    } else {
+      const keyParts = key.split(".");
+      let baseValue: any = defaults;
+      for (const [index, part] of keyParts.entries()) {
+        baseValue = has(baseValue, part) ? get(baseValue, part) : (typeof baseValue === 'function' ? (baseValue as any)(part) : undefined);
+        if (baseValue === undefined || !isObjectLike(baseValue)) {
+          set(res, key, mergeValue);
+          continue outer;
+        }
       }
-      if (!has(currentRes, part)) set(currentRes, part, deepReplaceFunctionsWithObjects(baseValue) as never);
-      currentRes = get(currentRes, part);
+      set(res, key, applyDefaults(baseValue, mergeValue));
     }
-    set(res, key, mergeValue === null ? baseValue : isObjectLike(mergeValue) ? applyDefaults(baseValue, mergeValue) : mergeValue);
   }
   return res as any;
 }
@@ -612,20 +613,22 @@ import.meta.vitest?.test("applyDefaults", ({ expect }) => {
 
   // Functions
   expect(applyDefaults((key: string) => ({ b: key }), { a: {} })).toEqual({ a: { b: "a" } });
+  expect(applyDefaults((key: string) => ({ b: key }), { a: null })).toEqual({});
   expect(applyDefaults((key1: string) => (key2: string) => ({ a: key1, b: key2 }), { c: { d: {} } })).toEqual({ c: { d: { a: "c", b: "d" } } });
   expect(applyDefaults({ a: (key: string) => ({ b: key }) }, { a: { c: { d: 1 } } })).toEqual({ a: { c: { b: "c", d: 1 } } });
   expect(applyDefaults({ a: (key: string) => ({ b: key }) }, {})).toEqual({ a: {} });
+  expect(applyDefaults({ a: (key: string) => ({ b: key }) }, { a: null })).toEqual({ a: {} });
   expect(applyDefaults({ a: { b: (key: string) => ({ b: key }) } }, {})).toEqual({ a: { b: {} } });
   expect(applyDefaults(typedAssign(() => ({ b: 1 }), { a: { b: 1, c: 2 } }), { a: {} })).toEqual({ a: { b: 1, c: 2 } });
   expect(applyDefaults(typedAssign(() => ({ b: 1 }), { a: { b: 1, c: 2 } }), { d: {} })).toEqual({ a: { b: 1, c: 2 }, d: { b: 1 } });
 
   // Dot notation
   expect(applyDefaults({ a: { b: 1 } }, { "a.c": 2 })).toEqual({ a: { b: 1 }, "a.c": 2 });
-  expect(applyDefaults({ a: { b: 1 } }, { "a.c": null })).toEqual({ a: { b: 1 }, "a.c": null });
+  expect(applyDefaults({ a: { b: 1 } }, { "a.c": null })).toEqual({ a: { b: 1 } });
   expect(applyDefaults({ a: 1 }, { "a.b": 2 })).toEqual({ a: 1, "a.b": 2 });
   expect(applyDefaults({ a: null }, { "a.b": 2 })).toEqual({ a: null, "a.b": 2 });
   expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
-  expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1 } });
+  expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({ a: { b: { c: 1 } } });
   expect(applyDefaults({ a: { b: { c: { d: 1 } } } }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
   expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
   expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
@@ -890,7 +893,7 @@ export async function getConfigOverrideErrors<T extends yup.AnySchema>(schema: T
       // find smallest key prefix that is invalid
       const keySplit = key.split(".");
       for (let i = 0; i < keySplit.length; i++) {
-        const prefix = keySplit.slice(0, i).join(".");
+        const prefix = keySplit.slice(0, i + 1).join(".");
         const subSchema = getSubSchema(schema, prefix);
         if (!subSchema) {
           return Result.error(`The key ${JSON.stringify(key)} is not valid (nested object not found in schema: ${JSON.stringify(prefix)}).`);
diff --git a/packages/stack-shared/src/schema-fields.ts b/packages/stack-shared/src/schema-fields.ts
index 3d0a3b34be..be38ea17ff 100644
--- a/packages/stack-shared/src/schema-fields.ts
+++ b/packages/stack-shared/src/schema-fields.ts
@@ -423,7 +423,7 @@ export const dayIntervalOrNeverSchema = yupUnion(dayIntervalSchema.defined(), yu
  * This schema is useful for fields where the user can specify the ID, such as price IDs. It is particularly common
  * for IDs in the config schema.
  */
-export const userSpecifiedIdSchema = (idName: `${string}Id`) => yupString().max(63).matches(/^[a-zA-Z_][a-zA-Z0-9_-]*$/, `${idName} must start with a letter, underscore, or number, and contain only letters, numbers, underscores, and hyphens`);
+export const userSpecifiedIdSchema = (idName: `${string}Id`) => yupString().max(63).matches(/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/, `${idName} must contain only letters, numbers, underscores, and hyphens, and not start with a hyphen`);
 export const moneyAmountSchema = (currency: Currency) => yupString<MoneyAmount>().test('money-amount', 'Invalid money amount', (value, context) => {
   if (value == null) return true;
   const regex = /^([0-9]+)(\.([0-9]+))?$/;
diff --git a/packages/stack-shared/src/utils/objects.tsx b/packages/stack-shared/src/utils/objects.tsx
index 1fb17bbde3..86b052cddc 100644
--- a/packages/stack-shared/src/utils/objects.tsx
+++ b/packages/stack-shared/src/utils/objects.tsx
@@ -531,24 +531,24 @@ import.meta.vitest?.test("deepSortKeys", ({ expect }) => {
 });
 
 export function set<T extends object, K extends keyof T>(obj: T, key: K, value: T[K]) {
-  if (!isObjectLike(obj)) throw new StackAssertionError("set: obj is not an object", { obj, key, value });
+  if (!isObjectLike(obj)) throw new StackAssertionError(`set: obj is not an object (found: ${(obj as any) === null ? "null" : typeof obj})`, { obj, key, value });
   Object.defineProperty(obj, key, { value, writable: true, configurable: true, enumerable: true });
 }
 
 export function get<T extends object, K extends keyof T>(obj: T, key: K): T[K] {
-  if (!isObjectLike(obj)) throw new StackAssertionError("get: obj is not an object", { obj, key });
+  if ((obj as any) == null) throw new StackAssertionError("get: obj is null or undefined", { obj, key });
   const descriptor = Object.getOwnPropertyDescriptor(obj, key);
   if (!descriptor) throw new StackAssertionError(`get: key ${String(key)} does not exist`, { obj, key });
   return descriptor.value;
 }
 
 export function getOrUndefined<T extends object, K extends keyof T>(obj: T, key: K): T[K] | undefined {
-  if (!isObjectLike(obj)) throw new StackAssertionError("getOrUndefined: obj is not an object", { obj, key });
+  if ((obj as any) == null) throw new StackAssertionError("getOrUndefined: obj is null or undefined", { obj, key });
   return has(obj, key) ? get(obj, key) : undefined;
 }
 
 export function has<T extends object, K extends keyof T>(obj: T, key: K): obj is T & { [k in K]: unknown } {
-  if (!isObjectLike(obj)) throw new StackAssertionError("has: obj is not an object", { obj, key });
+  if ((obj as any) == null) throw new StackAssertionError("has: obj is null or undefined", { obj, key });
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
diff --git a/packages/stack-shared/src/utils/strings.tsx b/packages/stack-shared/src/utils/strings.tsx
index 45030a7b42..2f845368ba 100644
--- a/packages/stack-shared/src/utils/strings.tsx
+++ b/packages/stack-shared/src/utils/strings.tsx
@@ -558,7 +558,8 @@ export function nicify(
       if (Array.isArray(value)) {
         const extraLines = getNicifiedObjectExtraLines(value);
         const resValueLength = value.length + extraLines.length;
-        if (maxDepth <= 0 && resValueLength === 0) return "[...]";
+        if (resValueLength === 0) return "[]";  // early return in case maxDepth <= 0
+        if (maxDepth <= 0) return `[...]`;
         const resValues = value.map((v, i) => nestedNicify(v, `${path}[${i}]`, i));
         resValues.push(...extraLines);
         if (resValues.length !== resValueLength) throw new StackAssertionError("nicify of object: resValues.length !== resValueLength", { value, resValues, resValueLength });

From 5c7f3d965cf9063580f38e38f61e91a4d32ee145 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Thu, 25 Sep 2025 19:32:58 -0500
Subject: [PATCH 13/23] more test fixes

---
 packages/stack-shared/src/config/schema.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 9cafa35c78..04764d26a9 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -630,9 +630,9 @@ import.meta.vitest?.test("applyDefaults", ({ expect }) => {
   expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
   expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({ a: { b: { c: 1 } } });
   expect(applyDefaults({ a: { b: { c: { d: 1 } } } }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
-  expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b": { d: 2 } })).toEqual({ a: { b: { c: 1 } }, "a.b": { c: 1, d: 2 } });
-  expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b.c": {} })).toEqual({ a: { b: { c: { d: 1 } } }, "a.b.c": { d: 1 } });
-  expect(applyDefaults({ a: { b: () => ({ c: 1, d: 2 }) } }, { "a.b.x-y.c": 3 })).toEqual({ a: { b: { "x-y": { c: 1, d: 2 } } }, "a.b.x-y.c": 3 });
+  expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b": { d: 2 } })).toEqual({ a: {}, "a.b": { c: 1, d: 2 } });
+  expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b.c": {} })).toEqual({ a: {}, "a.b.c": { d: 1 } });
+  expect(applyDefaults({ a: { b: () => ({ c: 1, d: 2 }) } }, { "a.b.x-y.c": 3 })).toEqual({ a: { b: {} }, "a.b.x-y.c": 3 });
 });
 
 export function applyProjectDefaults<T extends ProjectRenderedConfigBeforeDefaults>(config: T) {

From 3e3b2a81222ade49dff7a9317f170ccc1ff29aff Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Thu, 25 Sep 2025 19:49:51 -0500
Subject: [PATCH 14/23] fix tests

---
 apps/backend/src/lib/config.tsx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/apps/backend/src/lib/config.tsx b/apps/backend/src/lib/config.tsx
index bc3da0e3d9..2b286811f5 100644
--- a/apps/backend/src/lib/config.tsx
+++ b/apps/backend/src/lib/config.tsx
@@ -434,8 +434,9 @@ import.meta.vitest?.test('_validateConfigOverrideSchemaImpl(...)', async ({ expe
   expect(await validateConfigOverrideSchema(yupObject({ a: yupObject({ b: yupObject({ c: yupString().defined() }).defined() }).defined() }), { a: { b: {} } }, { "a.b": { c: 123 } })).toEqual(Result.error("[ERROR] a.b.c must be a `string` type, but the final value was: `123`."));
   expect(await validateConfigOverrideSchema(yupObject({ a: yupString().defined().oneOf(['b']) }), {}, { a: 'c' })).toEqual(Result.error("[ERROR] a must be one of the following values: b"));
   expect(await validateConfigOverrideSchema(yupObject({ a: yupString().defined() }), {}, {})).toEqual(Result.error("[WARNING] a must be defined"));
-  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), {}, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a").`));
-  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a").`));
+  expect(await validateConfigOverrideSchema(yupObject({}), {}, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a").`));
+  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), {}, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a.b").`));
+  expect(await validateConfigOverrideSchema(yupObject({ a: yupMixed() }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a.b").`));
   expect(await validateConfigOverrideSchema(yupObject({ a: yupObject({ c: yupString().optional() }) }), { a: 'str' }, { "a.b": "c" })).toEqual(Result.error(`[ERROR] The key \"a.b\" is not valid (nested object not found in schema: "a.b").`));
   expect(await validateConfigOverrideSchema(schema1, {}, { a: 123 })).toEqual(Result.error('[ERROR] a must be a `string` type, but the final value was: `123`.'));
   expect(await validateConfigOverrideSchema(unionSchema, { a: { "time": "now" } }, { "a.morning": true })).toMatchInlineSnapshot(`

From c50e96ce6dfe0c4ac9736472f836b9d93a388bdd Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Fri, 3 Oct 2025 15:49:02 -0700
Subject: [PATCH 15/23] Fix outdated variables named "group"

---
 .../latest/payments/purchases/validate-code/route.ts   | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
index ac8be16ff5..12fda88c56 100644
--- a/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
+++ b/apps/backend/src/app/api/latest/payments/purchases/validate-code/route.ts
@@ -67,9 +67,9 @@ export const POST = createSmartRouteHandler({
 
     const alreadyBoughtNonStackable = !!(subscriptions.find((s) => s.productId === verificationCode.data.productId) && product.stackable !== true);
 
-    const groups = tenancy.config.payments.catalogs;
-    const catalogId = Object.keys(groups).find((g) => product.catalogId === g);
-    let conflictingGroupProducts: { product_id: string, display_name: string }[] = [];
+    const catalogs = tenancy.config.payments.catalogs;
+    const catalogId = Object.keys(catalogs).find((g) => product.catalogId === g);
+    let conflictingCatalogProducts: { product_id: string, display_name: string }[] = [];
     if (catalogId) {
       const isSubscribable = product.prices !== "include-by-default" && Object.values(product.prices).some((p: any) => p && p.interval);
       if (isSubscribable) {
@@ -80,7 +80,7 @@ export const POST = createSmartRouteHandler({
           subscription.product.prices !== "include-by-default" &&
           (!product.isAddOnTo || !Object.keys(product.isAddOnTo).includes(subscription.productId))
         ));
-        conflictingGroupProducts = conflicts.map((s) => ({
+        conflictingCatalogProducts = conflicts.map((s) => ({
           product_id: s.productId!,
           display_name: s.product.displayName ?? s.productId!,
         }));
@@ -95,7 +95,7 @@ export const POST = createSmartRouteHandler({
         stripe_account_id: verificationCode.data.stripeAccountId,
         project_id: tenancy.project.id,
         already_bought_non_stackable: alreadyBoughtNonStackable,
-        conflicting_products: conflictingGroupProducts,
+        conflicting_products: conflictingCatalogProducts,
       },
     };
   },

From 3d095e68d6905609f3858fcfafb9b26e9b791251 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Fri, 3 Oct 2025 15:50:36 -0700
Subject: [PATCH 16/23] Fix import order

---
 examples/e-commerce/src/app/page.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/e-commerce/src/app/page.tsx b/examples/e-commerce/src/app/page.tsx
index 68633660e4..4e58cc9bbd 100644
--- a/examples/e-commerce/src/app/page.tsx
+++ b/examples/e-commerce/src/app/page.tsx
@@ -1,6 +1,6 @@
+import { ServerUser } from "@stackframe/stack";
 import { Shop } from "@/shop";
 import { stackServerApp } from "@/stack";
-import { ServerUser } from "@stackframe/stack";
 
 export default async function Home() {
   const users = await stackServerApp.listUsers();

From 7e88c9f779f9c356e5620a292e665f52250dc2ee Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 00:01:41 -0700
Subject: [PATCH 17/23] Fix tests

---
 .../api/v1/internal/transactions.test.ts      |  6 ++--
 .../outdated--purchase-session.test.ts        | 28 +++++++++++--------
 .../api/v1/payments/purchase-session.test.ts  |  2 +-
 packages/stack-shared/src/config/schema.ts    |  2 ++
 4 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
index 38261f457b..7a0c838cd8 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/internal/transactions.test.ts
@@ -95,7 +95,6 @@ it("includes TEST_MODE subscription", async () => {
         "customer_id": "<stripped UUID>",
         "customer_type": "user",
         "id": "<stripped UUID>",
-        "product_display_name": "Sub Product",
         "price": {
           "USD": "1000",
           "interval": [
@@ -103,6 +102,7 @@ it("includes TEST_MODE subscription", async () => {
             "month",
           ],
         },
+        "product_display_name": "Sub Product",
         "quantity": 1,
         "status": "active",
         "test_mode": true,
@@ -135,8 +135,8 @@ it("includes TEST_MODE one-time purchase", async () => {
         "customer_id": "<stripped UUID>",
         "customer_type": "user",
         "id": "<stripped UUID>",
-        "product_display_name": "One-Time Product",
         "price": { "USD": "5000" },
+        "product_display_name": "One-Time Product",
         "quantity": 1,
         "status": null,
         "test_mode": true,
@@ -172,8 +172,8 @@ it("includes item quantity change entries", async () => {
         "expires_at_millis": <stripped field 'expires_at_millis'>,
         "id": "<stripped UUID>",
         "item_id": "credits",
-        "product_display_name": null,
         "price": null,
+        "product_display_name": null,
         "quantity": 5,
         "status": null,
         "test_mode": false,
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
index 9d940c560e..63f8b1df9f 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
@@ -150,7 +150,13 @@ it("should error on one-time price quantity > 1 when offer is not stackable", as
       quantity: 2,
     },
   });
-  expect(res).toMatchInlineSnapshot(`{ "client_secret": "pi_3SAe2C2KCgi1aqUo1EpPjb95_secret_L8CPurjiGtbxopdDmeLkJpR6y" }`);
+  expect(res).toMatchInlineSnapshot(`
+    NiceResponse {
+      "status": 400,
+      "body": "This product is not stackable; quantity must be 1",
+      "headers": Headers { <some fields may have been hidden> },
+    }
+  `);
 });
 
 it("should return client secret for one-time price even if a conflicting group subscription exists (DB-only)", async ({ expect }) => {
@@ -164,7 +170,7 @@ it("should return client secret for one-time price even if a conflicting group s
           displayName: "Sub Offer",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: { monthly: { USD: "1000", interval: [1, "month"] } },
           includedItems: {},
@@ -173,7 +179,7 @@ it("should return client secret for one-time price even if a conflicting group s
           displayName: "One Time",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -591,7 +597,7 @@ it("should update existing stripe subscription when switching offers within a gr
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -605,7 +611,7 @@ it("should update existing stripe subscription when switching offers within a gr
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -697,7 +703,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -711,7 +717,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -836,7 +842,7 @@ it("should block one-time purchase for same product after prior one-time purchas
     body: { full_code: code2, price_id: "one", quantity: 1 },
   });
   expect(res.status).toBe(400);
-  expect(String(res.body)).toContain("one-time purchase for this offer");
+  expect(String(res.body)).toContain("one-time purchase for this product");
 });
 
 it("should block one-time purchase in same group after prior one-time purchase in that group (test-mode persisted)", async ({ expect }) => {
@@ -850,7 +856,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -859,7 +865,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          groupId: "grp",
+          catalogId: "grp",
           stackable: true,
           prices: { one: { USD: "700" } },
           includedItems: {},
@@ -902,5 +908,5 @@ it("should block one-time purchase in same group after prior one-time purchase i
     body: { full_code: codeB, price_id: "one", quantity: 1 },
   });
   expect(resB.status).toBe(400);
-  expect(String(resB.body)).toContain("one-time purchase in this product group");
+  expect(String(resB.body)).toContain("one-time purchase in this product catalog");
 });
diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
index ba124cdd63..e062c0a6d0 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/purchase-session.test.ts
@@ -908,5 +908,5 @@ it("should block one-time purchase in same group after prior one-time purchase i
     body: { full_code: codeB, price_id: "one", quantity: 1 },
   });
   expect(resB.status).toBe(400);
-  expect(String(resB.body)).toContain("one-time purchase in this product group");
+  expect(String(resB.body)).toContain("one-time purchase in this product catalog");
 });
diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 04764d26a9..563dc7fd44 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -153,6 +153,8 @@ const branchWorkflowsSchema = yupObject({
 export const branchConfigSchema = canNoLongerBeOverridden(projectConfigSchema, ["sourceOfTruth"]).concat(yupObject({
   rbac: branchRbacSchema,
 
+  apps: yupMixed(),
+
   teams: yupObject({
     createPersonalTeamOnSignUp: yupBoolean(),
     allowClientTeamCreation: yupBoolean(),

From 9199a617eedcf1997fb739317947c80b3c1a079d Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 00:03:34 -0700
Subject: [PATCH 18/23] Fix tests again

---
 .../outdated--purchase-session.test.ts           | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
index 63f8b1df9f..f5c6c0a5e6 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/payments/before-offer-to-product-rename/outdated--purchase-session.test.ts
@@ -170,7 +170,7 @@ it("should return client secret for one-time price even if a conflicting group s
           displayName: "Sub Offer",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: false,
           prices: { monthly: { USD: "1000", interval: [1, "month"] } },
           includedItems: {},
@@ -179,7 +179,7 @@ it("should return client secret for one-time price even if a conflicting group s
           displayName: "One Time",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -597,7 +597,7 @@ it("should update existing stripe subscription when switching offers within a gr
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -611,7 +611,7 @@ it("should update existing stripe subscription when switching offers within a gr
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -703,7 +703,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -717,7 +717,7 @@ it("should cancel DB-only subscription then create Stripe subscription when swit
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: false,
           prices: {
             monthly: {
@@ -856,7 +856,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
           displayName: "Offer A",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: true,
           prices: { one: { USD: "500" } },
           includedItems: {},
@@ -865,7 +865,7 @@ it("should block one-time purchase in same group after prior one-time purchase i
           displayName: "Offer B",
           customerType: "user",
           serverOnly: false,
-          catalogId: "grp",
+          groupId: "grp",
           stackable: true,
           prices: { one: { USD: "700" } },
           includedItems: {},

From fb7ca6a3a0fa50019ba7d588e29426d522c6278a Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 01:13:07 -0700
Subject: [PATCH 19/23] fix

---
 packages/stack-shared/src/config/schema.ts | 2 --
 1 file changed, 2 deletions(-)

diff --git a/packages/stack-shared/src/config/schema.ts b/packages/stack-shared/src/config/schema.ts
index 563dc7fd44..04764d26a9 100644
--- a/packages/stack-shared/src/config/schema.ts
+++ b/packages/stack-shared/src/config/schema.ts
@@ -153,8 +153,6 @@ const branchWorkflowsSchema = yupObject({
 export const branchConfigSchema = canNoLongerBeOverridden(projectConfigSchema, ["sourceOfTruth"]).concat(yupObject({
   rbac: branchRbacSchema,
 
-  apps: yupMixed(),
-
   teams: yupObject({
     createPersonalTeamOnSignUp: yupBoolean(),
     allowClientTeamCreation: yupBoolean(),

From 090a661db4eaf915e58d86a38946cb035567597f Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 01:45:59 -0700
Subject: [PATCH 20/23] fixes

---
 packages/stack-shared/src/apps/apps-config.ts | 55 +++++++++++++------
 .../src/config/schema-fuzzer.test.ts          |  6 ++
 2 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/packages/stack-shared/src/apps/apps-config.ts b/packages/stack-shared/src/apps/apps-config.ts
index 2bc99868f6..d192576790 100644
--- a/packages/stack-shared/src/apps/apps-config.ts
+++ b/packages/stack-shared/src/apps/apps-config.ts
@@ -1,92 +1,115 @@
+type App = {
+  type: "app" | "integration",
+  displayName: string,
+  subtitle: string,
+  tags: string[],
+  stage: "alpha" | "beta" | "stable",
+};
+
 export const ALL_APPS = {
   "authentication": {
-    type: "app" as const,
+    type: "app",
     displayName: "Authentication",
     subtitle: "User sign-in and account management",
     tags: ["auth", "security"],
+    stage: "stable",
   },
   "teams": {
-    type: "app" as const,
+    type: "app",
     displayName: "Teams",
     subtitle: "Team collaboration and management",
     tags: ["collaboration", "organization"],
+    stage: "stable",
   },
   "rbac": {
-    type: "app" as const,
+    type: "app",
     displayName: "RBAC",
     subtitle: "Role-based access control and permissions",
     tags: ["security", "permissions"],
+    stage: "stable",
   },
   "api-keys": {
-    type: "app" as const,
+    type: "app",
     displayName: "API Keys",
     subtitle: "API key generation and management",
     tags: ["api", "security"],
+    stage: "stable",
   },
   "payments": {
-    type: "app" as const,
+    type: "app",
     displayName: "Payments",
     subtitle: "Payment processing and subscription management",
     tags: ["billing", "monetization"],
+    stage: "stable",
   },
   "emails": {
-    type: "app" as const,
+    type: "app",
     displayName: "Emails",
     subtitle: "Email template configuration and management",
     tags: ["communication", "templates"],
+    stage: "stable",
   },
   "email-api": {
-    type: "app" as const,
+    type: "app",
     displayName: "Email API",
     subtitle: "Programmatic email sending and delivery",
     tags: ["api", "communication"],
+    stage: "alpha",
   },
   "data-vault": {
-    type: "app" as const,
+    type: "app",
     displayName: "Data Vault",
     subtitle: "Secure storage for sensitive user data",
     tags: ["security", "storage"],
+    stage: "stable",
   },
   "workflows": {
-    type: "app" as const,
+    type: "app",
     displayName: "Workflows",
     subtitle: "Automated business process orchestration",
     tags: ["automation", "processes"],
+    stage: "beta",
   },
   "webhooks": {
-    type: "app" as const,
+    type: "app",
     displayName: "Webhooks",
     subtitle: "Real-time event notifications and integrations",
     tags: ["integration", "events"],
+    stage: "stable",
   },
   "tv-mode": {
-    type: "app" as const,
+    type: "app",
     displayName: "TV mode",
     subtitle: "Dashboard display for large screens",
     tags: ["display", "monitoring"],
+    stage: "alpha",
   },
   "launch-checklist": {
-    type: "app" as const,
+    type: "app",
     displayName: "Launch Checklist",
     subtitle: "Pre-launch verification and readiness checks",
     tags: ["deployment", "verification"],
+    stage: "alpha",
   },
   "catalyst": {
-    type: "app" as const,
+    type: "app",
     displayName: "Catalyst",
     subtitle: "Project scaffolding and rapid development",
     tags: ["development", "tooling"],
+    stage: "alpha",
   },
   "neon": {
-    type: "integration" as const,
+    type: "integration",
     displayName: "Neon",
     subtitle: "Serverless Postgres database integration",
     tags: ["database", "integration"],
+    stage: "alpha",
   },
   "convex": {
-    type: "integration" as const,
+    type: "integration",
     displayName: "Convex",
     subtitle: "Real-time backend platform integration",
     tags: ["database", "integration", "realtime"],
+    stage: "alpha",
   },
-} as const;
+} as const satisfies Record<string, App>;
diff --git a/packages/stack-shared/src/config/schema-fuzzer.test.ts b/packages/stack-shared/src/config/schema-fuzzer.test.ts
index 6ef07958ea..d199253bb3 100644
--- a/packages/stack-shared/src/config/schema-fuzzer.test.ts
+++ b/packages/stack-shared/src/config/schema-fuzzer.test.ts
@@ -1,3 +1,4 @@
+import { ALL_APPS } from "../apps/apps-config";
 import { SUPPORTED_CURRENCIES } from "../utils/currency-constants";
 import { StackAssertionError } from "../utils/errors";
 import { getOrUndefined, isObjectLike, set, typedEntries, typedFromEntries } from "../utils/objects";
@@ -167,6 +168,11 @@ const branchSchemaFuzzerConfig = [{
   domains: [{
     allowLocalhost: [true, false],
   }],
+  apps: [{
+    installed: [typedFromEntries(typedEntries(ALL_APPS).map(([key, value]) => [key, [{
+      enabled: [true, false],
+    }]]))],
+  }],
 }] satisfies FuzzerConfig<BranchConfigNormalizedOverride>;
 
 const environmentSchemaFuzzerConfig = [{

From 7e191fd05c349fd2bb6392781bf33b26f366c0ee Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 01:54:53 -0700
Subject: [PATCH 21/23] fix tests

---
 apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
index 6ed52f3aea..52b2d53a91 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
@@ -404,7 +404,7 @@ it("returns an error when config override contains non-existent fields", async (
   expect(invalidTopLevelResponse).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "[ERROR] The key \\"nonExistentField\\" is not valid for the schema.",
+      "body": "[ERROR] The key \\"nonExistentField\\" is not valid (nested object not found in schema: \\"nonExistentField\\").",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);

From e3227bcbd256fa8d6fdb361c0c025d0116e68714 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 02:17:33 -0700
Subject: [PATCH 22/23] fixes

---
 .../api/latest/internal/config/override/crud.tsx  | 15 ++++++---------
 apps/backend/src/lib/config.tsx                   |  6 ++++--
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/apps/backend/src/app/api/latest/internal/config/override/crud.tsx b/apps/backend/src/app/api/latest/internal/config/override/crud.tsx
index c16e352289..fcc1b75b6b 100644
--- a/apps/backend/src/app/api/latest/internal/config/override/crud.tsx
+++ b/apps/backend/src/app/api/latest/internal/config/override/crud.tsx
@@ -1,6 +1,7 @@
-import { getRenderedEnvironmentConfigQuery, overrideEnvironmentConfigOverride, validateEnvironmentConfigOverride } from "@/lib/config";
+import { getRenderedEnvironmentConfigQuery, overrideEnvironmentConfigOverride } from "@/lib/config";
 import { globalPrismaClient, rawQuery } from "@/prisma-client";
 import { createCrudHandlers } from "@/route-handlers/crud-handler";
+import { environmentConfigSchema, getConfigOverrideErrors, migrateConfigOverride } from "@stackframe/stack-shared/dist/config/schema";
 import { configOverrideCrud } from "@stackframe/stack-shared/dist/interface/crud/config";
 import { yupObject } from "@stackframe/stack-shared/dist/schema-fields";
 import { StatusError } from "@stackframe/stack-shared/dist/utils/errors";
@@ -20,14 +21,10 @@ export const configOverridesCrudHandlers = createLazyProxy(() => createCrudHandl
         throw e;
       }
 
-      const validationResult = await validateEnvironmentConfigOverride({
-        environmentConfigOverride: parsedConfig,
-        branchId: auth.tenancy.branchId,
-        projectId: auth.tenancy.project.id,
-      });
-
-      if (validationResult.status === "error") {
-        throw new StatusError(StatusError.BadRequest, validationResult.error);
+      // TODO instead of doing this check here, we should change overrideEnvironmentConfigOverride to return the errors from its ensureNoConfigOverrideErrors call
+      const overrideError = await getConfigOverrideErrors(environmentConfigSchema, migrateConfigOverride("environment", parsedConfig));
+      if (overrideError.status === "error") {
+        throw new StatusError(StatusError.BadRequest, overrideError.error);
       }
 
       await overrideEnvironmentConfigOverride({
diff --git a/apps/backend/src/lib/config.tsx b/apps/backend/src/lib/config.tsx
index 2b286811f5..03a22468af 100644
--- a/apps/backend/src/lib/config.tsx
+++ b/apps/backend/src/lib/config.tsx
@@ -205,10 +205,11 @@ export async function overrideProjectConfigOverride(options: {
 
   // TODO put this in a serializable transaction (or a single SQL query) to prevent race conditions
   const oldConfig = await rawQuery(globalPrismaClient, getProjectConfigOverrideQuery(options));
-  const newConfig = override(
+  const newConfigUnmigrated = override(
     oldConfig,
     options.projectConfigOverrideOverride,
   );
+  const newConfig = migrateConfigOverride("project", newConfigUnmigrated);
 
   // large configs make our DB slow; let's prevent them early
   const newConfigString = JSON.stringify(newConfig);
@@ -249,10 +250,11 @@ export async function overrideEnvironmentConfigOverride(options: {
 
   // TODO put this in a serializable transaction (or a single SQL query) to prevent race conditions
   const oldConfig = await rawQuery(globalPrismaClient, getEnvironmentConfigOverrideQuery(options));
-  const newConfig = override(
+  const newConfigUnmigrated = override(
     oldConfig,
     options.environmentConfigOverrideOverride,
   );
+  const newConfig = migrateConfigOverride("environment", newConfigUnmigrated);
 
   // large configs make our DB slow; let's prevent them early
   const newConfigString = JSON.stringify(newConfig);

From 0cd66a30374e19047fd7c53bfe4959f3d3ed18d9 Mon Sep 17 00:00:00 2001
From: Konstantin Wohlwend <n2d4xc@gmail.com>
Date: Sat, 4 Oct 2025 02:27:43 -0700
Subject: [PATCH 23/23] fix tests (final! hopefully)

---
 .../tests/backend/endpoints/api/v1/internal/config.test.ts    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts b/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
index 52b2d53a91..aaa7e6fe4f 100644
--- a/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
+++ b/apps/e2e/tests/backend/endpoints/api/v1/internal/config.test.ts
@@ -374,7 +374,7 @@ it("returns an error when the oauth config is misconfigured", async ({ expect })
   expect(invalidTypeResponse).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "[ERROR] auth.oauth.providers.invalid.type must be one of the following values: google, github, microsoft, spotify, facebook, discord, gitlab, bitbucket, linkedin, apple, x, twitch",
+      "body": "auth.oauth.providers.invalid.type must be one of the following values: google, github, microsoft, spotify, facebook, discord, gitlab, bitbucket, linkedin, apple, x, twitch",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);
@@ -404,7 +404,7 @@ it("returns an error when config override contains non-existent fields", async (
   expect(invalidTopLevelResponse).toMatchInlineSnapshot(`
     NiceResponse {
       "status": 400,
-      "body": "[ERROR] The key \\"nonExistentField\\" is not valid (nested object not found in schema: \\"nonExistentField\\").",
+      "body": "The key \\"nonExistentField\\" is not valid (nested object not found in schema: \\"nonExistentField\\").",
       "headers": Headers { <some fields may have been hidden> },
     }
   `);