How Tidex calculates your pay

Inputs

• Shift data: shift_date (ISO), start_time (HH:MM), end_time (HH:MM), optional custom pause windows, optional custom supplements, job_id
• Wage snapshot: Hourly wage, supplement rules, tax settings, break deduction settings — scoped to a job
• Job: Name, color, immutable currency, payroll_day, half_tax_month, monthly_goal — primary source for payroll configuration
• Payroll adjustments: Manual payout-level additions or corrections with amount, payout date, job scope, and tax treatment
• User settings: Global preferences; payroll_day/half_tax_month/monthly_goal kept as legacy fallback during compatibility window

Outputs

• computeShift output: durationHours, paidHours, basePay, supplementPay, gross, wagePeriods, originalWagePeriods, breakAudit
• breakAudit output: method, thresholdHours, deductedHours, source, appliedPauseWindows, notes
• Downstream totals output: taxAmount and net (calculated outside computeShift), plus payroll adjustment gross/net totals for payout cards

Key invariants

• Deterministic: Same inputs always produce same outputs
• Pure computation: Zero I/O, all inputs explicit
• Cross-midnight support: Shifts spanning midnight are calculated as continuous time
• Dual-date snapshot logic: Wage/supplements/breaks use shift date; tax uses payout date
• Precision: Exact minute-based hours; round each shift pay component once to 2 decimal places
• Job-scoped snapshots: Each shift uses wage snapshots belonging to the same job; local rollout fallbacks may use default-job or legacy job-less snapshots when no scoped rows exist
• Job-scoped payroll day: payroll_day is resolved from the shift's job first, then the default job, then user settings

Definitions

recurring_shifts - Recurring shift templates

Virtual shifts are generated at runtime, never persisted. selected_days keys are weekday numbers (0=Sunday to 6=Saturday). A recurring pattern and all its virtual shifts belong to one job — there is no per-occurrence job override. Generated virtual shifts inherit any date-specific pause windows, date-specific supplements, and date-specific private notes for their occurrence date.

wage_snapshots - Point-in-time wage settings

Snapshots are job-scoped: one baseline (from_date = NULL) allowed per (user, job) pair. Snapshot selection uses shift date for wage/supplements/breaks, but payout date for tax settings. The live database has backfilled snapshots to non-null job_id; job-less snapshots remain supported only as rollout/local compatibility fallback.

user_settings - Global user preferences

DB triggers keep user_settings and the default job in sync bidirectionally. The jobs table is the authoritative source for payroll_day, half_tax_month, monthly_goal, and currency in job-aware clients. Resolution order for payroll_day: shift job value → default job value → user_settings.payroll_day → 1.

payroll_adjustments - Manual payout corrections

The database validates that explicit job_id values belong to the same active user-owned job. Adjustment rows are synced through the local-first iOS store and protected by the same owner-scoped RLS model as shifts.

SupplementRule structure

type SupplementRule = {
  days: number[];    // 1-7 (1=Monday, 7=Sunday)
  from: string;      // "HH:MM" (inclusive)
  to: string;        // "HH:MM" (exclusive)
  rate?: number;     // Fixed amount per hour in the job currency (mutually exclusive with percent)
  percent?: number;  // Percentage of base rate (mutually exclusive with rate)
};

// Example rules:
[
  { "days": [1,2,3,4,5], "from": "18:00", "to": "21:00", "rate": 22 },
  { "days": [6], "from": "13:00", "to": "24:00", "rate": 110 },
  { "days": [7], "from": "00:00", "to": "24:00", "rate": 115 }
]

Preset supplement rules (tariff default)

jobs table

Unique constraint: UNIQUE (user_id) WHERE is_default = true AND deleted_at IS NULL AND archived_at IS NULL — exactly one active default per user.

Backward compatibility

• Assign the user's default job to any shift, recurring shift, or wage snapshot written without job_id
• Mirror payroll_day, half_tax_month, and monthly_goal between user_settings and the default job in both directions
• Ensure every user has a default job, creating one on-the-fly if missing

Legacy user_settings fields (payroll_day, half_tax_month, monthly_goal) will not be removed until telemetry confirms all clients are job-aware.

Payroll day resolution

const payrollDayForJob = (targetJobId?: string | null): number =>
  jobsById.get(targetJobId ?? '')?.payroll_day   // 1. Job's own payroll_day
  ?? defaultJob?.payroll_day                      // 2. Default job's payroll_day
  ?? userSettings?.payroll_day                    // 3. Legacy user_settings fallback
  ?? 1;                                           // 4. Hard fallback

Pipeline steps

const [shifts, recurringShifts, jobs, allSnapshots] = await Promise.all([
  supabase.from("user_shifts")
    .select("*").eq("user_id", userId).is("deleted_at", null)
    .gte("shift_date", startDate).lte("shift_date", endDate).limit(limit),

  supabase.from("recurring_shifts")
    .select("*").eq("user_id", userId).is("deleted_at", null),

  supabase.from("jobs")
    .select("*").eq("user_id", userId).is("deleted_at", null)
    .order("sort_order", { ascending: true }),

  supabase.from("wage_snapshots")
    .select("*").eq("user_id", userId).is("deleted_at", null)
    .order("from_date", { ascending: false, nullsFirst: false }),
]);

const buckets = new Map<string, { dated: WageSnapshot[]; baseline: WageSnapshot | null }>();

for (const snapshot of allSnapshots) {
  const key = snapshot.job_id ?? '__legacy__';
  const bucket = buckets.get(key) ?? { dated: [], baseline: null };
  if (snapshot.from_date === null) bucket.baseline = snapshot;
  else bucket.dated.push(snapshot);
  buckets.set(key, bucket);
}

for (const bucket of buckets.values()) {
  bucket.dated.sort((a, b) => b.from_date.localeCompare(a.from_date));
}

function generateVirtualShiftsForMonth(
  yearMonth: { year: number; month: number },
  draft: RecurringDraft
): RecurringVirtualShift[]

function isInPhase(dateISO, anchorISO, interval) {
  if (interval === 0) return true; // Every week

  const daysDiff = (date - anchor) / (24 * 60 * 60 * 1000);
  const weeksDiff = Math.floor(daysDiff / 7);

  // interval 1 = every 2 weeks, interval 2 = every 3 weeks
  return weeksDiff % (interval + 1) === 0;
}

for (const shift of shifts) {
  const shiftJobId = shift.job_id ?? defaultJobId;
  const payrollDay =
    jobsById.get(shiftJobId)?.payroll_day
    ?? defaultJob?.payroll_day
    ?? userSettings?.payroll_day
    ?? 1;

  const scopedSnapshots = snapshotsForJob(
    shiftJobId,
    snapshotsByJobId,
    legacyNilJobSnapshots,
    defaultJobId
  );

  // Wage/supplement/break snapshot: use shift date, job-scoped
  const wageSnapshot = snapshotForDate(shift.shift_date, scopedSnapshots);

  // Tax snapshot: use payout date for THIS shift's job
  const payoutDate = calculatePayoutDate(shift.shift_date, payrollDay);
  const taxSnapshot = snapshotForDate(payoutDate, scopedSnapshots);

  const computed = PayrollCalculator.computeShift(shift, snapshot: wageSnapshot);

  result.push({
    ...shift, job_id: shiftJobId, computed,
    tax_enabled: taxSnapshot?.tax_enabled ?? false,
    tax_percentage: taxSnapshot?.tax_percentage ?? 0,
  });
}

Date-range inclusion rules

• Boundaries are inclusive on both ends
• Query: shift_date >= startDate AND shift_date <= endDate
• For overnight shifts: The shift belongs to the start date

A shift from 22:00 to 06:00 on 2025-01-15 is queried by shift_date = 2025-01-15

Cross-midnight handling

// Detection
const isCrossMidnight = endTime <= startTime;

// Treatment in calculation
let start = toMin(startHHMM); // e.g., 22:00 = 1320
let end = toMin(endHHMM);     // e.g., 06:00 = 360
if (end <= start) {
  end += 24 * 60;             // 360 + 1440 = 1800
}
// Duration: 1800 - 1320 = 480 minutes = 8 hours

Rule weekdays identify when each window starts. The engine includes overnight windows carried from the previous day and rules starting on the next day. Saturday supplements therefore give way to Sunday supplements at midnight; overlapping windows use the highest rate.

Payout date calculation

function calculatePayoutDate(
  earningsYear: number,
  earningsMonth: number, // 1-12
  payrollDay: number
): string {
  // Payout month is earnings month + 1
  let payoutYear = earningsYear;
  let payoutMonth = earningsMonth + 1;

  if (payoutMonth > 12) {
    payoutMonth = 1;
    payoutYear += 1;
  }

  // Handle edge case: payroll_day exceeds days in payout month
  const daysInPayoutMonth = new Date(payoutYear, payoutMonth, 0).getDate();
  const effectivePayrollDay = Math.min(Math.max(payrollDay, 1), daysInPayoutMonth);

  return `${payoutYear}-${padZero(payoutMonth)}-${padZero(effectivePayrollDay)}`;
}

// Example:
// Shift on 2025-01-15, payroll day = 20
// Earnings month = January (1)
// Payout month = February (2)
// Payout date = 2025-02-20

Payout date adjustment for holidays

function adjustPayrollDate(
  payrollDay: number,
  month: number,      // 0-11 (JavaScript Date format)
  year: number,
  locale: Locale = 'no'
): Date {
  let date = new Date(year, month, payrollDay);

  // Move backward until valid payroll day found (max 10 iterations)
  while (isInvalidPayrollDay(date, locale)) {
    date.setDate(date.getDate() - 1);
  }

  return date;
}

function isInvalidPayrollDay(date: Date, locale: Locale): boolean {
  return isWeekend(date) || isMonday(date) || isPublicHoliday(date, locale);
}

This adjustment is used for payroll date display/countdown UX. Snapshot selection for tax uses calculatePayoutDate() (unadjusted). Holiday detection includes fixed and Easter-based Norwegian public holidays. Raw payroll_day values are clamped to the valid range for the payout month before a payout date is emitted.

Job-scoped snapshot selection algorithm

// Shared Wagey TypeScript resolver
const resolveSnapshotForDate = (
  buckets: Map<string, SnapshotBucket>,
  snapshots: WageSnapshot[],
  date: string,
  jobId?: string | null
): WageSnapshot | null => {
  // Try job-specific bucket first, then legacy fallback
  const preferredKeys = [jobId ?? '__legacy__', '__legacy__'];

  // 1. Try dated snapshots (bucket is sorted DESC — first match = latest valid)
  for (const key of preferredKeys) {
    const dated = buckets.get(key)?.dated.find(s => s.from_date <= date);
    if (dated) return dated;
  }

  // 2. Try baselines
  for (const key of preferredKeys) {
    const baseline = buckets.get(key)?.baseline;
    if (baseline) return baseline;
  }

  return snapshots.find(s => s.from_date === null) ?? null;
};

Active iOS scope selection differs slightly for local rollout compatibility: if the shift job has any scoped snapshots, only that scope is searched. If it has none, the default-job scope is tried before legacy nil-job snapshots. Legacy nil-job rows in the local repository are included only for the selected default job.

Selection rules

• Within a selected scope, find the latest dated snapshot where from_date <= targetDate
• If none, use that scope's baseline snapshot (from_date = NULL)
• If no usable scope exists, use rollout fallback snapshots; if still none, return null and calculation uses defaults
• Inclusive from_date: A snapshot with from_date = 2025-02-01 applies to target dates >= 2025-02-01

Time conversion

function toMin(hhmm: string): number | null {
  const [h, m] = hhmm.split(":").map(Number);
  if (!Number.isInteger(h) || !Number.isInteger(m)) return null;
  if (m < 0 || m >= 60) return null;
  if (h < 0 || h > 24) return null;
  if (h === 24 && m !== 0) return null;
  return h * 60 + m;
}
// "09:00" -> 540
// "17:30" -> 1050
// "24:00" -> 1440
// "24:30" -> null

Invalid shift times or invalid supplement-window times are ignored defensively. A shift with invalid start/end time produces no wage periods and therefore no calculated pay.

Duration calculation

let start = toMin(startTime);  // e.g., 540
let end = toMin(endTime);      // e.g., 1050

// Handle cross-midnight
if (end <= start) {
  end += 24 * 60; // Add 1440 minutes (24 hours)
}

const totalMinutes = end - start;
const durationHours = totalMinutes / 60;

Defensive normalization

• payroll_day is clamped to 1 through the number of days in the payout month
• tax_percentage is clamped to 0 through 100 before gross-to-net conversion
• break_threshold_hours falls back to the default when missing, negative, or non-finite
• break_deduction_minutes is clamped to zero or higher and never deducts more than the shift duration
• hourly wage, fixed supplements, and percentage supplements must be finite and non-negative
• negative wage-period durations are ignored when totaling break input periods

Weekday calculation

const WEEKDAYS = [7, 1, 2, 3, 4, 5, 6]; // JS getDay(): 0=Sun -> 7, then 1..6 Mon..Sat

const date = new Date(shiftDate + "T00:00:00Z");
const weekday = WEEKDAYS[date.getUTCDay()]; // 1-7 (Mon-Sun)

Supplement rules use 1-7 (Monday-Sunday), not JavaScript's 0-6.

Base rate resolution

function resolveBaseRate(shift: ShiftRow, snapshot: WageSnapshot | null): number {
  // Priority 1: New snapshot system
  if (Number.isFinite(snapshot?.hourly_wage) && snapshot.hourly_wage > 0) {
    return snapshot.hourly_wage;
  }

  // Priority 2: Legacy per-shift snapshot (backward compatibility)
  if (Number.isFinite(shift.hourly_wage_snapshot) && shift.hourly_wage_snapshot > 0) {
    return shift.hourly_wage_snapshot;
  }

  // Priority 3: Fallback to tariff level 1
  return PRESET_WAGE_RATES["1"]; // 184.54
}

Supplement rules resolution

function resolveSupplementRules(
  predefinedRules: SupplementRule[],
  customSupplements: CustomSupplementsData | null
): SupplementRule[] {
  // Custom supplements completely replace predefined rules
  if (customSupplements) {
    // An empty rules array explicitly disables supplements for this shift.
    return customSupplements.rules.map(rule => ({
      ...rule,
      days: [1, 2, 3, 4, 5, 6, 7], // Shift-specific clock windows also apply after midnight
    }));
  }

  return predefinedRules;
}

Wage periods construction

function buildWagePeriods(
  startHHMM: string,
  endHHMM: string,
  weekday: number,
  baseRate: number,
  rules: SupplementRule[],
): WagePeriod[] {
  const start = toMin(startHHMM);
  let end = toMin(endHHMM);
  if (start == null || end == null) return [];
  if (end <= start) end += 24 * 60;

  const windows: { from: number; to: number; rate: number }[] = [];
  for (const rule of rules) {
    const from = toMin(rule.from);
    const to = toMin(rule.to);
    if (from == null || to == null || from === to) continue;
    // Weekdays identify the rule's start day, including overnight carry from yesterday.
    for (const dayOffset of [-1, 0, 1]) {
      const ruleWeekday = ((weekday - 1 + dayOffset + 7) % 7) + 1;
      if (!rule.days.includes(ruleWeekday)) continue;
      const windowFrom = from + dayOffset * 24 * 60;
      const windowTo = to + dayOffset * 24 * 60 + (to < from ? 24 * 60 : 0);
      if (windowTo <= start || windowFrom >= end) continue;
      windows.push({ from: windowFrom, to: windowTo, rate: resolveSupplementRate(rule, baseRate) });
    }
  }

  const points = new Set<number>([start, end]);
  for (const window of windows) {
    points.add(Math.max(start, window.from));
    points.add(Math.min(end, window.to));
  }
  const sorted = Array.from(points).sort((a, b) => a - b);
  const periods: WagePeriod[] = [];
  for (let index = 0; index < sorted.length - 1; index++) {
    const fromMin = sorted[index], toMin = sorted[index + 1];
    let supplementRate = 0;
    for (const window of windows) {
      if (fromMin >= window.from && toMin <= window.to) {
        supplementRate = Math.max(supplementRate, window.rate);
      }
    }
    periods.push({ fromMin, toMin, baseRate, supplementRate, totalRate: baseRate + supplementRate });
  }
  return periods;
}

Supplement rate resolution

function resolveSupplementRate(rule: SupplementRule, baseRate: number): number {
  // Fixed amount per hour in the job currency
  if (rule.rate != null && Number.isFinite(rule.rate) && rule.rate >= 0) {
    return rule.rate;
  }

  // Percentage of base rate
  if (rule.percent != null && Number.isFinite(rule.percent) && rule.percent >= 0) {
    return (baseRate * rule.percent) / 100;
  }

  return 0;
}

Stacking behavior: Highest-wins. Only the highest non-negative finite supplement rate applies to each time period.

Pay calculation

let basePay = 0, supplementPay = 0;

for (const period of periods) {
  const hours = (period.toMin - period.fromMin) / 60;
  basePay += hours * period.baseRate;
  supplementPay += hours * period.supplementRate;
}

// Round once per pay component, after summing exact-minute contributions.
basePay = Math.round(basePay * 100) / 100;
supplementPay = Math.round(supplementPay * 100) / 100;
const gross = Math.round((basePay + supplementPay) * 100) / 100;

Tax calculation

const taxEnabled = snapshot.tax_enabled;
const taxPercentage = Math.min(Math.max(snapshot.tax_percentage, 0), 100);

// Half-tax adjustment (based on payout month)
const payoutMonth = shiftMonth === 12 ? 1 : shiftMonth + 1;
const effectiveTaxPct = (halfTaxMonth === payoutMonth)
  ? taxPercentage / 2
  : taxPercentage;

const taxAmount = taxEnabled ? gross * (effectiveTaxPct / 100) : 0;
const net = gross - taxAmount;

Exact pause windows

if (normalizedPauseWindows) {
  const afterPause = applyCustomPauseWindowClipping(
    periods,
    normalizedPauseWindows,
    shift.start_time,
    shift.end_time
  );

  periods = afterPause.periods;
  breakAudit = {
    method: "none",
    thresholdHours: 0,
    deductedHours: afterPause.deductedHours,
    source: "custom_pause_windows",
    appliedPauseWindows: afterPause.appliedPauseWindows,
    notes: afterPause.appliedPauseWindows?.length
      ? ["Deducted using custom pause windows"]
      : [],
  };
} else {
  const afterBreak = applyBreakDeduction(periods, method, threshold, breakHours);
  periods = afterBreak.periods;
  breakAudit = afterBreak.audit;
}

Pause windows are normalized, deduplicated, and merged when they overlap. Cross-midnight pause windows are supported using the same extended timeline model as cross-midnight shifts.

Default settings

• Enabled: Yes (break_enabled = true)
• Method: Proportional
• Threshold: 5.5 hours (break_threshold_hours)
• Break duration: 30 minutes (break_deduction_minutes)

Threshold behavior

// Threshold comparison: strict greater than (>)
const toDeduct = method !== "none" && totalHours > thresholdHours
  ? Math.min(Math.max(0, deductionHours), totalHours) : 0;

// Edge case: Shift exactly at threshold (e.g., 5.5h with 5.5h threshold)
// NO break applied (uses >, not >=)

A 5.5-hour shift with a 5.5-hour threshold will NOT have a break deducted.

Method 1: Proportional (default)

if (method === "proportional") {
  // Deduct exact proportional fractions (not rounded to minutes)
  for (let i = 0; i < adjusted.length; i++) {
    const span = adjusted[i].toMin - adjusted[i].fromMin;
    const proportion = span / totalMinutes;
    const cutMinutes = proportion * toDeduct * 60;
    adjusted[i].toMin -= cutMinutes;
  }
}

Keeps ratios between base pay and supplements intact.

Method 2: End of shift

if (method === "end_of_shift") {
  // Subtract from the tail
  for (let i = adjusted.length - 1; i >= 0 && remaining > 0; i--) {
    const span = adjusted[i].toMin - adjusted[i].fromMin;
    const cut = Math.min(span, remaining);
    adjusted[i].toMin -= cut;
    remaining -= cut;
  }
}

Method 3: Base only

if (method === "base_only") {
  // Deduct from periods with lowest supplement first
  const order = adjusted
    .map((p, idx) => ({ idx, supplement: p.supplementRate }))
    .sort((a, b) => a.supplement - b.supplement)
    .map(o => o.idx);

  for (const i of order) {
    if (remaining <= 0) break;
    const span = adjusted[i].toMin - adjusted[i].fromMin;
    const cut = Math.min(span, remaining);
    adjusted[i].toMin -= cut;
    remaining -= cut;
  }
}

Useful for preserving premium hours (evening/weekend supplements).

Method 4: None

Break method summary

Break audit

type BreakAudit = {
  method: BreakMethod;
  thresholdHours: number;
  deductedHours: number;
  source: "none" | "automatic_break" | "custom_pause_windows";
  appliedPauseWindows?: PauseWindow[];
  notes?: string[];
};

Tax treatments

gross_taxable adjustments use the same half-tax rule as shift totals: if half_tax_month equals the payout month, the effective tax percentage is halved before calculating net.

Adjustment totals algorithm

function payrollAdjustmentTotals(
  adjustments: PayrollAdjustment[],
  taxSettingsForAdjustment: (a: PayrollAdjustment) => PayoutTaxSettings,
  halfTaxMonth: number | null,
  payoutMonth: number
): PayrollAdjustmentTotals {
  return adjustments
    .filter(a => !a.deleted_at)
    .reduce((totals, adjustment) => {
      const tax = taxSettingsForAdjustment(adjustment);
      const gross = adjustment.amount;

      if (adjustment.tax_treatment !== "gross_taxable") {
        return {
          gross: totals.gross + gross,
          net: totals.net + gross,
          taxEnabled: totals.taxEnabled,
        };
      }

      const pct = Math.min(Math.max(tax.percentage, 0), 100);
      const effectivePct = halfTaxMonth === payoutMonth ? pct / 2 : pct;
      const net = tax.enabled ? gross * (1 - effectivePct / 100) : gross;

      return {
        gross: totals.gross + gross,
        net: totals.net + net,
        taxEnabled: totals.taxEnabled || tax.enabled,
      };
    }, { gross: 0, net: 0, taxEnabled: false });
}

Payroll card (active iOS)

for (const job of jobsSortedByNextPayoutDate) {
  const payoutDate = adjustPayrollDate(job.payroll_day, visiblePayoutMonth, visiblePayoutYear);
  const jobShifts = previousMonthShifts.filter(s => effectiveJobId(s) === job.id);
  const shiftTotals = summarizeShiftTotals(jobShifts, halfTaxMonth, earningsMonth);

  const jobAdjustments = payoutAdjustments.filter(a => effectiveJobId(a) === job.id);
  const adjustmentTotals = payrollAdjustmentTotals(
    jobAdjustments,
    adjustment => taxSettingsForAdjustment(adjustment),
    halfTaxMonth,
    visiblePayoutMonth
  );

  variants.push({
    job,
    payoutDate,
    gross: shiftTotals.gross + adjustmentTotals.gross,
    net: shiftTotals.net + adjustmentTotals.net,
    currency: job.currency,
  });
}

Only payable variants with non-zero gross are shown. If several jobs pay on the same next adjusted payout date, they are combined into one card with per-job breakdown rows; otherwise the next payable job variant is shown.

Projected total

const primaryMonthShifts = shiftsMatchingPrimaryJobCurrencyBucket(monthShifts);
const totals = summarizeShiftTotals({
  shifts: primaryMonthShifts,
  now: new Date(),
  earningsMonth,
  halfTaxMonth
});

const earnedToDate = taxEnabled ? totals.completedNet : totals.completedGross;
const projectedTotal = taxEnabled ? totals.net : totals.gross;
const hasFutureShifts = plannedShiftCount > 0;

Completed totals use Date.hasShiftEnded, so a shift on today only counts as completed after its end time. Planned count tracks future shifts in the primary job/currency bucket.

Conflict exclusion (overlapping shifts)

function buildExcludedShiftIds(shifts: ShiftWithComputations[]): Set<string> {
  const result = new Set<string>();
  const shiftsByDate = groupByDate(shifts);

  for (const [date, shiftsOnDate] of shiftsByDate) {
    if (shiftsOnDate.length < 2) continue;

    // Find overlapping clusters using union-find
    const clusters = findOverlappingClusters(shiftsOnDate);

    for (const cluster of clusters) {
      if (cluster.length < 2) continue;

      // Sort by gross ascending, keep only the lowest
      cluster.sort((a, b) => a.computed.gross - b.computed.gross);
      for (let i = 1; i < cluster.length; i++) {
        result.add(cluster[i].id);
      }
    }
  }

  return result;
}

Excluded shifts are displayed with strikethrough styling but remain visible.

Overlap detection

function shiftsOverlap(a, b): boolean {
  let startA = toMinutes(a.start_time);
  let endA = toMinutes(a.end_time);
  let startB = toMinutes(b.start_time);
  let endB = toMinutes(b.end_time);

  // Handle cross-midnight
  if (endA <= startA) endA += 24 * 60;
  if (endB <= startB) endB += 24 * 60;

  return startA < endB && startB < endA;
}

Test case 2: Weekday evening shift (with supplement)

// Input
const shift = {
  shift_date: "2025-01-15", // Wednesday
  start_time: "17:00",
  end_time: "22:00",
};

const snapshot = {
  hourly_wage: 185.00,
  supplements: { rules: [
    { days: [1,2,3,4,5], from: "18:00", to: "21:00", rate: 22 },
    { days: [1,2,3,4,5], from: "21:00", to: "24:00", rate: 45 },
  ]},
  break_enabled: false,
};

// Expected output
{
  durationHours: 5.00,
  paidHours: 5.00,
  basePay: 925.00,       // 5h x 185
  supplementPay: 111.00, // 1h x 0 + 3h x 22 + 1h x 45 = 0 + 66 + 45
  gross: 1036.00,
}

Test case 3: Cross-midnight shift

// Input
const shift = {
  shift_date: "2025-01-15", // Wednesday
  start_time: "22:00",
  end_time: "06:00",
};

const snapshot = {
  hourly_wage: 185.00,
  supplements: { rules: [
    { days: [1,2,3,4,5], from: "21:00", to: "24:00", rate: 45 },
  ]},
  break_enabled: true,
  break_threshold_hours: 5.5,
  break_deduction_minutes: 30,
};

// Expected output
{
  durationHours: 8.00,        // 22:00 to 06:00 = 8 hours
  paidHours: 7.50,            // 8h - 0.5h break
  basePay: 1387.51,           // 346.88 (1.875h x 185) + 1040.63 (5.625h x 185)
  supplementPay: 84.38,       // 1.875h x 45 (proportional: 2h loses 2/8 x 0.5h)
  gross: 1471.89,
}

Test case 4: Sunday full day (high supplement)

// Input
const shift = {
  shift_date: "2025-01-19", // Sunday
  start_time: "08:00",
  end_time: "16:00",
};

const snapshot = {
  hourly_wage: 185.00,
  supplements: { rules: [
    { days: [7], from: "00:00", to: "24:00", rate: 115 },
  ]},
  break_enabled: true,
  break_threshold_hours: 5.5,
  break_deduction_minutes: 30,
};

// Expected output
{
  durationHours: 8.00,
  paidHours: 7.50,
  basePay: 1387.50,      // 7.5h x 185
  supplementPay: 862.50, // 7.5h x 115
  gross: 2250.00,
}

Test case 5: Break threshold edge case

// Input
const shift = {
  shift_date: "2025-01-15",
  start_time: "09:00",
  end_time: "14:30", // Exactly 5.5 hours
};

const snapshot = {
  hourly_wage: 185.00,
  break_enabled: true,
  break_threshold_hours: 5.5,
  break_deduction_minutes: 30,
};

// Expected output
{
  durationHours: 5.50,
  paidHours: 5.50,       // NO break (threshold uses >)
  basePay: 1017.50,
  supplementPay: 0,
  gross: 1017.50,
}

The threshold comparison uses strict greater than (>), not >=.

Test case 6: Percentage-based supplement

// Input
const shift = {
  shift_date: "2025-01-15",
  start_time: "18:00",
  end_time: "22:00",
};

const snapshot = {
  hourly_wage: 200.00,
  supplements: { rules: [
    { days: [3], from: "18:00", to: "24:00", percent: 50 }, // 50% of base
  ]},
  break_enabled: false,
};

// Expected output
{
  durationHours: 4.00,
  paidHours: 4.00,
  basePay: 800.00,       // 4h x 200
  supplementPay: 400.00, // 4h x (200 x 0.50)
  gross: 1200.00,
}

Test case 7: Saturday to Sunday cross-midnight

// Input
const shift = {
  shift_date: "2025-01-18", // Saturday
  start_time: "20:00",
  end_time: "02:00",
};

const snapshot = {
  hourly_wage: 185.00,
  supplements: { rules: [
    { days: [6], from: "18:00", to: "24:00", rate: 110 }, // Saturday evening
    { days: [7], from: "00:00", to: "24:00", rate: 115 }, // Sunday all day
  ]},
  break_enabled: false,
};

// Expected output
{
  durationHours: 6.00,
  paidHours: 6.00,
  // 20:00-00:00 (4h) at Saturday rate 110
  // 00:00-02:00 (2h) at Sunday rate 115
  basePay: 1110.00,       // 6h x 185
  supplementPay: 670.00,  // 4h x 110 + 2h x 115
  gross: 1780.00,
}

Test case 8: Tax with half-tax month

// Input
const shift = {
  shift_date: "2025-11-15", // November
};

const snapshot = {
  tax_enabled: true,
  tax_percentage: 30,
};

const settings = {
  half_tax_month: 12, // December (payout month for November shifts)
};

// Tax calculation
// Payout month = December
// Half-tax applies because halfTaxMonth === payoutMonth
const effectiveTaxPct = 30 / 2; // = 15%
const taxAmount = gross * 0.15;

Test case 9: Overlapping shifts (conflict exclusion)

// Input
const shifts = [
  {
    id: "shift-a",
    shift_date: "2025-01-15",
    start_time: "09:00",
    end_time: "17:00", // Gross: 1480 NOK
  },
  {
    id: "shift-b",
    shift_date: "2025-01-15",
    start_time: "14:00",
    end_time: "22:00", // Gross: 1850 NOK (higher due to evening supplement)
  },
];

// Expected behavior
// shift-a and shift-b overlap (14:00-17:00)
// shift-a has lower gross (1480) -> included in totals
// shift-b has higher gross (1850) -> excluded from totals, shown with strikethrough

const excludedIds = buildExcludedShiftIds(shifts);
// excludedIds.has("shift-b") === true
// excludedIds.has("shift-a") === false

// Monthly total = 1480 (only shift-a counted)