@taskforcehq/taskforce 0.3.309 → 0.3.313

package/dist/components/views/PlanComparisonPage.test.js

@@ -1,757 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { within } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { PlanComparisonPage } from './PlanComparisonPage';
-describe('PlanComparisonPage', () => {
-    beforeEach(() => {
-        globalThis.__DEBUG_MODE__ = false;
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pageTitle: 'Subscription Plans',
-                pageDescription: 'Manage your subscription and explore available features. Your current plan is highlighted below.',
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        description: 'Start using Taskforce at no cost.',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: null, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    },
-                    {
-                        planId: 'team-5',
-                        displayName: 'Team 5',
-                        description: 'For small collaborative teams.',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'team-5-v2',
-                            versionNumber: 2,
-                            seatLimit: 5,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 2000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_team_5_year', unitAmount: 20000, currency: 'usd', interval: 'year' }
-                        }
-                    }
-                ]
-            })
-        })));
-    });
-    afterEach(() => {
-        delete globalThis.__DEBUG_MODE__;
-        vi.unstubAllGlobals();
-    });
-    it('shows pricing source details only when debug mode is enabled', async () => {
-        globalThis.__DEBUG_MODE__ = true;
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText('Pricing source: production (cloud)')).toBeInTheDocument();
-    });
-    it('renders plan descriptions when provided by the pricing payload', async () => {
-        const { container } = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText('Start using Taskforce at no cost.')).toBeInTheDocument();
-        expect(screen.getByText('For small collaborative teams.')).toBeInTheDocument();
-        expect(screen.getByRole('heading', { name: 'Founding beta' })).toBeInTheDocument();
-        expect(screen.getByText(/Taskforce is in founding beta/)).toBeInTheDocument();
-        expect(screen.getByText(/Early members get access while the product is still forming/)).toBeInTheDocument();
-        expect(screen.getByText('Prices are listed in USD. Taxes may apply.')).toBeInTheDocument();
-        expect(screen.getByText('Local install is free on every plan. Cloud limits apply only to hosted workspaces.')).toBeInTheDocument();
-        const foundingBeta = screen.getByRole('heading', { name: 'Founding beta' }).closest('section');
-        const firstPlanCard = container.querySelector('[data-testid^="plan-card-"]');
-        const planCards = container.querySelectorAll('[data-testid^="plan-card-"]');
-        const lastPlanCard = planCards[planCards.length - 1];
-        const pricingNotes = screen.getByText('Prices are listed in USD. Taxes may apply.').closest('div');
-        const cloudCapacity = screen.getByRole('heading', { name: 'Need more cloud capacity?' }).closest('section');
-        const teamWorkspacesCard = screen.getByRole('heading', { name: 'Team workspaces are coming soon.' }).closest('div');
-        if (!foundingBeta || !firstPlanCard) {
-            throw new Error('Expected founding beta copy and a plan card to render.');
-        }
-        if (!lastPlanCard || !pricingNotes) {
-            throw new Error('Expected pricing notes to render below the plan cards.');
-        }
-        if (!cloudCapacity || !teamWorkspacesCard) {
-            throw new Error('Expected cloud capacity copy to render above the team workspaces card.');
-        }
-        expect(Boolean(foundingBeta.compareDocumentPosition(firstPlanCard) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
-        expect(Boolean(lastPlanCard.compareDocumentPosition(pricingNotes) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
-        expect(Boolean(pricingNotes.compareDocumentPosition(cloudCapacity) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
-        expect(Boolean(cloudCapacity.compareDocumentPosition(teamWorkspacesCard) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
-    });
-    it('renders pricing above the plan description', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        const teamCard = await screen.findByTestId('plan-card-team-5');
-        const monthlyPrice = within(teamCard).getByText('$20');
-        const description = within(teamCard).getByText('For small collaborative teams.');
-        expect(Boolean(monthlyPrice.compareDocumentPosition(description) & Node.DOCUMENT_POSITION_FOLLOWING)).toBe(true);
-    });
-    it('shows founding offer pricing when campaign prices are present', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                plans: [
-                    {
-                        planId: 'pro',
-                        displayName: 'Pro',
-                        description: 'For serious operators.',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'pro-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_pro_month', unitAmount: 3000, currency: 'usd', interval: 'month' },
-                            year: null
-                        },
-                        campaignPricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_pro_campaign_month', unitAmount: 1200, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        const proCard = await screen.findByTestId('plan-card-pro');
-        expect(within(proCard).getByText('$30')).toBeInTheDocument();
-        expect(within(proCard).getByText('Founding Offer:')).toBeInTheDocument();
-        expect(within(proCard).getByText('$12')).toBeInTheDocument();
-        expect(within(proCard).getAllByText('/ month')).toHaveLength(2);
-    });
-    it('renders and selects campaign-only pricing intervals', async () => {
-        const onSelectPlan = vi.fn();
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                plans: [
-                    {
-                        planId: 'pro',
-                        displayName: 'Pro',
-                        description: 'For serious operators.',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'pro-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: null,
-                            year: null
-                        },
-                        campaignPricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_pro_campaign_month', unitAmount: 1200, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        const proCard = await screen.findByTestId('plan-card-pro');
-        expect(within(proCard).queryByText('$30')).not.toBeInTheDocument();
-        expect(within(proCard).getByText('Founding Offer:')).toBeInTheDocument();
-        expect(within(proCard).getByText('$12')).toBeInTheDocument();
-        fireEvent.click(within(proCard).getByRole('button', { name: 'Get Started' }));
-        expect(onSelectPlan).toHaveBeenCalledWith({
-            planId: 'pro',
-            planVersionId: 'pro-v1',
-            interval: 'month',
-            pricingType: 'stripe',
-            pricingAudience: 'campaign',
-            isCurrentPlan: false
-        });
-    });
-    it('prefers pricing payload header copy when provided', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pageTitle: 'Choose Your Taskforce Plan',
-                pageDescription: 'Compare plans and pick the right fit for your team.',
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: []
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", subtitle: "Fallback subtitle", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Choose Your Taskforce Plan' })).toBeInTheDocument();
-        expect(screen.getByText('Compare plans and pick the right fit for your team.')).toBeInTheDocument();
-    });
-    it('can keep the provided heading when pricing payload title exists', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pageTitle: 'Choose Your Taskforce Plan',
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: []
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Pricing for human-agent work.", preferPricingPageTitle: false, isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Pricing for human-agent work.' })).toBeInTheDocument();
-        expect(screen.queryByRole('heading', { name: 'Choose Your Taskforce Plan' })).not.toBeInTheDocument();
-    });
-    it('renders pricing payload description as sanitized HTML', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pageTitle: 'Choose Your Taskforce Plan',
-                pageDescription: '<p>Local install is <strong>free</strong>.</p><p><a href="https://example.com/pricing">Read more</a><a href="javascript:alert(1)">Nope</a></p><script>alert(1)</script>',
-                plans: []
-            })
-        })));
-        const { container } = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", subtitle: "Fallback subtitle", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText(/Local install is/)).toBeInTheDocument();
-        expect(container.querySelector('strong')?.textContent).toBe('free');
-        expect(container.querySelector('script')).toBeNull();
-        expect(screen.queryByText('alert(1)')).not.toBeInTheDocument();
-        expect(container.querySelector('a[href="https://example.com/pricing"]')?.textContent).toBe('Read more');
-        expect(container.querySelector('a[href^="javascript:"]')).toBeNull();
-        expect(screen.getByText('Nope')).toBeInTheDocument();
-    });
-    it('falls back to provided pricing source details when the pricing response omits them', async () => {
-        globalThis.__DEBUG_MODE__ = true;
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                plans: [
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: null, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, fallbackPricingSource: { environment: 'performance', runtimeMode: 'local' }, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText('Pricing source: performance (local)')).toBeInTheDocument();
-    });
-    it('keeps pricing source details hidden when debug mode is disabled', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        await screen.findByRole('heading', { name: 'Subscription Plans' });
-        expect(screen.queryByText('Pricing source: production (cloud)')).not.toBeInTheDocument();
-    });
-    it('renders public feature copy when provided by the pricing payload', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'team-5',
-                        displayName: 'Team 5',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'team-5-v2',
-                            versionNumber: 2,
-                            seatLimit: 5,
-                            metadata: {}
-                        },
-                        features: [
-                            {
-                                featureKey: 'collaboration.ai_profiles',
-                                access: 'enabled',
-                                label: 'AI Profiles',
-                                publicLabel: 'AI teammates',
-                                publicDescription: 'Add reusable AI teammates to your workspace.',
-                                publicDescriptionVisible: true
-                            }
-                        ],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 2000, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText('AI teammates')).toBeInTheDocument();
-        expect(screen.getByText('Add reusable AI teammates to your workspace.')).toBeInTheDocument();
-        expect(screen.queryByText('Collaboration Ai Profiles')).not.toBeInTheDocument();
-    });
-    it('hides feature descriptions when publicDescriptionVisible is false', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'team-5',
-                        displayName: 'Team 5',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'team-5-v2',
-                            versionNumber: 2,
-                            seatLimit: 5,
-                            metadata: {}
-                        },
-                        features: [
-                            {
-                                featureKey: 'collaboration.ai_profiles',
-                                access: 'enabled',
-                                label: 'AI Profiles',
-                                publicLabel: 'AI teammates',
-                                publicDescription: 'Add reusable AI teammates to your workspace.',
-                                publicDescriptionVisible: false
-                            }
-                        ],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 2000, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByText('AI teammates')).toBeInTheDocument();
-        expect(screen.queryByText('Add reusable AI teammates to your workspace.')).not.toBeInTheDocument();
-    });
-    it('renders inline numeric feature limits next to each feature label', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: 12,
-                            metadata: {}
-                        },
-                        features: [
-                            {
-                                featureKey: 'workspace.workspaces',
-                                access: 'enabled',
-                                label: 'Workspaces',
-                                config: { maxWorkspaces: 1 }
-                            },
-                            {
-                                featureKey: 'collaboration.ai_profiles',
-                                access: 'limited',
-                                label: 'AI Profiles',
-                                publicLabel: 'AI Agents',
-                                config: { maxAiProfiles: 4 }
-                            },
-                            {
-                                featureKey: 'context.uploads',
-                                access: 'enabled',
-                                label: 'Cloud Storage',
-                                config: { storageLimitMb: 24 }
-                            },
-                            {
-                                featureKey: 'collaboration.team_management',
-                                access: 'enabled',
-                                label: 'Team Management'
-                            }
-                        ],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: null, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        const { container } = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        const freeCard = await screen.findByTestId('plan-card-free');
-        const featureTextNodes = Array.from(freeCard.querySelectorAll('span')).map((node) => node.textContent);
-        expect(featureTextNodes).toContain('1 Workspace');
-        expect(featureTextNodes).toContain('4 AI Agents');
-        expect(featureTextNodes).toContain('24MB Cloud Storage');
-        expect(featureTextNodes).toContain('12 Team Management');
-        expect(container.querySelector('[class*="featureLimitUnit"]')?.textContent).toBe('MB');
-    });
-    it('renders the storage unit suffix in a smaller accent span', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [
-                            {
-                                featureKey: 'context.uploads',
-                                access: 'enabled',
-                                label: 'Cloud Storage',
-                                config: { storageLimitMb: 64 }
-                            }
-                        ],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: null, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        const { container } = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        await screen.findByText('Cloud Storage');
-        const accent = container.querySelector('[class*="featureLimitAccent"]');
-        const unit = container.querySelector('[class*="featureLimitUnit"]');
-        expect(accent?.textContent).toBe('64MB');
-        expect(unit?.textContent).toBe('MB');
-    });
-    it('renders storage limits above 1000 MB as rounded GB', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'pro',
-                        displayName: 'Pro',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'pro-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [
-                            {
-                                featureKey: 'context.uploads',
-                                access: 'enabled',
-                                label: 'Cloud Storage',
-                                config: { storageLimitMb: 2500 }
-                            }
-                        ],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_pro_month', unitAmount: 1999, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        const { container } = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        await screen.findByText('Cloud Storage');
-        const accent = container.querySelector('[class*="featureLimitAccent"]');
-        const unit = container.querySelector('[class*="featureLimitUnit"]');
-        expect(accent?.textContent).toBe('3GB');
-        expect(unit?.textContent).toBe('GB');
-    });
-    it('hides missing yearly pricing rows and buttons instead of rendering unavailable state', async () => {
-        vi.stubGlobal('fetch', vi.fn(async () => ({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'operator',
-                        displayName: 'Operator',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'operator-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_operator_month', unitAmount: 999, currency: 'usd', interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        })));
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        const operatorCard = await screen.findByTestId('plan-card-operator');
-        expect(within(operatorCard).getByText('$9.99')).toBeInTheDocument();
-        expect(within(operatorCard).getByText('/ month')).toBeInTheDocument();
-        expect(within(operatorCard).queryByText('/ year')).not.toBeInTheDocument();
-        expect(within(operatorCard).queryByText('Unavailable')).not.toBeInTheDocument();
-        expect(within(operatorCard).getByRole('button', { name: 'Get Started' })).toBeInTheDocument();
-        expect(within(operatorCard).queryByRole('button', { name: 'Start Yearly' })).not.toBeInTheDocument();
-    });
-    it('does not mark a plan current when only the plan id matches but the version does not', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v1", currentEntitlementState: "active", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        expect(screen.queryByText('Current Plan')).not.toBeInTheDocument();
-    });
-    it('marks a trialing entitlement as the current plan', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v2", currentEntitlementState: "trialing", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        expect(screen.getByText('Current Plan')).toBeInTheDocument();
-    });
-    it('can show the current plan as a non-interactive indicator when billing is managed from page chrome', async () => {
-        const onSelectPlan = vi.fn();
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v2", currentEntitlementState: "active", canManageCurrentPlan: true, currentPlanCardActionMode: "indicator", onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        const currentCard = screen.getByTestId('plan-card-team-5');
-        expect(currentCard).not.toHaveAttribute('role', 'button');
-        expect(screen.queryByTestId('plan-manage-team-5')).not.toBeInTheDocument();
-        expect(screen.queryByRole('button', { name: 'Manage Plan' })).not.toBeInTheDocument();
-        expect(screen.getByTestId('plan-current-team-5')).toBeDisabled();
-        fireEvent.click(currentCard);
-        expect(onSelectPlan).not.toHaveBeenCalled();
-    });
-    it('can render the page header bar even when shell chrome is present', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, chrome: _jsx("div", { children: "Shell chrome" }), showHeaderBarWithChrome: true, topActions: _jsx("button", { type: "button", children: "Manage billing" }), onBack: () => { }, backLabel: "Back to App", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        expect(screen.getByRole('button', { name: 'Back to App' })).toBeInTheDocument();
-        expect(screen.getByRole('button', { name: 'Manage billing' })).toBeInTheDocument();
-    });
-    it('does not mark a canceled entitlement as current through the plan-id fallback path', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: null, currentEntitlementState: "canceled", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        expect(screen.queryByText('Current Plan')).not.toBeInTheDocument();
-    });
-    it('does not mark a linked pending-plan-selection entitlement as the current plan', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "team-5", currentPlanVersionId: "team-5-v2", currentEntitlementState: "pending_plan_selection", canManageCurrentPlan: true, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        expect(screen.queryByRole('button', { name: 'Manage Plan' })).not.toBeInTheDocument();
-        expect(screen.queryByText('Current Plan')).not.toBeInTheDocument();
-        expect(screen.getByRole('button', { name: 'Start Monthly' })).toBeInTheDocument();
-    });
-    it('can disable the page back button while onboarding remains blocked', async () => {
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, onBack: () => { }, backLabel: "Back to App", backDisabled: true, onSelectPlan: () => { } }));
-        expect(await screen.findByRole('button', { name: 'Back to App' })).toBeDisabled();
-    });
-    it('shows pricing before auth resolves but keeps plan selection disabled until bootstrap finishes', async () => {
-        const onSelectPlan = vi.fn();
-        const view = render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, authSessionResolved: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
-        const freeCard = screen.getByTestId('plan-card-free');
-        expect(screen.getByRole('button', { name: 'Get Started' })).toBeDisabled();
-        expect(screen.getByRole('button', { name: 'Start Monthly' })).toBeDisabled();
-        expect(screen.getByRole('button', { name: 'Start Yearly' })).toBeDisabled();
-        expect(freeCard).not.toHaveAttribute('role', 'button');
-        view.rerender(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, authSessionResolved: true, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        const enabledFreeCard = screen.getByTestId('plan-card-free');
-        expect(screen.getByRole('button', { name: 'Get Started' })).toBeEnabled();
-        expect(screen.getByRole('button', { name: 'Start Monthly' })).toBeEnabled();
-        expect(screen.getByRole('button', { name: 'Start Yearly' })).toBeEnabled();
-        expect(enabledFreeCard).toHaveAttribute('role', 'button');
-        fireEvent.click(screen.getByRole('button', { name: 'Get Started' }));
-        await waitFor(() => {
-            expect(onSelectPlan).toHaveBeenCalledWith({
-                planId: 'free',
-                planVersionId: 'free-v1',
-                interval: 'month',
-                pricingType: 'free',
-                pricingAudience: 'public',
-                isCurrentPlan: false
-            });
-        });
-    });
-    it('selects the whole plan card using the default available interval', async () => {
-        const onSelectPlan = vi.fn();
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        await screen.findByRole('heading', { name: 'Subscription Plans' });
-        const freeHeading = screen.getByRole('heading', { name: 'Free' });
-        const freeCard = freeHeading.closest('[role="button"]');
-        expect(freeCard).toBeTruthy();
-        expect(within(freeCard).getByText('$0')).toBeInTheDocument();
-        expect(within(freeCard).getByText('/ month')).toBeInTheDocument();
-        fireEvent.click(freeCard);
-        await waitFor(() => {
-            expect(onSelectPlan).toHaveBeenCalledWith({
-                planId: 'free',
-                planVersionId: 'free-v1',
-                interval: 'month',
-                pricingType: 'free',
-                pricingAudience: 'public',
-                isCurrentPlan: false
-            });
-        });
-    });
-    it('does not trigger current-plan actions when the current plan is not Stripe-managed', async () => {
-        const onSelectPlan = vi.fn();
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: true, currentPlanId: "free", currentPlanVersionId: "free-v1", currentEntitlementState: "active", canManageCurrentPlan: false, onBack: () => { }, backLabel: "Back", onSelectPlan: onSelectPlan }));
-        await screen.findByRole('heading', { name: 'Subscription Plans' });
-        const currentButton = screen.getByRole('button', { name: 'Current Plan' });
-        expect(currentButton).toBeDisabled();
-        expect(onSelectPlan).not.toHaveBeenCalled();
-    });
-    it('loads pricing from the provided cloud endpoint', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'performance',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    }
-                ]
-            })
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, pricingEndpoint: "https://performance-app.example/api/taskforce/public/pricing", onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        expect(await screen.findByRole('heading', { name: 'Free' })).toBeInTheDocument();
-        expect(fetchMock).toHaveBeenCalledTimes(1);
-        expect(fetchMock).toHaveBeenCalledWith('https://performance-app.example/api/taskforce/public/pricing', {
-            method: 'GET',
-            credentials: 'include'
-        });
-        expect(screen.queryByText('Connecting to plan pricing...')).not.toBeInTheDocument();
-    });
-    it('orders plans from free to highest priced tier', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: [
-                    {
-                        planId: 'team-5',
-                        displayName: 'Team 5',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'team-5-v2',
-                            versionNumber: 3,
-                            seatLimit: 5,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_team_5_month', unitAmount: 12000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_team_5_year', unitAmount: 120000, currency: 'usd', interval: 'year' }
-                        }
-                    },
-                    {
-                        planId: 'free',
-                        displayName: 'Free',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'free-v1',
-                            versionNumber: 1,
-                            seatLimit: null,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
-                            year: null
-                        }
-                    },
-                    {
-                        planId: 'basic',
-                        displayName: 'Basic',
-                        status: 'active',
-                        defaultVersion: {
-                            planVersionId: 'basic-v1',
-                            versionNumber: 2,
-                            seatLimit: 1,
-                            metadata: {}
-                        },
-                        features: [],
-                        pricing: {
-                            month: { pricingType: 'stripe', stripePriceId: 'price_basic_month', unitAmount: 3000, currency: 'usd', interval: 'month' },
-                            year: { pricingType: 'stripe', stripePriceId: 'price_basic_year', unitAmount: 30000, currency: 'usd', interval: 'year' }
-                        }
-                    }
-                ]
-            })
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        await screen.findByRole('heading', { name: 'Subscription Plans' });
-        const planNames = screen.getAllByRole('heading', { level: 3 }).map((node) => node.textContent);
-        expect(planNames).toEqual(['Free', 'Basic', 'Team 5']);
-    });
-    it('defaults to the same-origin pricing endpoint', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                pricingSource: {
-                    environment: 'production',
-                    runtimeMode: 'cloud'
-                },
-                plans: []
-            })
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        render(_jsx(PlanComparisonPage, { heading: "Subscription Plans", isAuthenticated: false, onBack: () => { }, backLabel: "Back", onSelectPlan: () => { } }));
-        await screen.findByText('Paid plans are getting their final polish.');
-        expect(fetchMock).toHaveBeenCalledWith('/api/taskforce/public/pricing', {
-            method: 'GET',
-            credentials: 'include'
-        });
-    });
-});