+ {TEST_DUES_ENABLED && (
+
Test annual dues
+ )}
My Account
{' '}
·
diff --git a/src/pages/community/TestDues.test.tsx b/src/pages/community/TestDues.test.tsx
new file mode 100644
index 00000000..ad470a0f
--- /dev/null
+++ b/src/pages/community/TestDues.test.tsx
@@ -0,0 +1,197 @@
+import React from 'react';
+import {
+ act, fireEvent, render, screen, waitFor
+} from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import { HelmetProvider } from 'react-helmet-async';
+import TestDues from './TestDues';
+import { callTestDues, openTestCheckout } from '../../services/community/testDuesService';
+
+let mockUser: any;
+let mockAuth: any;
+let mockServices: any;
+let mockCallback: (u: any) => void;
+const mockApp = { options: { projectId: 'run-mprc-staging' } };
+jest.mock('firebase/auth', () => ({
+ onIdTokenChanged: (auth: any, cb: (u: any) => void) => {
+ mockCallback = cb;
+ cb(auth.currentUser);
+ return jest.fn();
+ }
+}));
+jest.mock('../../services/hooks/useAuth', () => ({
+ useAuth: () => ({
+ user: mockUser,
+ isLoading: false
+ })
+}));
+jest.mock('../../services/ServiceLocatorContext', () => ({ useServiceLocator: () => ({ services: mockServices }) }));
+jest.mock('../../services/community/testDuesService', () => ({
+ ...jest.requireActual('../../services/community/testDuesService'),
+ TEST_DUES_ENABLED: true,
+ callTestDues: jest.fn(),
+ openTestCheckout: jest.fn()
+}));
+const call = callTestDues as jest.Mock;
+const state = () => ({
+ schemaVersion: 1,
+ observedAtMs: 1792152000000,
+ active: false,
+ accessThroughMs: null,
+ order: null,
+ waiver: { version: 'synthetic-dues-v1', text: 'SYNTHETIC TEST ONLY. No real waiver.' },
+ offers: ['individual', 'family'].map((kind) => ({
+ membershipDuesCheckoutSchemaVersion: 1,
+ planRef: `dues-2026-${kind}-v1`,
+ policyVersion: 'test-dues-calendar-v1',
+ termId: 'calendar-2026',
+ amountMinor: kind === 'individual' ? 2500 : 3000,
+ currency: 'usd',
+ startsAtMs: 1767254400000,
+ endsAtMs: 1798790400000,
+ offerable: true
+ }))
+});
+const order = {
+ id: 'a'.repeat(64),
+ state: 'open',
+ offerId: 'dues-2026-individual-v1',
+ amountMinor: 2500,
+ currency: 'usd',
+ endsAtMs: 1798790400000,
+ familyId: null
+};
+const show = () => (
+
+
+
+
+
+);
+const originalCrypto = Object.getOwnPropertyDescriptor(globalThis, 'crypto');
+beforeEach(() => {
+ jest.clearAllMocks();
+ mockUser = { uid: 'fictional' };
+ mockAuth = {
+ app: mockApp,
+ tenantId: null,
+ currentUser: {
+ uid: 'fictional',
+ emailVerified: true
+ }
+ };
+ mockServices = {
+ firebaseResources: {
+ auth: mockAuth,
+ functions: { app: mockApp }
+ }
+ };
+ call.mockResolvedValue(state());
+ Object.defineProperty(globalThis, 'crypto', {
+ configurable: true,
+ value: { randomUUID: () => '123e4567-e89b-42d3-a456-426614174000' }
+ });
+});
+afterEach(() => { jest.useRealTimers(); });
+afterAll(() => {
+ if (originalCrypto) {
+ Object.defineProperty(globalThis, 'crypto', originalCrypto);
+ }
+ else {
+ Reflect.deleteProperty(globalThis, 'crypto');
+ }
+});
+test('signed-out page calls no backend', () => {
+ mockUser = null;
+ mockAuth.currentUser = null;
+ render(show());
+ expect(screen.getByText('Sign in to continue')).toBeInTheDocument();
+ expect(call).not.toHaveBeenCalled();
+});
+test('consent precedes server-priced test checkout and redirects only to verified response', async () => {
+ render(show());
+ const button = await screen.findByRole('button', { name: 'Continue to individual test checkout' });
+ expect(button).toBeDisabled();
+ fireEvent.click(screen.getByRole('checkbox'));
+ call.mockResolvedValueOnce({
+ order,
+ checkoutUrl: 'https://checkout.stripe.com/c/pay/cs_test_synthetic'
+ });
+ fireEvent.click(button);
+ await waitFor(() => expect(openTestCheckout).toHaveBeenCalledWith('https://checkout.stripe.com/c/pay/cs_test_synthetic'));
+ expect(call.mock.calls[1][2]).toEqual({
+ action: 'prepare',
+ accountUid: 'fictional',
+ requestId: '123e4567-e89b-42d3-a456-426614174000',
+ offerId: 'dues-2026-individual-v1',
+ waiverVersion: 'synthetic-dues-v1',
+ waiverAccepted: true
+ });
+});
+test('lost prepare retains exact request; retry does not create another ID or trust return query', async () => {
+ render(show());
+ const button = await screen.findByRole('button', { name: 'Continue to individual test checkout' });
+ fireEvent.click(screen.getByRole('checkbox'));
+ call.mockRejectedValueOnce(new Error('uncertain'));
+ fireEvent.click(button);
+ const retry = await screen.findByRole('button', { name: 'Retry saved request' });
+ await waitFor(() => expect(retry).toBeEnabled());
+ const saved = call.mock.calls[1][2];
+ call.mockResolvedValueOnce({ order }).mockResolvedValueOnce({
+ ...state(),
+ order
+ });
+ fireEvent.click(retry);
+ await screen.findByText('Your saved purchase');
+ expect(call.mock.calls[2][2]).toEqual(saved);
+ expect(openTestCheckout).not.toHaveBeenCalled();
+});
+test('reload recovers server order; no new-purchase controls while pending', async () => {
+ call.mockResolvedValue({
+ ...state(),
+ order
+ });
+ render(show());
+ await screen.findByText('Your saved purchase');
+ expect(screen.getByRole('button', { name: 'Resume saved checkout' })).toBeEnabled();
+ expect(screen.queryByText('Continue to individual test checkout')).not.toBeInTheDocument();
+});
+test('same-UID new session discards late result and saved consent', async () => {
+ let resolve: (v: any) => void = () => { };
+ call.mockReturnValueOnce(new Promise((r) => {
+ resolve = r;
+ }));
+ render(show());
+ call.mockRejectedValue(new Error('unavailable'));
+ await act(async () => {
+ mockCallback(mockAuth.currentUser);
+ });
+ await act(async () => {
+ resolve(state());
+ });
+ expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+});
+test('deadline removes controls without polling', async () => {
+ jest.useFakeTimers();
+ render(show());
+ await screen.findByRole('checkbox');
+ const calls = call.mock.calls.length;
+ act(() => {
+ jest.advanceTimersByTime(60001);
+ });
+ expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+ expect(call).toHaveBeenCalledTimes(calls);
+});
+test('bad response hides all purchase controls', async () => {
+ call.mockResolvedValue({
+ ...state(),
+ unexpected: true
+ });
+ render(show());
+ await screen.findByText(/We could not confirm/);
+ expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+});
diff --git a/src/pages/community/TestDues.tsx b/src/pages/community/TestDues.tsx
new file mode 100644
index 00000000..75970a9e
--- /dev/null
+++ b/src/pages/community/TestDues.tsx
@@ -0,0 +1,291 @@
+import React, {
+ useEffect, useMemo, useRef, useState
+} from 'react';
+import { onIdTokenChanged, User } from 'firebase/auth';
+import { Link } from 'react-router-dom';
+import { useAuth } from '../../services/hooks/useAuth';
+import { useServiceLocator } from '../../services/ServiceLocatorContext';
+import {
+ callTestDues, DuesRequest, DuesStatus, openTestCheckout,
+ parseDuesResult, parseDuesStatus, TEST_DUES_ENABLED
+} from '../../services/community/testDuesService';
+import SEO from '../../components/SEO';
+import './Community.css';
+
+const date = (ms: number) => new Intl.DateTimeFormat('en-US', {
+ timeZone: 'America/Los_Angeles',
+ dateStyle: 'medium'
+}).format(ms - 1);
+export default function TestDues() {
+ const { services } = useServiceLocator();
+ const { user, isLoading } = useAuth();
+ const auth = services?.firebaseResources.auth;
+ const functions = services?.firebaseResources.functions;
+ const [session, setSession] = useState<{
+ user: User;
+ epoch: symbol;
+ } | null>(null);
+ const enabled = TEST_DUES_ENABLED
+ && functions?.app.options.projectId === 'run-mprc-staging'
+ && auth?.app === functions?.app
+ && auth?.tenantId === null;
+ const identity = useMemo(() => Symbol('test-dues'), [enabled,
+ services,
+ auth,
+ functions,
+ session,
+ user?.uid,
+ isLoading]);
+ const currentIdentity = useRef(identity);
+ currentIdentity.current = identity;
+ const serial = useRef(0);
+ const inFlight = useRef(false);
+ const pending = useRef<{
+ identity: symbol;
+ request: DuesRequest;
+ } | null>(null);
+ const [snapshot, setSnapshot] = useState<{
+ identity: symbol;
+ value: DuesStatus;
+ began: number;
+ wall: number;
+ budget: number;
+ } | null>(null);
+ const [busy, setBusy] = useState(false);
+ const [accepted, setAccepted] = useState(false);
+ const [message, setMessage] = useState('');
+ const current = () => enabled
+ && !isLoading
+ && session
+ && auth?.currentUser === session.user
+ && session.user.uid === user?.uid
+ && session.user.emailVerified;
+ const fresh = () => snapshot
+ && snapshot.identity === identity
+ && Math.max(
+ performance.now() - snapshot.began,
+ Date.now() - snapshot.wall,
+ ) < snapshot.budget;
+ const status = current() && fresh() ? snapshot?.value : null;
+ const saved = pending.current?.identity === identity ? pending.current.request : null;
+ async function perform(action: DuesRequest['action'] = 'status', offerId?: string, retry = false) {
+ if (!current() || !auth || !functions || !session || inFlight.current) return;
+ if (action === 'prepare' && !retry && (!status || !fresh() || !accepted)) return;
+ const capture = identity;
+ serial.current += 1;
+ const generation = serial.current;
+ const valid = () => currentIdentity.current === capture
+ && serial.current === generation
+ && current();
+ let request = retry ? saved : { action, accountUid: session.user.uid } as DuesRequest;
+ if (action === 'prepare' && !retry) {
+ try {
+ request = {
+ ...request,
+ requestId: crypto.randomUUID(),
+ offerId,
+ waiverVersion: status?.waiver.version,
+ waiverAccepted: true
+ };
+ }
+ catch {
+ setMessage('Use an up-to-date browser to prepare checkout.');
+ return;
+ }
+ }
+ if (!request) return;
+ if (request.action === 'prepare') pending.current = { identity: capture, request };
+ inFlight.current = true;
+ setBusy(true);
+ setSnapshot(null);
+ setAccepted(false);
+ setMessage('');
+ try {
+ if (request.action !== 'status') {
+ const result = parseDuesResult(await callTestDues(functions, auth, request));
+ if (!valid()) return;
+ pending.current = null;
+ if (result.checkoutUrl) {
+ openTestCheckout(result.checkoutUrl);
+ return;
+ }
+ }
+ const began = performance.now();
+ const wall = Date.now();
+ const value = parseDuesStatus(await callTestDues(functions, auth, {
+ action: 'status',
+ accountUid: session.user.uid
+ }));
+ if (!valid()) return;
+ const budget = Math.min(
+ 60000,
+ ...value.offers.map((o) => o.endsAtMs - value.observedAtMs),
+ ...(value.accessThroughMs ? [value.accessThroughMs - value.observedAtMs] : []),
+ );
+ if (Math.max(performance.now() - began, Date.now() - wall) >= budget) throw new Error('stale');
+ setSnapshot({
+ identity: capture, value, began, wall, budget
+ });
+ setMessage('Current test status loaded.');
+ }
+ catch {
+ if (valid()) {
+ setSnapshot(null);
+ setMessage('We could not confirm this request. Refresh status or resume the saved purchase. Do not start another payment.');
+ }
+ }
+ finally {
+ if (valid()) {
+ inFlight.current = false;
+ setBusy(false);
+ }
+ }
+ }
+ useEffect(() => {
+ if (!enabled || !auth) {
+ setSession(null);
+ return undefined;
+ }
+ return onIdTokenChanged(auth, (next) => {
+ serial.current += 1;
+ pending.current = null;
+ inFlight.current = false;
+ setSnapshot(null);
+ setAccepted(false);
+ setBusy(false);
+ setSession(next ? {
+ user: next,
+ epoch: Symbol('native-dues')
+ } : null);
+ });
+ }, [enabled, auth]);
+ useEffect(() => {
+ serial.current += 1;
+ pending.current = null;
+ inFlight.current = false;
+ setSnapshot(null);
+ setAccepted(false);
+ setBusy(false);
+ setMessage('');
+ if (current()) perform();
+ return () => { serial.current += 1; };
+ }, [identity]);
+ useEffect(() => {
+ if (!snapshot) return undefined;
+ let timer: number;
+ const expire = () => {
+ window.clearTimeout(timer);
+ const remaining = snapshot.budget - Math.max(
+ performance.now() - snapshot.began,
+ Date.now() - snapshot.wall,
+ );
+ if (remaining <= 0) {
+ setSnapshot(null);
+ setAccepted(false);
+ setMessage('Refresh status before continuing.');
+ }
+ else timer = window.setTimeout(expire, Math.ceil(remaining));
+ };
+ expire();
+ window.addEventListener('focus', expire);
+ document.addEventListener('visibilitychange', expire);
+ return () => {
+ window.clearTimeout(timer);
+ window.removeEventListener('focus', expire);
+ document.removeEventListener('visibilitychange', expire);
+ };
+ }, [snapshot]);
+ const canBuy = status && !status.active && (!status.order || status.order.state === 'expired');
+ let accountMessage = '';
+ if (!enabled) accountMessage = 'Test checkout is not connected here yet.';
+ else if (isLoading) accountMessage = 'Loading account…';
+ else if (user?.uid && !current()) accountMessage = 'Verify your email and sign in again to continue.';
+ return (
+
+
+
MID-PENINSULA RUNNING CLUB
+
Test annual dues
+
+ Staging only. Use a fictional account and Stripe test details.
+ No real payment or club membership is created.
+
+
+ Membership and free events
+ {' · '}
+ My Account
+
+ {accountMessage &&
{accountMessage}
}
+ {enabled && !isLoading && !user?.uid && (
Sign in to continue)}
+ {current() && (
+ <>
+
+ {saved && (
+
+)}
+
{busy ? 'Checking test membership…' : message}
+ {status?.active &&
Your test membership is active.
}
+ {status?.order && (
+
+ Your saved purchase
+ {`Status: ${status.order.state.replace(/_/g, ' ')}.`}
+ {`$${(status.order.amountMinor / 100).toFixed(2)} USD test dues.`}
+ {`Calendar-year term ends ${date(status.order.endsAtMs)}, Pacific time.`}
+ {status.order.familyId && (
+
+ {`Family ID: ${status.order.familyId}. `}
+ Invitations for other accounts are not available yet.
+ An ID alone does not grant membership.
+
+)}
+ {['prepared', 'open'].includes(status.order.state) && (
+
+)}
+ {['open', 'prepared', 'paid_pending_activation'].includes(status.order.state) && (
+
+)}
+ {['held', 'paid_pending_activation'].includes(status.order.state) && (
+
+ Ask the test owner to reconcile this purchase.
+ Keep the saved order; do not pay again.
+
+)}
+
+)}
+ {canBuy && status && (
+ <>
+
+ Read the test waiver
+ {status.waiver.text}
+
+
+
+ {status.offers.map((o) => {
+ const kind = o.planRef.includes('-family-') ? 'family' : 'individual';
+ return (
+
+ {kind === 'family' ? 'Family' : 'Individual'}
+ {`$${(o.amountMinor / 100).toFixed(2)} USD per calendar year.`}
+ {`Ends ${date(o.endsAtMs)}, Pacific time. No automatic renewal.`}
+
+
+ );
+ })}
+
+
+)}
+
+)}
+
+ );
+}
diff --git a/src/services/community/testDuesService.test.ts b/src/services/community/testDuesService.test.ts
new file mode 100644
index 00000000..65312509
--- /dev/null
+++ b/src/services/community/testDuesService.test.ts
@@ -0,0 +1,87 @@
+import { callTestDues, parseDuesResult, parseDuesStatus } from './testDuesService';
+
+const value = () => ({
+ schemaVersion: 1,
+ observedAtMs: 1792152000000,
+ active: false,
+ accessThroughMs: null,
+ order: null,
+ waiver: { version: 'synthetic-dues-v1', text: 'SYNTHETIC TEST ONLY. No real waiver.' },
+ offers: ['individual', 'family'].map((kind) => ({
+ membershipDuesCheckoutSchemaVersion: 1,
+ planRef: `dues-2026-${kind}-v1`,
+ policyVersion: 'test-dues-calendar-v1',
+ termId: 'calendar-2026',
+ amountMinor: kind === 'individual' ? 2500 : 3000,
+ currency: 'usd',
+ startsAtMs: 1767254400000,
+ endsAtMs: 1798790400000,
+ offerable: true
+ }))
+});
+test('parses only bounded test offers/status', () => {
+ expect(parseDuesStatus(value()).offers).toHaveLength(2);
+});
+test.each([{ active: true },
+ { accessThroughMs: 1798790400000 },
+ { schemaVersion: 2 },
+ { offers: [] },
+ { arbitrary: 'data' }])('rejects unknown/inconsistent status %j', (patch) => {
+ expect(() => parseDuesStatus({
+ ...value(),
+ ...patch
+ })).toThrow();
+});
+test('rejects price drift, getters and duplicate plans', () => {
+ const v = value();
+ v.offers[0].amountMinor = 1;
+ expect(() => parseDuesStatus(v)).toThrow();
+ const getter = jest.fn();
+ const a = value();
+ Object.defineProperty(a, 'order', {
+ get: getter,
+ enumerable: true
+ });
+ expect(() => parseDuesStatus(a)).toThrow();
+ expect(getter).not.toHaveBeenCalled();
+ const b = value();
+ [,
+ b.offers[1]] = [null,
+ b.offers[0]];
+ expect(() => parseDuesStatus(b)).toThrow();
+});
+test('ephemeral URL must be test Checkout on an open order', () => {
+ const order = {
+ id: 'a'.repeat(64),
+ state: 'open',
+ offerId: 'dues-2026-individual-v1',
+ amountMinor: 2500,
+ currency: 'usd',
+ endsAtMs: 1798790400000,
+ familyId: null
+ };
+ expect(parseDuesResult({
+ order,
+ checkoutUrl: 'https://checkout.stripe.com/c/pay/cs_test_synthetic'
+ }).checkoutUrl).toContain('cs_test_');
+ ['https://evil.example/c/pay/cs_test_x',
+ 'https://checkout.stripe.com/c/pay/cs_live_x'].forEach((checkoutUrl) => {
+ expect(() => parseDuesResult({
+ order,
+ checkoutUrl
+ })).toThrow();
+ });
+ expect(() => parseDuesResult({
+ order: {
+ ...order,
+ state: 'active'
+ },
+ checkoutUrl: 'https://checkout.stripe.com/c/pay/cs_test_x'
+ })).toThrow();
+});
+test('default-off frontend cannot contact Firebase', async () => {
+ await expect(callTestDues({ app: { options: { projectId: 'run-mprc-staging' } } } as any, { currentUser: null } as any, {
+ action: 'status',
+ accountUid: 'fictional'
+ })).rejects.toThrow();
+});
diff --git a/src/services/community/testDuesService.ts b/src/services/community/testDuesService.ts
new file mode 100644
index 00000000..7ea3fd21
--- /dev/null
+++ b/src/services/community/testDuesService.ts
@@ -0,0 +1,196 @@
+import { httpsCallable, Functions } from 'firebase/functions';
+import { Auth } from 'firebase/auth';
+import { COMMUNITY_ENABLED } from './communityService';
+
+export const TEST_DUES_ENABLED = COMMUNITY_ENABLED
+ && process.env.REACT_APP_TEST_DUES_STAGING === 'true';
+export type DuesRequest = {
+ action: 'status' | 'prepare' | 'resume' | 'reconcile';
+ accountUid: string;
+ requestId?: string;
+ offerId?: string;
+ waiverVersion?: string;
+ waiverAccepted?: true;
+};
+export type DuesOrder = {
+ id: string;
+ state: 'prepared' | 'open' | 'expired' | 'paid_pending_activation' | 'active' | 'held';
+ offerId: string;
+ amountMinor: number;
+ currency: 'usd';
+ endsAtMs: number;
+ familyId: string | null;
+};
+export type DuesOffer = {
+ planRef: string;
+ amountMinor: number;
+ currency: 'usd';
+ startsAtMs: number;
+ endsAtMs: number;
+ offerable: boolean;
+};
+export type DuesStatus = {
+ schemaVersion: 1;
+ observedAtMs: number;
+ offers: DuesOffer[];
+ waiver: {
+ version: string;
+ text: string;
+ };
+ active: boolean;
+ accessThroughMs: number | null;
+ order: DuesOrder | null;
+};
+const check = (v: unknown) => { if (!v) throw new Error('Test dues status is unavailable.'); };
+const integer = (v: unknown): v is number => typeof v === 'number'
+ && Number.isSafeInteger(v)
+ && v >= 0
+ && v <= 8640000000000000;
+function object(v: unknown, keys: string[], optional: string[] = []): Record
{
+ check(v !== null
+ && typeof v === 'object'
+ && !Array.isArray(v)
+ && Object.getPrototypeOf(v) === Object.prototype);
+ const d = Object.getOwnPropertyDescriptors(v);
+ check(keys.every((k) => Object.prototype.hasOwnProperty.call(d, k))
+ && Reflect.ownKeys(d).every((k) => typeof k === 'string'
+ && [...keys,
+ ...optional].includes(k)
+ && d[k].enumerable
+ && Object.prototype.hasOwnProperty.call(d[k], 'value')));
+ return Object.fromEntries(Object.entries(d).map(([k, p]) => [k, p.value]));
+}
+function offerId(v: unknown): v is string {
+ return typeof v === 'string'
+ && /^dues-\d{4}-(individual|family)-v1$/.test(v);
+}
+function price(v: Record) {
+ check(offerId(v.offerId ?? v.planRef) && v.currency === 'usd'
+ && v.amountMinor === (String(v.offerId ?? v.planRef).includes('-individual-') ? 2500 : 3000));
+}
+function order(v: unknown): DuesOrder | null {
+ if (v === null) return null;
+ const o = object(v, ['id',
+ 'state',
+ 'offerId',
+ 'amountMinor',
+ 'currency',
+ 'endsAtMs',
+ 'familyId']);
+ price(o);
+ check(typeof o.id === 'string' && /^[a-f0-9]{64}$/.test(o.id) && integer(o.endsAtMs)
+ && ['prepared',
+ 'open',
+ 'expired',
+ 'paid_pending_activation',
+ 'active',
+ 'held'].includes(o.state)
+ && (o.familyId === null
+ || (o.state === 'active'
+ && o.offerId.includes('-family-')
+ && o.familyId === `family-${o.id.slice(0, 32)}`)));
+ return o as DuesOrder;
+}
+export function parseDuesStatus(v: unknown): DuesStatus {
+ try {
+ const s = object(v, ['schemaVersion',
+ 'observedAtMs',
+ 'offers',
+ 'waiver',
+ 'active',
+ 'accessThroughMs',
+ 'order']);
+ check(s.schemaVersion === 1 && integer(s.observedAtMs) && typeof s.active === 'boolean'
+ && (s.active ? integer(s.accessThroughMs)
+ && s.accessThroughMs > s.observedAtMs : s.accessThroughMs === null));
+ check(Array.isArray(s.offers));
+ const entries = Object.getOwnPropertyDescriptors(s.offers);
+ check(entries.length?.value === 2 && Reflect.ownKeys(entries).length === 3);
+ const plans = [0, 1].map((index) => {
+ const descriptor = entries[String(index)];
+ check(descriptor?.enumerable
+ && Object.prototype.hasOwnProperty.call(descriptor, 'value'));
+ const p = object(descriptor.value, ['membershipDuesCheckoutSchemaVersion',
+ 'planRef',
+ 'policyVersion',
+ 'termId',
+ 'amountMinor',
+ 'currency',
+ 'startsAtMs',
+ 'endsAtMs',
+ 'offerable']);
+ price(p);
+ check(p.membershipDuesCheckoutSchemaVersion === 1
+ && p.policyVersion === 'test-dues-calendar-v1'
+ && p.termId === `calendar-${p.planRef.slice(5, 9)}`
+ && integer(p.startsAtMs)
+ && integer(p.endsAtMs)
+ && p.startsAtMs <= s.observedAtMs
+ && s.observedAtMs < p.endsAtMs
+ && typeof p.offerable === 'boolean');
+ return p as DuesOffer;
+ });
+ check(plans[0].planRef !== plans[1].planRef
+ && plans[0].startsAtMs === plans[1].startsAtMs
+ && plans[0].endsAtMs === plans[1].endsAtMs);
+ const w = object(s.waiver, ['version', 'text']);
+ check(w.version === 'synthetic-dues-v1'
+ && typeof w.text === 'string'
+ && w.text.length <= 2000
+ && w.text.startsWith('SYNTHETIC TEST ONLY.'));
+ return {
+ schemaVersion: 1,
+ observedAtMs: s.observedAtMs,
+ offers: plans,
+ waiver: {
+ version: w.version,
+ text: w.text
+ },
+ active: s.active,
+ accessThroughMs: s.accessThroughMs,
+ order: order(s.order)
+ };
+ }
+ catch {
+ throw new Error('Test dues status is unavailable.');
+ }
+}
+export function parseDuesResult(v: unknown): {
+ order: DuesOrder;
+ checkoutUrl?: string;
+} {
+ const r = object(v, ['order'], ['checkoutUrl']);
+ const o = order(r.order);
+ check(o);
+ if (r.checkoutUrl !== undefined) {
+ check(o?.state === 'open' && typeof r.checkoutUrl === 'string' && r.checkoutUrl.length <= 4096);
+ const u = new URL(r.checkoutUrl);
+ check(u.protocol === 'https:'
+ && u.hostname === 'checkout.stripe.com'
+ && !u.username
+ && !u.password
+ && !u.port
+ && u.pathname.startsWith('/c/pay/cs_test_'));
+ }
+ return { order: o as DuesOrder, ...(r.checkoutUrl ? { checkoutUrl: r.checkoutUrl } : {}) };
+}
+export async function callTestDues(
+ functions: Functions,
+ auth: Auth,
+ request: DuesRequest,
+): Promise {
+ const user = auth.currentUser;
+ const bound = () => TEST_DUES_ENABLED
+ && functions.app.options.projectId === 'run-mprc-staging'
+ && auth.app === functions.app
+ && auth.tenantId === null
+ && user
+ && auth.currentUser === user
+ && user.uid === request.accountUid
+ && user.emailVerified;
+ if (!bound()) throw new Error('Test dues are unavailable.');
+ const result = await httpsCallable(functions, 'membershipTestDues')(request);
+ if (!bound()) throw new Error('Test dues are unavailable.');
+ return result.data;
+}
+export function openTestCheckout(url: string) { window.location.assign(url); }
diff --git a/tests/ci-workflow.test.js b/tests/ci-workflow.test.js
index 50e1feaf..0249d826 100644
--- a/tests/ci-workflow.test.js
+++ b/tests/ci-workflow.test.js
@@ -43,7 +43,7 @@ const CLEAN_COMMANDS = Object.freeze([
'test -z "$frontend_git_status"',
]);
const LINT_SCRIPT = 'node .github/scripts/check-frontend-lint.cjs';
-const EXPECTED_LINT_FILES = 133;
+const EXPECTED_LINT_FILES = 137;
const EXPECTED_LINT_ERRORS = 113;
const EXPECTED_LINT_WARNINGS = 6;
const YAML_TO_JSON = [
diff --git a/tests/firestore-rules/shop-and-locked.test.js b/tests/firestore-rules/shop-and-locked.test.js
index cb52b51b..f10270f3 100644
--- a/tests/firestore-rules/shop-and-locked.test.js
+++ b/tests/firestore-rules/shop-and-locked.test.js
@@ -774,6 +774,14 @@ describe('server-only operational collections', () => {
['promoCodes/PROMO1', 'promoCodes/PROMO2', { discountPercent: 10 }],
['ratelimits/checkout_ip__1.2.3.4', 'ratelimits/checkout_ip__5.6.7.8', { count: 5 }],
['mail/message1', 'mail/message2', { to: ['runner@example.com'] }],
+ ['membershipTestOrders/fictional1', 'membershipTestOrders/fictional2', { schemaVersion: 1 }],
+ ['membershipTestAccounts/fictional1', 'membershipTestAccounts/fictional2', { schemaVersion: 1 }],
+ ['membershipTestParticipants/fictional1', 'membershipTestParticipants/fictional2', { schemaVersion: 1 }],
+ ['membershipTestTerms/fictional1', 'membershipTestTerms/fictional2', { schemaVersion: 1 }],
+ ['membershipTestFamilies/fictional1', 'membershipTestFamilies/fictional2', { schemaVersion: 1 }],
+ ['membershipTestEvents/fictional1', 'membershipTestEvents/fictional2', { schemaVersion: 1 }],
+ ['membershipTestAudit/fictional1', 'membershipTestAudit/fictional2', { schemaVersion: 1 }],
+ ['membershipTestLimits/fictional1', 'membershipTestLimits/fictional2', { schemaVersion: 1 }],
['stripeEvents/evt_test_1', 'stripeEvents/evt_test_2', { status: 'processed' }],
['checkoutRequests/request1', 'checkoutRequests/request2', { status: 'created' }],
['auditEvents/audit1', 'auditEvents/audit2', { action: 'refund' }],
From 54dd8a9e284d3b86fb14b17531b56945b0691321 Mon Sep 17 00:00:00 2001
From: Dave Liu <7david12liu@gmail.com>
Date: Fri, 16 Oct 2026 18:57:00 -0700
Subject: [PATCH 2/4] Keep prepared dues request explicit for optimized type
checking
---
src/pages/community/TestDues.tsx | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/pages/community/TestDues.tsx b/src/pages/community/TestDues.tsx
index 75970a9e..7b1154db 100644
--- a/src/pages/community/TestDues.tsx
+++ b/src/pages/community/TestDues.tsx
@@ -81,7 +81,8 @@ export default function TestDues() {
if (action === 'prepare' && !retry) {
try {
request = {
- ...request,
+ action: 'prepare',
+ accountUid: session.user.uid,
requestId: crypto.randomUUID(),
offerId,
waiverVersion: status?.waiver.version,
From 7bbcebdb451a452da8e468c0baf97b1c650771ee Mon Sep 17 00:00:00 2001
From: Dave Liu <7david12liu@gmail.com>
Date: Fri, 16 Oct 2026 19:05:32 -0700
Subject: [PATCH 3/4] Fence dues recovery and bind exact verified Checkout
navigation
---
docs/TEST_DUES_ENGINEERING.md | 4 ++--
functions/testDuesStripe.js | 8 ++++----
functions/testDuesStripe.test.js | 10 ++++++++++
functions/testMembershipDues.js | 7 ++++++-
functions/testMembershipDues.test.js | 9 +++++++++
5 files changed, 31 insertions(+), 7 deletions(-)
diff --git a/docs/TEST_DUES_ENGINEERING.md b/docs/TEST_DUES_ENGINEERING.md
index 6117e2de..067b673b 100644
--- a/docs/TEST_DUES_ENGINEERING.md
+++ b/docs/TEST_DUES_ENGINEERING.md
@@ -4,11 +4,11 @@ This bounded staging integration consumes `membershipDuesCheckout`, `membershipD
## Trust and transitions
-Native callable Auth/App Check, matching caller/default tenant, recent verified token and current enabled/verified Auth metadata precede requests. The private `membershipTestParticipants/{uid}` marker must be current and synthetic; it is never a profile role. Exact staging or all three explicit loopback emulator hosts under a demo project, `COMMERCE_ENABLED=false` and `MPRC_TEST_DUES_ENABLED=true` are required. The frontend additionally needs its default-off staging flag. There is no production/live fallback.
+Native callable Auth/App Check, matching caller/default tenant, recent verified token and current enabled/verified Auth metadata precede requests. The private `membershipTestParticipants/{uid}` marker must be current and synthetic, including before reconciliation consumes a provider read or rate write; it is never a profile role. Exact staging or all three explicit loopback emulator hosts under a demo project, `COMMERCE_ENABLED=false` and `MPRC_TEST_DUES_ENABLED=true` are required. The frontend additionally needs its default-off staging flag. There is no production/live fallback.
Server offers fix 2500/3000 integer USD cents, LA calendar boundaries and a synthetic consent version/hash. No future term, automatic renewal or public external-payment instructions. One account lock and request-derived order ID are committed with immutable expectation, nonce, price, consent, expiration and provider idempotency key before any Checkout creation. Parallel commands/plans conflict; an exact request reuses byte-identical provider parameters. Unbound creation retries stop after five minutes, well within the provider's idempotency retention. Past that horizon the unresolved order stays held for private reconciliation; never guess that it is safe to charge again. Bound open Sessions are retrieved for resume. Verified empty expired Sessions may release the purchase lock; paid/held/pending orders cannot be discarded for a replacement purchase in the same year.
-The adapter verifies the actual Stripe account for each operation, accepts only test credentials and objects, fixes Checkout URLs, and projects no customer/contact data. Raw signed webhook bodies are bounded and verified before a minimal durable event receipt. SDK retrieval checks Session, nonce/order/client reference, test realm, amount/currency and current PaymentIntent/Charge, including refunds/disputes before an older paid callback. Charge reversals resolve the exact Session with a bounded PaymentIntent query. Invalid or foreign observations grant nothing. Duplicate/out-of-order deliveries re-read current provider state and cannot regress an active/held term. Cancellation return is a read, never a payment or refund command.
+The adapter verifies the actual Stripe account for each operation, accepts only test credentials and objects, binds each Checkout URL to its verified exact Session, rejects malformed refund counters, and projects no customer/contact data. Raw signed webhook bodies are bounded and verified before a minimal durable event receipt. SDK retrieval checks Session, nonce/order/client reference, test realm, amount/currency and current PaymentIntent/Charge, including refunds/disputes before an older paid callback. Charge reversals resolve the exact Session with a bounded PaymentIntent query. Invalid or foreign observations grant nothing. Duplicate/out-of-order deliveries re-read current provider state and cannot regress an active/held term. Cancellation return is a read, never a payment or refund command.
Verified paid evidence, immutable term receipt, canonical `communityMemberships/{uid}` activation, optional private family root and transition audit are atomic. Changed revision/withdrawal/suspension/association, invalid current account/participant or an expired original term leaves durable paid-pending evidence. No silent rebase, renewal, unsuspension or refund. A defensive test reversal holds the order permanently and suspends only the authority still bound to that payment; it cannot revoke a later unrelated term. This is deliberately not real refund policy. Auth metadata is rechecked immediately before the transaction but cannot be atomically locked with Firestore; native distributed revocation guarantees are not claimed.
diff --git a/functions/testDuesStripe.js b/functions/testDuesStripe.js
index a4142b42..e2ffc1cb 100644
--- a/functions/testDuesStripe.js
+++ b/functions/testDuesStripe.js
@@ -3,8 +3,8 @@
const Stripe = require('stripe');
const { check, RETURN_URL } = require('./testDuesPolicy');
const ref = (s, prefix) => typeof s === 'string' && new RegExp(`^${prefix}_[A-Za-z0-9]{1,120}$`).test(s);
-function checkoutUrl(url) {
- try { const u = new URL(url); check(u.protocol === 'https:' && u.hostname === 'checkout.stripe.com' && !u.username && !u.password && !u.port && u.pathname.startsWith('/c/pay/cs_test_')); return url; } catch { check(false); }
+function checkoutUrl(url, sessionId) {
+ try { const u = new URL(url); check(u.protocol === 'https:' && u.hostname === 'checkout.stripe.com' && !u.username && !u.password && !u.port && u.pathname.startsWith('/c/pay/cs_test_') && (!sessionId || u.pathname === `/c/pay/${sessionId}`)); return url; } catch { check(false); }
}
function checkoutParameters(o) {
return { mode: 'payment', payment_method_types: ['card'], client_reference_id: o.id,
@@ -34,7 +34,7 @@ function createTestStripe({ key, webhookSecret, account }) {
const c = pi.latest_charge;
if (c) {
check(typeof c === 'object' && ref(c.id, 'ch') && c.livemode === false && c.payment_intent === pi.id
- && c.amount === s.amount_total && c.currency === s.currency && typeof c.disputed === 'boolean' && Number.isSafeInteger(c.amount_refunded));
+ && c.amount === s.amount_total && c.currency === s.currency && typeof c.disputed === 'boolean' && Number.isSafeInteger(c.amount_refunded) && c.amount_refunded >= 0 && c.amount_refunded <= c.amount);
reversal = c.disputed || c.amount_refunded > 0;
}
paid = s.status === 'complete' && s.payment_status === 'paid' && pi.status === 'succeeded'
@@ -44,7 +44,7 @@ function createTestStripe({ key, webhookSecret, account }) {
return { checkoutRef: s.id, orderId: s.metadata.order, nonce: s.metadata.nonce, providerAccountRef: account,
livemode: false, amountMinor: s.amount_total, currency: s.currency, paymentRef, paid, reversal,
expired: s.status === 'expired' && s.payment_status === 'unpaid' && !s.payment_intent,
- ...(includeUrl && s.status === 'open' && s.url ? { url: checkoutUrl(s.url) } : {}),
+ ...(includeUrl && s.status === 'open' && s.url ? { url: checkoutUrl(s.url, s.id) } : {}),
};
}
return {
diff --git a/functions/testDuesStripe.test.js b/functions/testDuesStripe.test.js
index a84de2b4..d12b366e 100644
--- a/functions/testDuesStripe.test.js
+++ b/functions/testDuesStripe.test.js
@@ -60,3 +60,13 @@ test('only ephemeral test Checkout URL can be returned', () => {
expect(checkoutUrl('https://checkout.stripe.com/c/pay/cs_test_synthetic')).toContain('cs_test_');
for (const url of ['https://checkout.stripe.com.evil/c/pay/cs_test_x', 'https://checkout.stripe.com/c/pay/cs_live_x', 'http://checkout.stripe.com/c/pay/cs_test_x', 'https://user@checkout.stripe.com/c/pay/cs_test_x']) expect(() => checkoutUrl(url)).toThrow();
});
+
+test.each([-1, 1.5, 2501])('malformed refunded amount rejects without activation: %s', async amount => {
+ const pi = intent(); pi.latest_charge.amount_refunded = amount;
+ sdk.paymentIntents.retrieve.mockResolvedValue(pi);
+ await expect(adapter.retrieve('cs_test_synthetic')).rejects.toThrow();
+});
+test('Checkout URL must point at the verified exact Session', async () => {
+ sdk.checkout.sessions.retrieve.mockResolvedValue({ ...session(), status: 'open', payment_status: 'unpaid', payment_intent: null, url: 'https://checkout.stripe.com/c/pay/cs_test_foreign' });
+ await expect(adapter.retrieve('cs_test_synthetic', true)).rejects.toThrow();
+});
diff --git a/functions/testMembershipDues.js b/functions/testMembershipDues.js
index a343bb98..78be277a 100644
--- a/functions/testMembershipDues.js
+++ b/functions/testMembershipDues.js
@@ -155,7 +155,12 @@ function createTestDuesService({ db, auth, provider, account, clock = Date.now }
}
async function resume(uid) { await actor(uid); return open(uid, await latest(uid)); }
async function reconcile(uid) {
- await actor(uid); await rate(uid); const o = await latest(uid); check(o.checkoutRef);
+ await actor(uid);
+ await db.runTransaction(async tx => {
+ const p = await tx.get(participantRef(uid));
+ check(marked(p.data(), clock()), 'permission-denied');
+ });
+ await rate(uid); const o = await latest(uid); check(o.checkoutRef);
return { order: await observe(await provider.retrieve(o.checkoutRef)) };
}
async function webhook(event) {
diff --git a/functions/testMembershipDues.test.js b/functions/testMembershipDues.test.js
index ea16320d..ea837928 100644
--- a/functions/testMembershipDues.test.js
+++ b/functions/testMembershipDues.test.js
@@ -124,3 +124,12 @@ test('revoked marker/current disabled account blocks resume and no extra provide
f.docs.delete(`membershipTestParticipants/${UID}`); await expect(f.service.resume(UID)).rejects.toThrow(); expect(f.provider.create).toHaveBeenCalledTimes(1);
f.disable(); await expect(f.service.status(UID)).rejects.toThrow();
});
+
+test('revoked synthetic participant cannot reconcile or consume provider/rate resources', async () => {
+ const f = fixture(); await f.service.prepare(UID, f.request());
+ f.docs.delete(`membershipTestParticipants/${UID}`);
+ const before = JSON.stringify([...f.docs]);
+ await expect(f.service.reconcile(UID)).rejects.toThrow();
+ expect(f.provider.retrieve).not.toHaveBeenCalled();
+ expect(JSON.stringify([...f.docs])).toBe(before);
+});
From fec9127ff2727b83a675064e9e6fc050189da0f6 Mon Sep 17 00:00:00 2001
From: Dave Liu <7david12liu@gmail.com>
Date: Fri, 16 Oct 2026 19:10:43 -0700
Subject: [PATCH 4/4] Show annual renewal and useful saved-purchase recovery
controls
---
docs/officers/TEST_DUES.md | 2 +-
functions/testMembershipDues.test.js | 16 ++++++++++++++++
src/pages/community/TestDues.test.tsx | 23 +++++++++++++++++++++++
src/pages/community/TestDues.tsx | 12 +++++++++---
4 files changed, 49 insertions(+), 4 deletions(-)
diff --git a/docs/officers/TEST_DUES.md b/docs/officers/TEST_DUES.md
index 4bf43ff3..362cf7eb 100644
--- a/docs/officers/TEST_DUES.md
+++ b/docs/officers/TEST_DUES.md
@@ -30,7 +30,7 @@
**Stop conditions:** real information or money is requested; the test notice disappears; another account's state appears; an unresolved purchase offers another charge; an old term extends into a new year; a failed read leaves controls; or a provider, account, App Check or release check is missing. Near year end, checkout may be unavailable because the provider's minimum session lifetime would cross the term boundary.
-**Uncertain or held purchase:** keep the saved order and ask Dave for specialist reconciliation through a tracked change. Do not pay again, edit records, grant roles, issue refunds or change provider settings. Payment received after withdrawal, suspension, account loss, conflicting revisions or term expiry is retained for reconciliation rather than overriding that state. Rechecking verified identity can finish an otherwise unchanged pending activation. Any observed test refund/dispute places a sticky defensive hold; this does not choose a real club refund policy.
+**Uncertain or held purchase:** keep the saved order and ask Dave for specialist reconciliation through a tracked change. A declined-card attempt can retain a provider payment record even after checkout expires; it stays locked for specialist reconciliation. Do not pay again, edit records, grant roles, issue refunds or change provider settings. Payment received after withdrawal, suspension, account loss, conflicting revisions or term expiry is retained for reconciliation rather than overriding that state. Rechecking verified identity can finish an otherwise unchanged pending activation. Any observed test refund/dispute places a sticky defensive hold; this does not choose a real club refund policy.
**Success proof:** exact reviewed head and green CI, native Firestore concurrency results, actual Stripe sandbox account/webhook verification, genuine staging identity/App Check, matching Function and Hosting release receipts, dated phone/desktop checks, and exact owned cleanup. Unit doubles, generated signatures and emulator transactions do not prove native Stripe or hosted payment behavior.
diff --git a/functions/testMembershipDues.test.js b/functions/testMembershipDues.test.js
index ea837928..8b5cf91a 100644
--- a/functions/testMembershipDues.test.js
+++ b/functions/testMembershipDues.test.js
@@ -133,3 +133,19 @@ test('revoked synthetic participant cannot reconcile or consume provider/rate re
expect(f.provider.retrieve).not.toHaveBeenCalled();
expect(JSON.stringify([...f.docs])).toBe(before);
});
+
+test('old-year reversal cannot suspend a later paid membership term', async () => {
+ const f = fixture(); await f.service.prepare(UID, f.request()); f.paid(); await f.service.reconcile(UID);
+ const old = f.getOrder();
+ f.setNow(yearStart(2027)); f.docs.set(`membershipTestParticipants/${UID}`, { schemaVersion: 1, synthetic: true, expiresAtMs: f.now() + 86400000 });
+ f.provider.create.mockImplementationOnce(async next => {
+ f.setObservation({ orderId: next.id, nonce: next.nonce, checkoutRef: 'cs_test_newyear', paymentRef: null, paid: false, reversal: false });
+ return f.provider.retrieve();
+ });
+ await f.service.prepare(UID, f.request());
+ f.setObservation({ paid: true, paymentRef: 'pi_newyear' }); await f.service.reconcile(UID);
+ const before = f.docs.get(`communityMemberships/${UID}`); expect(before.authority.term.termId).toBe('calendar-2027');
+ f.setObservation({ orderId: old.id, nonce: old.nonce, checkoutRef: 'cs_test_fictional', paymentRef: 'pi_fictional', paid: false, reversal: true });
+ await f.service.webhook(f.event('evt_oldyear_reversal'));
+ expect(f.docs.get(`communityMemberships/${UID}`)).toEqual(before); expect((await f.service.status(UID)).active).toBe(true);
+});
diff --git a/src/pages/community/TestDues.test.tsx b/src/pages/community/TestDues.test.tsx
index ad470a0f..1bc6e875 100644
--- a/src/pages/community/TestDues.test.tsx
+++ b/src/pages/community/TestDues.test.tsx
@@ -195,3 +195,26 @@ test('bad response hides all purchase controls', async () => {
await screen.findByText(/We could not confirm/);
expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
});
+
+test('after a paid year ends the current-year offer is available without showing old access', async () => {
+ const now = 1798790400000;
+ const next = { ...state(), observedAtMs: now, order: { ...order, state: 'active', endsAtMs: now } };
+ next.offers = next.offers.map((p) => ({
+ ...p,
+planRef: p.planRef.replace('2026', '2027'),
+ termId: 'calendar-2027',
+startsAtMs: now,
+endsAtMs: 1830326400000
+}));
+ call.mockResolvedValue(next); render(show());
+ expect(await screen.findByRole('button', { name: 'Continue to individual test checkout' })).toBeDisabled();
+ expect(screen.getByText('Payment confirmed. That term has ended.')).toBeInTheDocument();
+ expect(screen.queryByText('Your test membership is active.')).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('checkbox'));
+ expect(screen.getByRole('button', { name: 'Continue to individual test checkout' })).toBeEnabled();
+});
+test('an unbound prepared order offers resume rather than a doomed payment check', async () => {
+ call.mockResolvedValue({ ...state(), order: { ...order, state: 'prepared' } }); render(show());
+ expect(await screen.findByRole('button', { name: 'Resume saved checkout' })).toBeEnabled();
+ expect(screen.queryByRole('button', { name: 'Check payment status' })).not.toBeInTheDocument();
+});
diff --git a/src/pages/community/TestDues.tsx b/src/pages/community/TestDues.tsx
index 7b1154db..fe5b6cca 100644
--- a/src/pages/community/TestDues.tsx
+++ b/src/pages/community/TestDues.tsx
@@ -196,7 +196,10 @@ export default function TestDues() {
document.removeEventListener('visibilitychange', expire);
};
}, [snapshot]);
- const canBuy = status && !status.active && (!status.order || status.order.state === 'expired');
+ const previousTermPaid = status?.order?.state === 'active'
+ && status.order.endsAtMs <= status.observedAtMs;
+ const canBuy = status && !status.active
+ && (!status.order || status.order.state === 'expired' || previousTermPaid);
let accountMessage = '';
if (!enabled) accountMessage = 'Test checkout is not connected here yet.';
else if (isLoading) accountMessage = 'Loading account…';
@@ -230,7 +233,10 @@ export default function TestDues() {
{status?.order && (
Your saved purchase
- {`Status: ${status.order.state.replace(/_/g, ' ')}.`}
+
+ {previousTermPaid ? 'Payment confirmed. That term has ended.'
+ : `Status: ${status.order.state.replace(/_/g, ' ')}.`}
+
{`$${(status.order.amountMinor / 100).toFixed(2)} USD test dues.`}
{`Calendar-year term ends ${date(status.order.endsAtMs)}, Pacific time.`}
{status.order.familyId && (
@@ -245,7 +251,7 @@ export default function TestDues() {
Resume saved checkout
)}
- {['open', 'prepared', 'paid_pending_activation'].includes(status.order.state) && (
+ {['open', 'paid_pending_activation'].includes(status.order.state) && (