@trajectonomics/tax 0.0.0-stage → 0.1.0

package/dist/us/index.mjs

@@ -0,0 +1,2897 @@
+import { a as usd, d as multiplySafeInteger, l as fromMinorUnits, m as TaxValidationError, n as evaluateBrackets, s as applyPercentage, t as clampCap, u as toMinorUnits } from "../clamp-Bse4u0H-.mjs";
+// src/us/parameters/amt.ts
+/**
+* Statutory 2026 Alternative Minimum Tax (AMT) exemptions, phaseouts, and rates.
+*
+* @statute IRC § 55
+*/
+const US_2026_AMT = {
+	baseExemptions: {
+		single: 90100,
+		married_filing_jointly: 140200,
+		married_filing_separately: 70100,
+		head_of_household: 90100
+	},
+	phaseoutThresholds: {
+		single: 643250,
+		married_filing_jointly: 1286500,
+		married_filing_separately: 643250,
+		head_of_household: 643250
+	},
+	phaseoutRate: .25,
+	rate26Thresholds: {
+		single: 239100,
+		married_filing_jointly: 239100,
+		married_filing_separately: 119550,
+		head_of_household: 239100
+	},
+	rate26: .26,
+	rate28: .28
+};
+// src/us/parameters/brackets.ts
+/**
+* Statutory 2026 US Federal ordinary income progressive brackets in minor units (cents).
+*
+* @statute IRC § 1(j), Rev. Proc. 2025-XX
+*/
+const US_2026_ORDINARY_BRACKETS = {
+	single: [
+		{
+			upTo: 124e4,
+			rate: .1
+		},
+		{
+			upTo: 504e4,
+			rate: .12
+		},
+		{
+			upTo: 1057e4,
+			rate: .22
+		},
+		{
+			upTo: 20177500,
+			rate: .24
+		},
+		{
+			upTo: 25622500,
+			rate: .32
+		},
+		{
+			upTo: 6406e4,
+			rate: .35
+		},
+		{
+			upTo: null,
+			rate: .37
+		}
+	],
+	married_filing_jointly: [
+		{
+			upTo: 248e4,
+			rate: .1
+		},
+		{
+			upTo: 1008e4,
+			rate: .12
+		},
+		{
+			upTo: 2114e4,
+			rate: .22
+		},
+		{
+			upTo: 40355e3,
+			rate: .24
+		},
+		{
+			upTo: 51245e3,
+			rate: .32
+		},
+		{
+			upTo: 7687e4,
+			rate: .35
+		},
+		{
+			upTo: null,
+			rate: .37
+		}
+	],
+	married_filing_separately: [
+		{
+			upTo: 124e4,
+			rate: .1
+		},
+		{
+			upTo: 504e4,
+			rate: .12
+		},
+		{
+			upTo: 1057e4,
+			rate: .22
+		},
+		{
+			upTo: 20177500,
+			rate: .24
+		},
+		{
+			upTo: 25622500,
+			rate: .32
+		},
+		{
+			upTo: 38435e3,
+			rate: .35
+		},
+		{
+			upTo: null,
+			rate: .37
+		}
+	],
+	head_of_household: [
+		{
+			upTo: 177e4,
+			rate: .1
+		},
+		{
+			upTo: 6745e3,
+			rate: .12
+		},
+		{
+			upTo: 1057e4,
+			rate: .22
+		},
+		{
+			upTo: 20175e3,
+			rate: .24
+		},
+		{
+			upTo: 2562e4,
+			rate: .32
+		},
+		{
+			upTo: 6406e4,
+			rate: .35
+		},
+		{
+			upTo: null,
+			rate: .37
+		}
+	]
+};
+/**
+* Statutory 2026 US Federal preferential capital gains brackets in minor units (cents).
+*
+* @statute IRC § 1(h), Rev. Proc. 2025-XX
+*/
+const US_2026_PREFERENTIAL_BRACKETS = {
+	single: [
+		{
+			upTo: 4945e3,
+			rate: 0
+		},
+		{
+			upTo: 5455e4,
+			rate: .15
+		},
+		{
+			upTo: null,
+			rate: .2
+		}
+	],
+	married_filing_jointly: [
+		{
+			upTo: 989e4,
+			rate: 0
+		},
+		{
+			upTo: 6137e4,
+			rate: .15
+		},
+		{
+			upTo: null,
+			rate: .2
+		}
+	],
+	married_filing_separately: [
+		{
+			upTo: 4945e3,
+			rate: 0
+		},
+		{
+			upTo: 30685e3,
+			rate: .15
+		},
+		{
+			upTo: null,
+			rate: .2
+		}
+	],
+	head_of_household: [
+		{
+			upTo: 662e4,
+			rate: 0
+		},
+		{
+			upTo: 5796e4,
+			rate: .15
+		},
+		{
+			upTo: null,
+			rate: .2
+		}
+	]
+};
+// src/us/parameters/constants.ts
+/**
+* Statutory 2026 US Federal base standard deduction amounts in major dollars.
+*
+* @statute IRC § 63(c)(2), Rev. Proc. 2025-XX
+*/
+const US_2026_STANDARD_DEDUCTION = {
+	single: 16100,
+	married_filing_jointly: 32200,
+	married_filing_separately: 16100,
+	head_of_household: 24150
+};
+/**
+* Statutory 2026 additional standard deduction for age 65+ and blindness per condition.
+*
+* @statute IRC § 63(f), Rev. Proc. 2025-XX
+*/
+const US_2026_ADDITIONAL_STANDARD_DEDUCTION = {
+	unmarried: 2050,
+	married: 1650
+};
+/**
+* Statutory 2026 Schedule 1 Above-the-Line deduction limits in major dollars.
+*
+* @statute IRC § 62, § 219, § 221, § 223, § 402(g)
+*/
+const US_2026_ABOVE_THE_LINE_CAPS = {
+	educatorSingle: 350,
+	educatorMfjBoth: 700,
+	studentLoanInterest: 2500,
+	traditional401kBase: 24500,
+	traditional401kCatchUpAge50: 8e3,
+	traditionalIraBase: 7500,
+	traditionalIraCatchUpAge50: 1100,
+	hsaSelfOnlyBase: 4400,
+	hsaFamilyBase: 8750,
+	hsaCatchUpAge55: 1e3
+};
+/**
+* Statutory 2026 Schedule A Itemized Deduction thresholds and caps.
+*
+* @statute IRC §§ 164, 170, 213
+*/
+const US_2026_ITEMIZED = {
+	medicalFloorRate: .075,
+	saltCap: 1e4,
+	saltCapMfs: 5e3,
+	charityCeilingRate: .6
+};
+/**
+* Statutory Net Investment Income Tax (NIIT) rates and MAGI thresholds.
+*
+* @statute IRC § 1411
+*/
+const US_2026_NIIT = {
+	rate: .038,
+	thresholds: {
+		single: 2e5,
+		head_of_household: 2e5,
+		married_filing_jointly: 25e4,
+		married_filing_separately: 125e3
+	}
+};
+// src/us/parameters/credits.ts
+/**
+* Statutory 2026 Federal Tax Credits parameters.
+*
+* @statute IRC § 21, § 24, § 25A, § 32
+*/
+const US_2026_CREDITS = {
+	ctcAmountPerChild: 2e3,
+	actcMaxPerChild: 1700,
+	actcEarnedIncomeThreshold: 2500,
+	actcRate: .15,
+	ctcPhaseoutThresholds: {
+		single: 2e5,
+		married_filing_jointly: 4e5,
+		married_filing_separately: 2e5,
+		head_of_household: 2e5
+	},
+	ctcPhaseoutStepAmount: 1e3,
+	ctcPhaseoutStepRate: 50,
+	odcAmountPerDependent: 500,
+	eitcInvestmentIncomeLimit: 11950,
+	eitcTiers: {
+		0: {
+			creditRate: .0765,
+			maxEarnedIncome: 8490,
+			maxCredit: 649,
+			phaseoutThresholdSingle: 10620,
+			phaseoutThresholdMfj: 17990,
+			phaseoutRate: .0765
+		},
+		1: {
+			creditRate: .34,
+			maxEarnedIncome: 12730,
+			maxCredit: 4328,
+			phaseoutThresholdSingle: 23340,
+			phaseoutThresholdMfj: 30710,
+			phaseoutRate: .1598
+		},
+		2: {
+			creditRate: .4,
+			maxEarnedIncome: 17880,
+			maxCredit: 7152,
+			phaseoutThresholdSingle: 23340,
+			phaseoutThresholdMfj: 30710,
+			phaseoutRate: .2106
+		},
+		3: {
+			creditRate: .45,
+			maxEarnedIncome: 17880,
+			maxCredit: 8046,
+			phaseoutThresholdSingle: 23340,
+			phaseoutThresholdMfj: 30710,
+			phaseoutRate: .2106
+		}
+	},
+	careMaxExpenseOne: 3e3,
+	careMaxExpenseTwoPlus: 6e3,
+	careBaseRate: .35,
+	careFloorRate: .2,
+	carePhaseoutAgiThreshold: 15e3,
+	carePhaseoutStepAgi: 2e3,
+	carePhaseoutStepRate: .01,
+	aotcMaxPerStudent: 2500,
+	aotcTier1MaxExpense: 2e3,
+	aotcTier1Rate: 1,
+	aotcTier2MaxExpense: 2e3,
+	aotcTier2Rate: .25,
+	aotcRefundableRate: .4,
+	aotcPhaseoutMin: {
+		single: 8e4,
+		head_of_household: 8e4,
+		married_filing_jointly: 16e4,
+		married_filing_separately: 0
+	},
+	aotcPhaseoutMax: {
+		single: 9e4,
+		head_of_household: 9e4,
+		married_filing_jointly: 18e4,
+		married_filing_separately: 0
+	},
+	llcMaxExpensePerReturn: 1e4,
+	llcRate: .2
+};
+// src/us/parameters/payroll.ts
+/**
+* Statutory 2026 FICA & SECA Payroll parameters.
+*
+* @statute IRC § 1401, § 1402, § 3101
+*/
+const US_2026_PAYROLL = {
+	socialSecurityWageBase: 181800,
+	ficaSocialSecurityRate: .062,
+	ficaMedicareRate: .0145,
+	additionalMedicareRate: .009,
+	additionalMedicareThresholds: {
+		single: 2e5,
+		married_filing_jointly: 25e4,
+		married_filing_separately: 125e3,
+		head_of_household: 2e5
+	},
+	seNetEarningsFactor: .9235,
+	seThresholdFloor: 400,
+	seSocialSecurityRate: .124,
+	seMedicareRate: .029,
+	seDeductibleRate: .5
+};
+// src/us/parameters.ts
+/**
+* Consolidated statutory parameter table for US Federal Income Tax (Tax Year 2026).
+*
+* @statute IRC § 1 et seq.
+*/
+const US_2026_PARAMETERS = {
+	taxYear: 2026,
+	currency: "USD",
+	standardDeduction: US_2026_STANDARD_DEDUCTION,
+	additionalStandardDeduction: US_2026_ADDITIONAL_STANDARD_DEDUCTION,
+	aboveTheLineCaps: US_2026_ABOVE_THE_LINE_CAPS,
+	itemized: US_2026_ITEMIZED,
+	niit: US_2026_NIIT,
+	ordinaryBrackets: US_2026_ORDINARY_BRACKETS,
+	preferentialBrackets: US_2026_PREFERENTIAL_BRACKETS,
+	payroll: US_2026_PAYROLL,
+	amt: US_2026_AMT,
+	credits: US_2026_CREDITS
+};
+// src/us/types/state-fields.ts
+/**
+* Diagnostic and reporting field identifiers for state income tax calculations.
+*/
+let UsStateField = /* @__PURE__ */ function(UsStateField) {
+	UsStateField["BracketBound"] = "state.bracketBound";
+	UsStateField["Agi"] = "state.agi";
+	UsStateField["StandardDeduction"] = "state.standardDeduction";
+	UsStateField["PersonalExemption"] = "state.personalExemption";
+	UsStateField["DependentExemption"] = "state.dependentExemption";
+	UsStateField["TaxableIncome"] = "state.taxableIncome";
+	UsStateField["BracketTax"] = "state.bracketTax";
+	UsStateField["Surtax"] = "state.surtax";
+	UsStateField["SurtaxThreshold"] = "state.surtaxThreshold";
+	UsStateField["PhaseOutThreshold"] = "state.phaseOutThreshold";
+	UsStateField["CreditsPersonal"] = "state.credits.personal";
+	UsStateField["CreditsDependent"] = "state.credits.dependent";
+	UsStateField["CreditsClaimedNonRefundable"] = "state.credits.claimedNonRefundable";
+	UsStateField["CreditsNonRefundable"] = "state.credits.nonRefundable";
+	UsStateField["CreditsRefundable"] = "state.credits.refundable";
+	UsStateField["Withholding"] = "state.withholding";
+	UsStateField["TaxBeforeCredits"] = "state.taxBeforeCredits";
+	UsStateField["TotalTax"] = "state.totalTax";
+	UsStateField["NetTaxPayable"] = "state.netTaxPayable";
+	return UsStateField;
+}({});
+// src/us/state/parameters/helpers.ts
+function tiersToBrackets(tiers) {
+	const bounds = tiers.map(([lower]) => toMinorUnits(lower, US_2026_PARAMETERS.currency, "state.bracketBound"));
+	const brackets = [];
+	const first = bounds[0] ?? 0;
+	if (first > 0) brackets.push({
+		upTo: first,
+		rate: 0
+	});
+	for (let index = 0; index < tiers.length; index++) {
+		const tier = tiers[index];
+		if (!tier) continue;
+		brackets.push({
+			upTo: bounds[index + 1] ?? null,
+			rate: tier[1]
+		});
+	}
+	return brackets;
+}
+function standardAmounts(single, mfj, hoh, mfs) {
+	return {
+		single,
+		married_filing_jointly: mfj,
+		married_filing_separately: mfs ?? (mfj === single ? single : Math.round(mfj / 2)),
+		head_of_household: hoh ?? (single > 0 ? Math.round(single * 1.5) : 0)
+	};
+}
+function exemptionAmounts(single, mfj, hoh, mfs = void 0) {
+	return {
+		single,
+		married_filing_jointly: mfj,
+		married_filing_separately: mfs ?? single,
+		head_of_household: hoh ?? single
+	};
+}
+function resolveMfsTiers(def) {
+	if (def.mfs === "half-mfj") return def.mfj.map(([lower, rate]) => [lower / 2, rate]);
+	return def.mfs ?? def.single;
+}
+function resolveHohTiers(def) {
+	if (def.hoh === "mfj") return def.mfj;
+	return def.hoh ?? def.single;
+}
+function optionalRules(def) {
+	return {
+		...def.surtax ? { surtax: def.surtax } : {},
+		...def.standardDeductionPhaseOut ? { standardDeductionPhaseOut: def.standardDeductionPhaseOut } : {},
+		...def.dependentExemptionPhaseOut ? { dependentExemptionPhaseOut: def.dependentExemptionPhaseOut } : {}
+	};
+}
+/**
+* Builds a complete state parameter table from a compact statutory definition.
+*
+* Math: Converts dollar thresholds to integer cents; derives vertical-equity defaults
+* (MFS uses single brackets, HoH uses single brackets and 1.5x single standard deduction).
+* Units: Definition amounts are major dollars; emitted bracket bounds are integer cents.
+* Throws: TaxValidationError if a threshold cannot be represented as safe integer cents.
+*
+* @param def Compact state statutory definition.
+* @returns Complete state parameter table.
+*/
+function defineState(def) {
+	const personalExemption = def.personalExemption ?? [0, 0];
+	const personalCredit = def.personalCredit ?? [0, 0];
+	return {
+		code: def.code,
+		name: def.name,
+		type: def.type,
+		brackets: {
+			single: tiersToBrackets(def.single),
+			married_filing_jointly: tiersToBrackets(def.mfj),
+			married_filing_separately: tiersToBrackets(resolveMfsTiers(def)),
+			head_of_household: tiersToBrackets(resolveHohTiers(def))
+		},
+		standardDeduction: standardAmounts(def.std[0], def.std[1], def.std[2], def.stdMfs),
+		personalExemption: exemptionAmounts(personalExemption[0], personalExemption[1], personalExemption[2], def.personalExemptionMfs),
+		personalCredit: exemptionAmounts(personalCredit[0], personalCredit[1], personalCredit[2]),
+		dependentExemption: def.dependentExemption ?? 0,
+		dependentCredit: def.dependentCredit ?? 0,
+		...optionalRules(def)
+	};
+}
+/**
+* Indexes a complete list of state parameter tables by state code.
+*
+* @param states All supported state parameter tables.
+* @returns Record keyed by every supported state code.
+*/
+function indexStates(states) {
+	const record = {};
+	for (const state of states) record[state.code] = state;
+	return record;
+}
+/** Statutory parameter table for the 2026 flat-rate states in group A. */
+const FLAT_STATES_A = [
+	defineState({
+		code: "AZ",
+		name: "Arizona",
+		type: "flat",
+		single: [[0, .025]],
+		mfj: [[0, .025]],
+		std: [
+			16100,
+			32200,
+			24150
+		],
+		dependentCredit: 100
+	}),
+	defineState({
+		code: "CO",
+		name: "Colorado",
+		type: "flat",
+		single: [[0, .044]],
+		mfj: [[0, .044]],
+		std: [16100, 32200]
+	}),
+	defineState({
+		code: "GA",
+		name: "Georgia",
+		type: "flat",
+		single: [[0, .0499]],
+		mfj: [[0, .0499]],
+		std: [
+			15e3,
+			3e4,
+			15e3
+		],
+		dependentExemption: 5e3
+	}),
+	defineState({
+		code: "ID",
+		name: "Idaho",
+		type: "flat",
+		single: [[4811, .053]],
+		mfj: [[9622, .053]],
+		std: [16100, 32200]
+	}),
+	defineState({
+		code: "IL",
+		name: "Illinois",
+		type: "flat",
+		single: [[0, .0495]],
+		mfj: [[0, .0495]],
+		std: [0, 0],
+		personalExemption: [2925, 5850],
+		dependentExemption: 2925
+	}),
+	defineState({
+		code: "IN",
+		name: "Indiana",
+		type: "flat",
+		single: [[0, .0295]],
+		mfj: [[0, .0295]],
+		std: [0, 0],
+		personalExemption: [1e3, 2e3],
+		dependentExemption: 1e3
+	}),
+	defineState({
+		code: "IA",
+		name: "Iowa",
+		type: "flat",
+		single: [[0, .038]],
+		mfj: [[0, .038]],
+		std: [16100, 32200],
+		personalCredit: [40, 80],
+		dependentCredit: 40
+	})
+];
+/** Statutory parameter table for the 2026 flat-rate states in group B. */
+const FLAT_STATES_B = [
+	defineState({
+		code: "KY",
+		name: "Kentucky",
+		type: "flat",
+		single: [[0, .035]],
+		mfj: [[0, .035]],
+		std: [
+			3360,
+			3360,
+			3360
+		]
+	}),
+	defineState({
+		code: "MA",
+		name: "Massachusetts",
+		type: "flat",
+		single: [[0, .05]],
+		mfj: [[0, .05]],
+		std: [0, 0],
+		personalExemption: [
+			4400,
+			8800,
+			6800
+		],
+		dependentExemption: 1e3,
+		surtax: {
+			threshold: 1107750,
+			rate: .04
+		}
+	}),
+	defineState({
+		code: "MI",
+		name: "Michigan",
+		type: "flat",
+		single: [[0, .0425]],
+		mfj: [[0, .0425]],
+		std: [0, 0],
+		personalExemption: [5900, 11800],
+		dependentExemption: 5900
+	}),
+	defineState({
+		code: "MS",
+		name: "Mississippi",
+		type: "flat",
+		single: [[1e4, .04]],
+		mfj: [[1e4, .04]],
+		std: [2300, 4600],
+		personalExemption: [6e3, 12e3],
+		dependentExemption: 1500
+	}),
+	defineState({
+		code: "NC",
+		name: "North Carolina",
+		type: "flat",
+		single: [[0, .0399]],
+		mfj: [[0, .0399]],
+		std: [12750, 25500]
+	}),
+	defineState({
+		code: "PA",
+		name: "Pennsylvania",
+		type: "flat",
+		single: [[0, .0307]],
+		mfj: [[0, .0307]],
+		std: [0, 0]
+	}),
+	defineState({
+		code: "UT",
+		name: "Utah",
+		type: "flat",
+		single: [[0, .0445]],
+		mfj: [[0, .0445]],
+		std: [0, 0],
+		personalCredit: [
+			966,
+			1932,
+			1449
+		],
+		dependentCredit: 126.66
+	})
+];
+/** Statutory parameter table for Louisiana and Ohio flat-rate individual income taxes. */
+const FLAT_STATES_C = [defineState({
+	code: "LA",
+	name: "Louisiana",
+	type: "flat",
+	single: [[0, .03]],
+	mfj: [[0, .03]],
+	std: [
+		12875,
+		25750,
+		25750
+	]
+}), defineState({
+	code: "OH",
+	name: "Ohio",
+	type: "flat",
+	single: [[26050, .0275]],
+	mfj: [[26050, .0275]],
+	std: [0, 0],
+	personalExemption: [2400, 4800],
+	dependentExemption: 2400
+})];
+// src/us/state/parameters/flat/index.ts
+/** Statutory parameter table for all 2026 flat-rate state individual income taxes. */
+const FLAT_STATES = [
+	...FLAT_STATES_A,
+	...FLAT_STATES_B,
+	...FLAT_STATES_C
+];
+// src/us/state/parameters/none.ts
+/**
+* Builds the zero-rate parameter table for a state with no 2026 wage income tax.
+*
+* Units: All amounts are zero major dollars.
+*/
+function noTaxState(code, name) {
+	return defineState({
+		code,
+		name,
+		type: "none",
+		single: [[0, 0]],
+		mfj: [[0, 0]],
+		std: [0, 0]
+	});
+}
+/**
+* Statutory parameter table for the nine states with no 2026 wage income tax.
+*
+* Washington taxes only long-term capital gains above a high threshold, and New Hampshire and
+* Tennessee repealed their interest and dividends taxes, so none taxes wage or ordinary income.
+*
+* @statute State constitutions and statutes repealing or prohibiting an individual income tax.
+*/
+const NO_TAX_STATES = [
+	noTaxState("AK", "Alaska"),
+	noTaxState("FL", "Florida"),
+	noTaxState("NV", "Nevada"),
+	noTaxState("NH", "New Hampshire"),
+	noTaxState("SD", "South Dakota"),
+	noTaxState("TN", "Tennessee"),
+	noTaxState("TX", "Texas"),
+	noTaxState("WA", "Washington"),
+	noTaxState("WY", "Wyoming")
+];
+// src/us/state/parameters/progressive/al.ts
+/**
+* 2026 Alabama individual income tax parameters.
+*
+* @statute Ala. Code § 40-18-5
+*/
+const US_2026_STATE_AL = defineState({
+	code: "AL",
+	name: "Alabama",
+	type: "progressive",
+	single: [
+		[0, .02],
+		[500, .04],
+		[3e3, .05]
+	],
+	mfj: [
+		[0, .02],
+		[1e3, .04],
+		[6e3, .05]
+	],
+	std: [
+		3e3,
+		8500,
+		5200
+	],
+	personalExemption: [
+		1500,
+		3e3,
+		3e3
+	],
+	dependentExemption: 1e3
+});
+// src/us/state/parameters/progressive/ar.ts
+/**
+* 2026 Arkansas individual income tax parameters.
+*
+* Brackets from the DFA 2026 withholding formula (0% to $5,599, then 2%, 3%, 3.4%); the top rate is
+* 3.7% after H.B. 1001 (retroactive to 2026-01-01), as reported by EY and Bloomberg Tax.
+*
+* @statute Ark. Code Ann. § 26-51-201
+*/
+const US_2026_STATE_AR = defineState({
+	code: "AR",
+	name: "Arkansas",
+	type: "progressive",
+	single: [
+		[5600, .02],
+		[11200, .03],
+		[16e3, .034],
+		[26400, .037]
+	],
+	mfj: [
+		[5600, .02],
+		[11200, .03],
+		[16e3, .034],
+		[26400, .037]
+	],
+	std: [2470, 4940],
+	personalCredit: [29, 58],
+	dependentCredit: 29
+});
+// src/us/state/parameters/progressive/ca.ts
+/**
+* 2026 California individual income tax parameters.
+*
+* FTB 2026 indexed schedules, deduction ($5,900/$11,800) and exemption credits ($158/$316,
+* $491 per dependent). 1% mental health services surtax above $1,000,000.
+*
+* @statute Cal. Rev. & Tax. Code § 17041
+*/
+const US_2026_STATE_CA = defineState({
+	code: "CA",
+	name: "California",
+	type: "progressive",
+	single: [
+		[0, .01],
+		[11456, .02],
+		[27157, .04],
+		[42861, .06],
+		[59498, .08],
+		[75197, .093],
+		[384109, .103],
+		[460927, .113],
+		[768213, .123]
+	],
+	mfj: [
+		[0, .01],
+		[22912, .02],
+		[54314, .04],
+		[85722, .06],
+		[118996, .08],
+		[150394, .093],
+		[768218, .103],
+		[921854, .113],
+		[1536426, .123]
+	],
+	hoh: [
+		[0, .01],
+		[22927, .02],
+		[54316, .04],
+		[70018, .06],
+		[86654, .08],
+		[102356, .093],
+		[522385, .103],
+		[626864, .113],
+		[1044771, .123]
+	],
+	std: [
+		5900,
+		11800,
+		11800
+	],
+	personalCredit: [158, 316],
+	dependentCredit: 491,
+	surtax: {
+		threshold: 1e6,
+		rate: .01
+	}
+});
+// src/us/state/parameters/progressive/ct.ts
+/**
+* 2026 Connecticut individual income tax parameters.
+*
+* @statute Conn. Gen. Stat. § 12-700
+*/
+const US_2026_STATE_CT = defineState({
+	code: "CT",
+	name: "Connecticut",
+	type: "progressive",
+	single: [
+		[0, .02],
+		[1e4, .045],
+		[5e4, .055],
+		[1e5, .06],
+		[2e5, .065],
+		[25e4, .069],
+		[5e5, .0699]
+	],
+	mfj: [
+		[0, .02],
+		[2e4, .045],
+		[1e5, .055],
+		[2e5, .06],
+		[4e5, .065],
+		[5e5, .069],
+		[1e6, .0699]
+	],
+	hoh: [
+		[0, .02],
+		[16e3, .045],
+		[8e4, .055],
+		[16e4, .06],
+		[32e4, .065],
+		[4e5, .069],
+		[8e5, .0699]
+	],
+	std: [0, 0],
+	personalExemptionMfs: 12e3,
+	personalExemption: [
+		15e3,
+		24e3,
+		19e3
+	]
+});
+// src/us/state/parameters/progressive/dc.ts
+/**
+* 2026 District of Columbia individual income tax parameters.
+*
+* @statute D.C. Code § 47-1806.03
+*/
+const US_2026_STATE_DC = defineState({
+	code: "DC",
+	name: "District of Columbia",
+	type: "progressive",
+	single: [
+		[0, .04],
+		[1e4, .06],
+		[4e4, .065],
+		[6e4, .085],
+		[25e4, .0925],
+		[5e5, .0975],
+		[1e6, .1075]
+	],
+	mfj: [
+		[0, .04],
+		[1e4, .06],
+		[4e4, .065],
+		[6e4, .085],
+		[25e4, .0925],
+		[5e5, .0975],
+		[1e6, .1075]
+	],
+	std: [
+		16100,
+		32200,
+		24150
+	]
+});
+// src/us/state/parameters/progressive/de.ts
+/**
+* 2026 Delaware individual income tax parameters.
+*
+* @statute Del. Code Ann. tit. 30, § 1102
+*/
+const US_2026_STATE_DE = defineState({
+	code: "DE",
+	name: "Delaware",
+	type: "progressive",
+	single: [
+		[2e3, .022],
+		[5e3, .039],
+		[1e4, .048],
+		[2e4, .052],
+		[25e3, .0555],
+		[6e4, .066]
+	],
+	mfj: [
+		[2e3, .022],
+		[5e3, .039],
+		[1e4, .048],
+		[2e4, .052],
+		[25e3, .0555],
+		[6e4, .066]
+	],
+	std: [
+		3250,
+		6500,
+		3250
+	],
+	personalCredit: [110, 220],
+	dependentCredit: 110
+});
+// src/us/state/parameters/progressive/hi.ts
+/**
+* 2026 Hawaii individual income tax parameters.
+*
+* @statute Haw. Rev. Stat. § 235-51
+*/
+const US_2026_STATE_HI = defineState({
+	code: "HI",
+	name: "Hawaii",
+	type: "progressive",
+	single: [
+		[0, .014],
+		[9600, .032],
+		[14400, .055],
+		[19200, .064],
+		[24e3, .068],
+		[36e3, .072],
+		[48e3, .076],
+		[125e3, .079],
+		[175e3, .0825],
+		[225e3, .09],
+		[275e3, .1],
+		[325e3, .11]
+	],
+	mfj: [
+		[0, .014],
+		[19200, .032],
+		[28800, .055],
+		[38400, .064],
+		[48e3, .068],
+		[72e3, .072],
+		[96e3, .076],
+		[25e4, .079],
+		[35e4, .0825],
+		[45e4, .09],
+		[55e4, .1],
+		[65e4, .11]
+	],
+	hoh: [
+		[0, .014],
+		[14400, .032],
+		[21600, .055],
+		[28800, .064],
+		[36e3, .068],
+		[54e3, .072],
+		[72e3, .076],
+		[187500, .079],
+		[262500, .0825],
+		[337500, .09],
+		[412500, .1],
+		[487500, .11]
+	],
+	std: [
+		8e3,
+		16e3,
+		12e3
+	],
+	personalExemption: [1144, 2288],
+	dependentExemption: 1144
+});
+// src/us/state/parameters/progressive/ks.ts
+/**
+* 2026 Kansas individual income tax parameters.
+*
+* @statute Kan. Stat. Ann. § 79-32,110
+*/
+const US_2026_STATE_KS = defineState({
+	code: "KS",
+	name: "Kansas",
+	type: "progressive",
+	single: [[0, .052], [23e3, .0558]],
+	mfj: [[0, .052], [46e3, .0558]],
+	std: [
+		3605,
+		8240,
+		6180
+	],
+	personalExemption: [9160, 18320],
+	dependentExemption: 2320
+});
+// src/us/state/parameters/progressive/md.ts
+/**
+* 2026 Maryland individual income tax parameters.
+*
+* @statute Md. Code, Tax-Gen. § 10-105
+*/
+const US_2026_STATE_MD = defineState({
+	code: "MD",
+	name: "Maryland",
+	type: "progressive",
+	single: [
+		[0, .02],
+		[1e3, .03],
+		[2e3, .04],
+		[3e3, .0475],
+		[1e5, .05],
+		[125e3, .0525],
+		[15e4, .055],
+		[25e4, .0575],
+		[5e5, .0625],
+		[1e6, .065]
+	],
+	mfj: [
+		[0, .02],
+		[1e3, .03],
+		[2e3, .04],
+		[3e3, .0475],
+		[15e4, .05],
+		[175e3, .0525],
+		[225e3, .055],
+		[3e5, .0575],
+		[6e5, .0625],
+		[12e5, .065]
+	],
+	hoh: "mfj",
+	std: [
+		3400,
+		6800,
+		6800
+	],
+	personalExemption: [3200, 6400],
+	dependentExemption: 3200
+});
+// src/us/state/parameters/progressive/me.ts
+/**
+* 2026 Maine individual income tax parameters.
+*
+* Standard deduction phased out linearly over $75,000 (single, separate), $112,500 (head of
+* household) and $150,000 (joint) of AGI above $102,250, $153,400 and $204,550; the head of
+* household start is the statutory $120,000 indexed with the single and joint starts.
+* 2% surcharge on Maine taxable income above $1,000,000 (single), $1,500,000 (joint and head
+* of household) and $750,000 (separate), effective for tax years beginning in 2026.
+*
+* @statute Me. Rev. Stat. tit. 36, § 5111, sub-§ 7 (P.L. 2025, c. 650, Pt. DDDD)
+*/
+const US_2026_STATE_ME = defineState({
+	code: "ME",
+	name: "Maine",
+	type: "progressive",
+	single: [
+		[0, .058],
+		[27400, .0675],
+		[64850, .0715]
+	],
+	mfj: [
+		[0, .058],
+		[54850, .0675],
+		[129750, .0715]
+	],
+	hoh: [
+		[0, .058],
+		[41100, .0675],
+		[97300, .0715]
+	],
+	std: [
+		15700,
+		31400,
+		23550
+	],
+	personalExemption: [5300, 10600],
+	dependentCredit: 305,
+	standardDeductionPhaseOut: {
+		kind: "linear",
+		start: {
+			single: 102250,
+			married_filing_jointly: 204550,
+			married_filing_separately: 102250,
+			head_of_household: 153400
+		},
+		width: {
+			single: 75e3,
+			married_filing_jointly: 15e4,
+			married_filing_separately: 75e3,
+			head_of_household: 112500
+		}
+	},
+	surtax: {
+		threshold: {
+			single: 1e6,
+			married_filing_jointly: 15e5,
+			married_filing_separately: 75e4,
+			head_of_household: 15e5
+		},
+		rate: .02
+	}
+});
+// src/us/state/parameters/progressive/mn.ts
+/**
+* 2026 Minnesota individual income tax parameters.
+*
+* Standard deduction reduced by 3% of AGI over $244,400 plus 10% over $337,800 (halved for
+* separate filers), capped at 80% of the deduction; the dependent exemption is disallowed 2%
+* per $2,500 (separate: $1,250) of AGI over the threshold. Amounts are the 2026 values published
+* by the Minnesota Department of Revenue. The statutory 80% cut-off above $1,107,750 is always
+* reached earlier through the 80% cap and is not modeled separately.
+*
+* @statute Minn. Stat. §§ 290.06, 290.0121 subd. 2, 290.0123 subd. 5
+*/
+const US_2026_STATE_MN = defineState({
+	code: "MN",
+	name: "Minnesota",
+	type: "progressive",
+	single: [
+		[0, .0535],
+		[33310, .068],
+		[109430, .0785],
+		[203150, .0985]
+	],
+	mfj: [
+		[0, .0535],
+		[48700, .068],
+		[193480, .0785],
+		[337930, .0985]
+	],
+	hoh: [
+		[0, .0535],
+		[41010, .068],
+		[164800, .0785],
+		[270060, .0985]
+	],
+	std: [
+		15300,
+		30600,
+		23e3
+	],
+	mfs: "half-mfj",
+	dependentExemption: 5300,
+	standardDeductionPhaseOut: {
+		kind: "tiered",
+		start: {
+			single: 244400,
+			married_filing_jointly: 244400,
+			married_filing_separately: 122200,
+			head_of_household: 244400
+		},
+		second: {
+			single: 337800,
+			married_filing_jointly: 337800,
+			married_filing_separately: 168900,
+			head_of_household: 337800
+		},
+		rate: .03,
+		secondRate: .1,
+		maxShare: .8
+	},
+	dependentExemptionPhaseOut: {
+		kind: "stepped",
+		start: {
+			single: 244500,
+			married_filing_jointly: 366700,
+			married_filing_separately: 183350,
+			head_of_household: 305600
+		},
+		step: {
+			single: 2500,
+			married_filing_jointly: 2500,
+			married_filing_separately: 1250,
+			head_of_household: 2500
+		},
+		ratePerStep: .02
+	}
+});
+// src/us/state/parameters/progressive/mo.ts
+/**
+* 2026 Missouri individual income tax parameters.
+*
+* @statute Mo. Rev. Stat. § 143.011
+*/
+const US_2026_STATE_MO = defineState({
+	code: "MO",
+	name: "Missouri",
+	type: "progressive",
+	single: [
+		[1348, .02],
+		[2696, .025],
+		[4044, .03],
+		[5392, .035],
+		[6740, .04],
+		[8088, .045],
+		[9436, .047]
+	],
+	mfj: [
+		[2696, .02],
+		[5392, .025],
+		[8088, .03],
+		[10784, .035],
+		[13480, .04],
+		[16176, .045],
+		[18872, .047]
+	],
+	std: [16100, 32200]
+});
+// src/us/state/parameters/progressive/mt.ts
+/**
+* 2026 Montana individual income tax parameters.
+*
+* @statute Mont. Code Ann. § 15-30-2103
+*/
+const US_2026_STATE_MT = defineState({
+	code: "MT",
+	name: "Montana",
+	type: "progressive",
+	single: [[0, .047], [47500, .0565]],
+	mfj: [[0, .047], [95e3, .0565]],
+	std: [16100, 32200]
+});
+// src/us/state/parameters/progressive/nd.ts
+/**
+* 2026 North Dakota individual income tax parameters.
+*
+* @statute N.D. Cent. Code § 57-38-30.3
+*/
+const US_2026_STATE_ND = defineState({
+	code: "ND",
+	name: "North Dakota",
+	type: "progressive",
+	single: [[48475, .0195], [244825, .025]],
+	mfj: [[80975, .0195], [298075, .025]],
+	mfs: [[40475, .0195], [149025, .025]],
+	hoh: [[64950, .0195], [271450, .025]],
+	std: [16100, 32200]
+});
+// src/us/state/parameters/progressive/ne.ts
+/**
+* 2026 Nebraska individual income tax parameters.
+*
+* @statute Neb. Rev. Stat. § 77-2715.03
+*/
+const US_2026_STATE_NE = defineState({
+	code: "NE",
+	name: "Nebraska",
+	type: "progressive",
+	single: [
+		[0, .0246],
+		[4130, .0351],
+		[24760, .0455]
+	],
+	mfj: [
+		[0, .0246],
+		[8250, .0351],
+		[49530, .0455]
+	],
+	std: [8850, 17700],
+	personalCredit: [176, 352],
+	dependentCredit: 176
+});
+// src/us/state/parameters/progressive/nj.ts
+/**
+* 2026 New Jersey individual income tax parameters.
+*
+* @statute N.J. Stat. Ann. § 54A:2-1
+*/
+const US_2026_STATE_NJ = defineState({
+	code: "NJ",
+	name: "New Jersey",
+	type: "progressive",
+	single: [
+		[0, .014],
+		[2e4, .0175],
+		[35e3, .035],
+		[4e4, .05525],
+		[75e3, .0637],
+		[5e5, .0897],
+		[1e6, .1075]
+	],
+	mfj: [
+		[0, .014],
+		[2e4, .0175],
+		[5e4, .0245],
+		[7e4, .035],
+		[8e4, .05525],
+		[15e4, .0637],
+		[5e5, .0897],
+		[1e6, .1075]
+	],
+	hoh: "mfj",
+	std: [0, 0],
+	personalExemption: [1e3, 2e3],
+	dependentExemption: 1500
+});
+// src/us/state/parameters/progressive/nm.ts
+/**
+* 2026 New Mexico individual income tax parameters.
+*
+* @statute N.M. Stat. Ann. § 7-2-7
+*/
+const US_2026_STATE_NM = defineState({
+	code: "NM",
+	name: "New Mexico",
+	type: "progressive",
+	single: [
+		[0, .015],
+		[5500, .032],
+		[16500, .043],
+		[33500, .047],
+		[66500, .049],
+		[21e4, .059]
+	],
+	mfj: [
+		[0, .015],
+		[8e3, .032],
+		[25e3, .043],
+		[5e4, .047],
+		[1e5, .049],
+		[315e3, .059]
+	],
+	mfs: "half-mfj",
+	hoh: "mfj",
+	std: [16100, 32200],
+	dependentExemption: 4e3
+});
+// src/us/state/parameters/progressive/ny.ts
+/**
+* 2026 New York individual income tax parameters.
+*
+* @statute N.Y. Tax Law § 601
+*/
+const US_2026_STATE_NY = defineState({
+	code: "NY",
+	name: "New York",
+	type: "progressive",
+	single: [
+		[0, .039],
+		[8500, .044],
+		[11700, .0515],
+		[13900, .054],
+		[80650, .059],
+		[215400, .0685],
+		[1077550, .0965],
+		[5e6, .103],
+		[25e6, .109]
+	],
+	mfj: [
+		[0, .039],
+		[17150, .044],
+		[23600, .0515],
+		[27900, .054],
+		[161550, .059],
+		[323200, .0685],
+		[2155350, .0965],
+		[5e6, .103],
+		[25e6, .109]
+	],
+	hoh: [
+		[0, .039],
+		[12800, .044],
+		[17650, .0515],
+		[20900, .054],
+		[107650, .059],
+		[269300, .0685],
+		[1616450, .0965],
+		[5e6, .103],
+		[25e6, .109]
+	],
+	std: [
+		8e3,
+		16050,
+		11200
+	],
+	stdMfs: 8e3,
+	dependentExemption: 1e3
+});
+// src/us/state/parameters/progressive/ok.ts
+/**
+* 2026 Oklahoma individual income tax parameters.
+*
+* @statute Okla. Stat. tit. 68, § 2355
+*/
+const US_2026_STATE_OK = defineState({
+	code: "OK",
+	name: "Oklahoma",
+	type: "progressive",
+	single: [
+		[3750, .025],
+		[4900, .035],
+		[7200, .045]
+	],
+	mfj: [
+		[7500, .025],
+		[9800, .035],
+		[14400, .045]
+	],
+	hoh: "mfj",
+	std: [
+		6350,
+		12700,
+		9350
+	],
+	personalExemption: [1e3, 2e3],
+	dependentExemption: 1e3
+});
+// src/us/state/parameters/progressive/or.ts
+/**
+* 2026 Oregon individual income tax parameters.
+*
+* @statute Or. Rev. Stat. § 316.037
+*/
+const US_2026_STATE_OR = defineState({
+	code: "OR",
+	name: "Oregon",
+	type: "progressive",
+	single: [
+		[0, .0475],
+		[4550, .0675],
+		[11400, .0875],
+		[125e3, .099]
+	],
+	mfj: [
+		[0, .0475],
+		[9100, .0675],
+		[22800, .0875],
+		[25e4, .099]
+	],
+	hoh: "mfj",
+	std: [
+		2910,
+		5820,
+		4420
+	],
+	personalCredit: [256, 512],
+	dependentCredit: 256
+});
+// src/us/state/parameters/progressive/ri.ts
+/**
+* 2026 Rhode Island individual income tax parameters.
+*
+* @statute R.I. Gen. Laws § 44-30-2.6
+*/
+const US_2026_STATE_RI = defineState({
+	code: "RI",
+	name: "Rhode Island",
+	type: "progressive",
+	single: [
+		[0, .0375],
+		[82050, .0475],
+		[186450, .0599]
+	],
+	mfj: [
+		[0, .0375],
+		[82050, .0475],
+		[186450, .0599]
+	],
+	std: [11200, 22400],
+	personalExemption: [5250, 10500],
+	dependentExemption: 5250
+});
+// src/us/state/parameters/progressive/sc.ts
+/**
+* 2026 South Carolina individual income tax parameters.
+*
+* @statute S.C. Code Ann. § 12-6-510
+*/
+const US_2026_STATE_SC = defineState({
+	code: "SC",
+	name: "South Carolina",
+	type: "progressive",
+	single: [
+		[0, 0],
+		[3640, .03],
+		[18230, .06]
+	],
+	mfj: [
+		[0, 0],
+		[3640, .03],
+		[18230, .06]
+	],
+	std: [
+		16100,
+		32200,
+		24150
+	],
+	dependentExemption: 4930
+});
+// src/us/state/parameters/progressive/va.ts
+/**
+* 2026 Virginia individual income tax parameters.
+*
+* @statute Va. Code Ann. § 58.1-320
+*/
+const US_2026_STATE_VA = defineState({
+	code: "VA",
+	name: "Virginia",
+	type: "progressive",
+	single: [
+		[0, .02],
+		[3e3, .03],
+		[5e3, .05],
+		[17e3, .0575]
+	],
+	mfj: [
+		[0, .02],
+		[3e3, .03],
+		[5e3, .05],
+		[17e3, .0575]
+	],
+	std: [
+		8750,
+		17500,
+		8750
+	],
+	personalExemption: [930, 1860],
+	dependentExemption: 930
+});
+// src/us/state/parameters/progressive/vt.ts
+/**
+* 2026 Vermont individual income tax parameters.
+*
+* @statute Vt. Stat. Ann. tit. 32, § 5822
+*/
+const US_2026_STATE_VT = defineState({
+	code: "VT",
+	name: "Vermont",
+	type: "progressive",
+	single: [
+		[0, .0335],
+		[49400, .066],
+		[119700, .076],
+		[249700, .0875]
+	],
+	mfj: [
+		[0, .0335],
+		[82500, .066],
+		[199450, .076],
+		[304e3, .0875]
+	],
+	mfs: "half-mfj",
+	std: [7650, 15300],
+	personalExemption: [5300, 10600],
+	dependentExemption: 5300
+});
+// src/us/state/parameters/progressive/wi.ts
+/**
+* 2026 Wisconsin individual income tax parameters.
+*
+* @statute Wis. Stat. § 71.06
+*/
+const US_2026_STATE_WI = defineState({
+	code: "WI",
+	name: "Wisconsin",
+	type: "progressive",
+	single: [
+		[0, .035],
+		[15110, .044],
+		[51950, .053],
+		[332720, .0765]
+	],
+	mfj: [
+		[0, .035],
+		[20150, .044],
+		[69260, .053],
+		[443630, .0765]
+	],
+	mfs: "half-mfj",
+	std: [
+		13960,
+		25840,
+		17950
+	],
+	personalExemption: [700, 1400],
+	dependentExemption: 700
+});
+/** Statutory parameter table for all 2026 graduated-rate state individual income taxes. */
+const PROGRESSIVE_STATES = [
+	US_2026_STATE_AL,
+	US_2026_STATE_AR,
+	US_2026_STATE_CA,
+	US_2026_STATE_CT,
+	US_2026_STATE_DE,
+	US_2026_STATE_DC,
+	US_2026_STATE_HI,
+	US_2026_STATE_KS,
+	US_2026_STATE_ME,
+	US_2026_STATE_MD,
+	US_2026_STATE_MN,
+	US_2026_STATE_MO,
+	US_2026_STATE_MT,
+	US_2026_STATE_NE,
+	US_2026_STATE_NJ,
+	US_2026_STATE_NM,
+	US_2026_STATE_NY,
+	US_2026_STATE_ND,
+	US_2026_STATE_OK,
+	US_2026_STATE_OR,
+	US_2026_STATE_RI,
+	US_2026_STATE_SC,
+	US_2026_STATE_VT,
+	US_2026_STATE_VA,
+	defineState({
+		code: "WV",
+		name: "West Virginia",
+		type: "progressive",
+		single: [
+			[0, .0211],
+			[1e4, .0281],
+			[25e3, .0316],
+			[4e4, .0422],
+			[6e4, .0458]
+		],
+		mfj: [
+			[0, .0211],
+			[1e4, .0281],
+			[25e3, .0316],
+			[4e4, .0422],
+			[6e4, .0458]
+		],
+		mfs: "half-mfj",
+		std: [0, 0],
+		personalExemption: [2e3, 4e3],
+		dependentExemption: 2e3
+	}),
+	US_2026_STATE_WI
+];
+// src/us/state/parameters/index.ts
+/**
+* Consolidated statutory parameter table for all 50 US states and the District of Columbia
+* for Tax Year 2026.
+*
+* @statute State individual income tax statutes; 2026 schedules as published by the
+* state revenue departments and compiled by the Tax Foundation (February 2026).
+*/
+const US_2026_STATE_PARAMETERS = indexStates([
+	...NO_TAX_STATES,
+	...FLAT_STATES,
+	...PROGRESSIVE_STATES
+]);
+// src/us/calculate-result.ts
+function buildUsTaxResult(p) {
+	const effRate = p.agiRes.grossIncomeCents > 0 ? Math.max(0, p.totalTaxCents) / p.agiRes.grossIncomeCents : 0;
+	const netPayable = usd(fromMinorUnits(p.netTaxCents, "USD", "netTaxPayable", { allowNegative: true }), "netTaxPayable", { allowNegative: true });
+	return {
+		jurisdiction: "US",
+		taxYear: 2026,
+		currency: "USD",
+		grossIncome: p.agiRes.grossIncome,
+		taxableIncome: p.dedRes.taxableIncome,
+		totalTax: usd(fromMinorUnits(p.totalTaxCents, "USD")),
+		effectiveRate: effRate,
+		marginalRate: p.ordMarginalRate + (p.stateRes.breakdown?.marginalRate ?? 0),
+		netTaxPayable: netPayable,
+		breakdown: {
+			ordinaryGrossIncome: p.agiRes.ordinaryGrossIncome,
+			preferentialGrossIncome: p.agiRes.preferentialGrossIncome,
+			grossIncome: p.agiRes.grossIncome,
+			adjustments: p.agiRes.adjustments,
+			agi: p.agiRes.agi,
+			electedDeduction: p.dedRes.electedDeduction,
+			standardDeduction: p.dedRes.standardBreakdown,
+			itemizedDeductions: p.dedRes.itemizedBreakdown,
+			allowableDeduction: p.dedRes.allowableDeduction,
+			ordinaryTaxableIncome: p.dedRes.ordinaryTaxableIncome,
+			preferentialTaxableIncome: p.dedRes.preferentialTaxableIncome,
+			taxableIncome: p.dedRes.taxableIncome,
+			ordinaryTax: usd(fromMinorUnits(p.ordTaxCents, "USD")),
+			ordinarySlices: p.ordSlices,
+			preferentialTax: p.prefRes.preferentialTax,
+			preferentialSlices: p.prefRes.slices,
+			regularIncomeTax: usd(fromMinorUnits(p.regularTaxCents, "USD")),
+			amt: p.amtRes.breakdown,
+			niit: p.niitRes.breakdown,
+			fica: p.ficaRes.breakdown,
+			scheduleSe: p.seRes.breakdown,
+			credits: p.creditsRes.breakdown,
+			state: p.stateRes.breakdown,
+			totalTax: usd(fromMinorUnits(p.totalTaxCents, "USD")),
+			withholding: usd(fromMinorUnits(p.withhCents, "USD")),
+			netTaxPayable: netPayable
+		}
+	};
+}
+// src/us/stages/adjustments.ts
+function resolveAdjustmentClamped(amount, capDollars, field) {
+	const reqCents = toMinorUnits(amount ?? 0, "USD", field);
+	const capCents = toMinorUnits(capDollars, "USD", `${field}Cap`);
+	const clampedCents = clampCap(reqCents, capCents, field);
+	return {
+		cents: clampedCents.allowed,
+		clamped: {
+			requested: fromMinorUnits(clampedCents.requested, "USD"),
+			allowed: fromMinorUnits(clampedCents.allowed, "USD"),
+			cap: fromMinorUnits(clampedCents.cap, "USD"),
+			wasClamped: clampedCents.wasClamped
+		}
+	};
+}
+function resolveCaps(adj, status, params) {
+	const p = params.aboveTheLineCaps;
+	return {
+		educator: status === "married_filing_jointly" && adj?.bothSpousesEducators ? p.educatorMfjBoth : p.educatorSingle,
+		hsa: (adj?.hsaCoverageType === "family" ? p.hsaFamilyBase : p.hsaSelfOnlyBase) + (adj?.age55OrOlder ? p.hsaCatchUpAge55 : 0),
+		ira: p.traditionalIraBase + (adj?.age50OrOlder ? p.traditionalIraCatchUpAge50 : 0),
+		k401: p.traditional401kBase + (adj?.age50OrOlder ? p.traditional401kCatchUpAge50 : 0),
+		student: p.studentLoanInterest
+	};
+}
+/**
+* Evaluates Schedule 1 Above-the-Line Adjustments clamped to statutory caps.
+*
+* @statute IRC § 62, § 219, § 221, § 223, § 402(g)
+*/
+function calculateUsAdjustments(adjustments, filingStatus, params) {
+	const caps = resolveCaps(adjustments, filingStatus, params);
+	const edu = resolveAdjustmentClamped(adjustments?.educatorExpenses, caps.educator, "educatorExpenses");
+	const hsa = resolveAdjustmentClamped(adjustments?.hsaContributions, caps.hsa, "hsaContributions");
+	const ira = resolveAdjustmentClamped(adjustments?.traditionalIraContributions, caps.ira, "traditionalIra");
+	const sl = resolveAdjustmentClamped(adjustments?.studentLoanInterest, caps.student, "studentLoanInterest");
+	const k401 = resolveAdjustmentClamped(adjustments?.preTaxDeferrals401k, caps.k401, "preTaxDeferrals401k");
+	const seCents = toMinorUnits(adjustments?.deductibleSelfEmploymentTax ?? 0, "USD", "deductibleSeTax");
+	const totalAdjCents = edu.cents + hsa.cents + ira.cents + sl.cents + k401.cents + seCents;
+	return {
+		totalAdjCents,
+		breakdown: {
+			educatorExpenses: edu.clamped,
+			hsa: hsa.clamped,
+			traditionalIra: ira.clamped,
+			studentLoanInterest: sl.clamped,
+			preTaxDeferrals401k: k401.clamped,
+			deductibleSelfEmploymentTax: usd(fromMinorUnits(seCents, "USD")),
+			totalAdjustments: usd(fromMinorUnits(totalAdjCents, "USD"))
+		}
+	};
+}
+// src/us/stages/agi.ts
+function sumOrdinaryIncomeCents(income) {
+	return toMinorUnits(income.w2Wages ?? 0, "USD", "w2Wages") + toMinorUnits(income.selfEmploymentNetEarnings ?? 0, "USD", "selfEmploymentNetEarnings", { allowNegative: true }) + toMinorUnits(income.ordinaryInterest ?? 0, "USD", "ordinaryInterest") + toMinorUnits(income.ordinaryDividends ?? 0, "USD", "ordinaryDividends") + toMinorUnits(income.shortTermCapitalGains ?? 0, "USD", "shortTermCapitalGains") + toMinorUnits(income.rentalAndOtherOrdinaryIncome ?? 0, "USD", "rentalAndOtherOrdinaryIncome");
+}
+function sumPreferentialIncomeCents(income) {
+	return toMinorUnits(income.longTermCapitalGains ?? 0, "USD", "longTermCapitalGains") + toMinorUnits(income.qualifiedDividends ?? 0, "USD", "qualifiedDividends");
+}
+/**
+* Computes Gross Income, clamped Schedule 1 Adjustments, and AGI in minor units.
+*
+* @statute IRC § 61, § 62
+*/
+function calculateUsAgi(income, adjustments, filingStatus, params) {
+	const ordinaryCents = sumOrdinaryIncomeCents(income);
+	const prefCents = sumPreferentialIncomeCents(income);
+	const grossCents = ordinaryCents + prefCents;
+	const adjResult = calculateUsAdjustments(adjustments, filingStatus, params);
+	const agiCents = Math.max(0, grossCents - adjResult.totalAdjCents);
+	return {
+		ordinaryGrossCents: ordinaryCents,
+		preferentialGrossCents: prefCents,
+		grossIncomeCents: grossCents,
+		totalAdjustmentsCents: adjResult.totalAdjCents,
+		agiCents,
+		ordinaryGrossIncome: usd(fromMinorUnits(ordinaryCents, "USD", "ordinaryGrossIncome", { allowNegative: true }), "ordinaryGrossIncome", { allowNegative: true }),
+		preferentialGrossIncome: usd(fromMinorUnits(prefCents, "USD")),
+		grossIncome: usd(fromMinorUnits(grossCents, "USD", "grossIncome", { allowNegative: true }), "grossIncome", { allowNegative: true }),
+		agi: usd(fromMinorUnits(agiCents, "USD")),
+		adjustments: adjResult.breakdown
+	};
+}
+// src/us/types/fields.ts
+/**
+* Diagnostic and reporting field identifiers for US income sources.
+*/
+let UsIncomeField = /* @__PURE__ */ function(UsIncomeField) {
+	UsIncomeField["W2Wages"] = "income.w2Wages";
+	UsIncomeField["SelfEmploymentNetEarnings"] = "income.selfEmploymentNetEarnings";
+	UsIncomeField["OrdinaryInterest"] = "income.ordinaryInterest";
+	UsIncomeField["OrdinaryDividends"] = "income.ordinaryDividends";
+	UsIncomeField["ShortTermCapitalGains"] = "income.shortTermCapitalGains";
+	UsIncomeField["RentalAndOtherOrdinaryIncome"] = "income.rentalAndOtherOrdinaryIncome";
+	UsIncomeField["LongTermCapitalGains"] = "income.longTermCapitalGains";
+	UsIncomeField["QualifiedDividends"] = "income.qualifiedDividends";
+	return UsIncomeField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for Schedule 1 adjustments.
+*/
+let UsAdjustmentField = /* @__PURE__ */ function(UsAdjustmentField) {
+	UsAdjustmentField["EducatorExpenses"] = "adjustments.educatorExpenses";
+	UsAdjustmentField["HsaContributions"] = "adjustments.hsaContributions";
+	UsAdjustmentField["TraditionalIra"] = "adjustments.traditionalIra";
+	UsAdjustmentField["StudentLoanInterest"] = "adjustments.studentLoanInterest";
+	UsAdjustmentField["PreTaxDeferrals401k"] = "adjustments.preTaxDeferrals401k";
+	UsAdjustmentField["DeductibleSeTax"] = "adjustments.deductibleSeTax";
+	return UsAdjustmentField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for Schedule A itemized deductions.
+*/
+let UsDeductionField = /* @__PURE__ */ function(UsDeductionField) {
+	UsDeductionField["MedicalExpenses"] = "itemized.medicalExpenses";
+	UsDeductionField["StateAndLocalTaxes"] = "itemized.stateAndLocalTaxes";
+	UsDeductionField["MortgageInterest"] = "itemized.mortgageInterest";
+	UsDeductionField["CharitableContributions"] = "itemized.charitableContributions";
+	UsDeductionField["StandardDeduction"] = "deductions.standard";
+	return UsDeductionField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for Payroll and Self-Employment taxes.
+*/
+let UsPayrollField = /* @__PURE__ */ function(UsPayrollField) {
+	UsPayrollField["FicaSocialSecurity"] = "payroll.fica.socialSecurity";
+	UsPayrollField["FicaMedicare"] = "payroll.fica.medicare";
+	UsPayrollField["FicaAdditionalMedicare"] = "payroll.fica.additionalMedicare";
+	UsPayrollField["SeSocialSecurity"] = "payroll.se.socialSecurity";
+	UsPayrollField["SeMedicare"] = "payroll.se.medicare";
+	UsPayrollField["SeDeductiblePortion"] = "payroll.se.deductiblePortion";
+	return UsPayrollField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for Alternative Minimum Tax.
+*/
+let UsAmtField = /* @__PURE__ */ function(UsAmtField) {
+	UsAmtField["Amti"] = "amt.amti";
+	UsAmtField["Exemption"] = "amt.exemption";
+	UsAmtField["Preferences"] = "amt.preferences";
+	UsAmtField["TentativeMinimumTax"] = "amt.tentativeMinimumTax";
+	UsAmtField["AmtTax"] = "amt.tax";
+	return UsAmtField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for Federal Tax Credits.
+*/
+let UsCreditField = /* @__PURE__ */ function(UsCreditField) {
+	UsCreditField["ChildTaxCredit"] = "credits.ctc";
+	UsCreditField["AdditionalChildTaxCredit"] = "credits.actc";
+	UsCreditField["OtherDependentCredit"] = "credits.odc";
+	UsCreditField["EarnedIncomeTaxCredit"] = "credits.eitc";
+	UsCreditField["ChildAndDependentCare"] = "credits.care";
+	UsCreditField["Aotc"] = "credits.aotc";
+	UsCreditField["Llc"] = "credits.llc";
+	UsCreditField["ForeignTaxCredit"] = "credits.ftc";
+	UsCreditField["CustomNonRefundable"] = "credits.customNonRefundable";
+	UsCreditField["CustomRefundable"] = "credits.customRefundable";
+	return UsCreditField;
+}({});
+/**
+* Diagnostic and reporting field identifiers for US federal tax totals.
+*/
+let UsTaxField = /* @__PURE__ */ function(UsTaxField) {
+	UsTaxField["GrossIncome"] = "grossIncome";
+	UsTaxField["TaxableIncome"] = "taxableIncome";
+	UsTaxField["RegularIncomeTax"] = "regularIncomeTax";
+	UsTaxField["TotalTax"] = "totalTax";
+	UsTaxField["Withholding"] = "withholding";
+	UsTaxField["NetTaxPayable"] = "netTaxPayable";
+	return UsTaxField;
+}({});
+// src/us/stages/amt.ts
+/**
+* Resolves the Schedule A SALT add-back for Form 6251.
+*
+* @param deductions Deduction stage result carrying the elected method and Schedule A.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns Allowed SALT deduction in integer cents (0 unless itemizing).
+* @throws {TaxValidationError} if the allowed SALT amount is not representable as cents.
+* @statute IRC § 56(b)(1)(A)(ii)
+*/
+function resolveAmtSaltCents(deductions, currency) {
+	return deductions.electedDeduction === "itemized" && deductions.itemizedBreakdown ? toMinorUnits(deductions.itemizedBreakdown.salt.allowed, currency) : 0;
+}
+/**
+* Computes Form 6251 Alternative Minimum Tax (AMT).
+*
+* @statute IRC § 55
+*/
+function calculateUsAmt(taxableIncomeCents, saltDeductionCents, preferencesDollars, regularTaxCents, filingStatus, params) {
+	const prefCents = toMinorUnits(preferencesDollars ?? 0, params.currency, "amt.preferences");
+	const amtiCents = taxableIncomeCents + saltDeductionCents + prefCents;
+	const baseExemptionCents = toMinorUnits(params.amt.baseExemptions[filingStatus], params.currency);
+	const phaseoutCents = toMinorUnits(params.amt.phaseoutThresholds[filingStatus], params.currency);
+	const excessAmtiCents = Math.max(0, amtiCents - phaseoutCents);
+	const reductionCents = Math.round(excessAmtiCents * params.amt.phaseoutRate);
+	const allowedExemptionCents = Math.max(0, baseExemptionCents - reductionCents);
+	const amtBaseCents = Math.max(0, amtiCents - allowedExemptionCents);
+	const cap26Cents = toMinorUnits(params.amt.rate26Thresholds[filingStatus], params.currency);
+	let tmtCents;
+	if (amtBaseCents <= cap26Cents) tmtCents = Math.round(amtBaseCents * params.amt.rate26);
+	else tmtCents = Math.round(cap26Cents * params.amt.rate26 + (amtBaseCents - cap26Cents) * params.amt.rate28);
+	const amtTaxCents = Math.max(0, tmtCents - regularTaxCents);
+	return {
+		amtTaxCents,
+		tentativeMinimumTaxCents: tmtCents,
+		breakdown: {
+			taxableIncome: usd(fromMinorUnits(taxableIncomeCents, params.currency)),
+			saltAddBack: usd(fromMinorUnits(saltDeductionCents, params.currency)),
+			preferences: usd(fromMinorUnits(prefCents, params.currency, "amt.preferences")),
+			amti: usd(fromMinorUnits(amtiCents, params.currency, "amt.amti")),
+			baseExemption: usd(fromMinorUnits(baseExemptionCents, params.currency)),
+			phaseoutThreshold: usd(fromMinorUnits(phaseoutCents, params.currency)),
+			exemptionReduction: usd(fromMinorUnits(reductionCents, params.currency)),
+			allowedExemption: usd(fromMinorUnits(allowedExemptionCents, params.currency, "amt.exemption")),
+			amtTaxableBase: usd(fromMinorUnits(amtBaseCents, params.currency)),
+			tentativeMinimumTax: usd(fromMinorUnits(tmtCents, params.currency, "amt.tentativeMinimumTax")),
+			regularTax: usd(fromMinorUnits(regularTaxCents, params.currency)),
+			amtTax: usd(fromMinorUnits(amtTaxCents, params.currency, "amt.tax"))
+		}
+	};
+}
+// src/us/stages/credits-child.ts
+function resolveCtcAllocation(initialCtc, initialOdc, reduction) {
+	if (reduction <= initialOdc) return {
+		allowedCtc: initialCtc,
+		allowedOdc: initialOdc - reduction
+	};
+	const remReduction = reduction - initialOdc;
+	return {
+		allowedCtc: Math.max(0, initialCtc - remReduction),
+		allowedOdc: 0
+	};
+}
+/**
+* Computes Child Tax Credit (CTC), ODC, and refundable Additional Child Tax Credit (ACTC).
+*
+* @statute IRC § 24
+*/
+function calculateUsChildCredits(credits, magiDollars, earnedIncomeDollars, taxAvailableCents, status, params) {
+	const children = Math.max(0, Math.floor(credits?.qualifyingChildrenForChildTaxCredit ?? 0));
+	const otherDeps = Math.max(0, Math.floor(credits?.otherDependents ?? 0));
+	const initCtc = children * params.credits.ctcAmountPerChild;
+	const initOdc = otherDeps * params.credits.odcAmountPerDependent;
+	const thresh = params.credits.ctcPhaseoutThresholds[status];
+	const excessMagi = Math.max(0, magiDollars - thresh);
+	const reduction = Math.ceil(excessMagi / params.credits.ctcPhaseoutStepAmount) * params.credits.ctcPhaseoutStepRate;
+	const { allowedCtc, allowedOdc } = resolveCtcAllocation(initCtc, initOdc, reduction);
+	const ctcCents = toMinorUnits(allowedCtc, params.currency);
+	const odcCents = toMinorUnits(allowedOdc, params.currency);
+	const nonRefCtcUsed = Math.min(ctcCents, taxAvailableCents);
+	const nonRefOdcUsed = Math.min(odcCents, taxAvailableCents - nonRefCtcUsed);
+	const unusedCtcDollars = allowedCtc - fromMinorUnits(nonRefCtcUsed, params.currency);
+	const earnedFormula = Math.max(0, earnedIncomeDollars - params.credits.actcEarnedIncomeThreshold) * params.credits.actcRate;
+	const maxActc = children * params.credits.actcMaxPerChild;
+	const actcCents = toMinorUnits(Math.min(unusedCtcDollars, maxActc, earnedFormula), params.currency);
+	return {
+		nonRefundableUsedCents: nonRefCtcUsed + nonRefOdcUsed,
+		actcRefundableCents: actcCents,
+		breakdown: {
+			qualifyingChildren: children,
+			otherDependents: otherDeps,
+			initialCtc: usd(fromMinorUnits(toMinorUnits(initCtc, params.currency), params.currency)),
+			initialOdc: usd(fromMinorUnits(toMinorUnits(initOdc, params.currency), params.currency)),
+			phaseoutReduction: usd(fromMinorUnits(toMinorUnits(reduction, params.currency), params.currency)),
+			allowedCtc: usd(fromMinorUnits(ctcCents, params.currency)),
+			allowedOdc: usd(fromMinorUnits(odcCents, params.currency)),
+			nonRefundableCtcUsed: usd(fromMinorUnits(nonRefCtcUsed, params.currency, "credits.ctc")),
+			nonRefundableOdcUsed: usd(fromMinorUnits(nonRefOdcUsed, params.currency, "credits.odc")),
+			actcRefundable: usd(fromMinorUnits(actcCents, params.currency, "credits.actc"))
+		}
+	};
+}
+// src/us/stages/credits-eitc.ts
+function resolveTierKey(count) {
+	if (count <= 0) return 0;
+	if (count === 1) return 1;
+	if (count === 2) return 2;
+	return 3;
+}
+/**
+* Computes Earned Income Tax Credit (EITC) across child tiers 0, 1, 2, 3+.
+*
+* @statute IRC § 32
+*/
+function calculateUsEitc(credits, earnedIncomeDollars, investmentIncomeDollars, agiDollars, status, params) {
+	const children = Math.max(0, Math.floor(credits?.eitcQualifyingChildren ?? 0));
+	const invLimit = params.credits.eitcInvestmentIncomeLimit;
+	if (investmentIncomeDollars > invLimit || status === "married_filing_separately" || earnedIncomeDollars <= 0) return {
+		creditCents: 0,
+		breakdown: {
+			qualifyingChildren: children,
+			earnedIncome: usd(fromMinorUnits(toMinorUnits(Math.max(0, earnedIncomeDollars), params.currency), params.currency)),
+			disqualifiedByInvestmentIncome: investmentIncomeDollars > invLimit,
+			credit: usd(0)
+		}
+	};
+	const tierKey = resolveTierKey(children);
+	const tier = params.credits.eitcTiers[tierKey];
+	const tentative = Math.min(earnedIncomeDollars * tier.creditRate, tier.maxCredit);
+	const phaseoutBasis = Math.max(earnedIncomeDollars, agiDollars);
+	const thresh = status === "married_filing_jointly" ? tier.phaseoutThresholdMfj : tier.phaseoutThresholdSingle;
+	const reduction = Math.max(0, phaseoutBasis - thresh) * tier.phaseoutRate;
+	const creditDollars = Math.max(0, tentative - reduction);
+	const creditCents = toMinorUnits(creditDollars, params.currency);
+	return {
+		creditCents,
+		breakdown: {
+			qualifyingChildren: children,
+			earnedIncome: usd(fromMinorUnits(toMinorUnits(earnedIncomeDollars, params.currency), params.currency)),
+			disqualifiedByInvestmentIncome: false,
+			credit: usd(fromMinorUnits(creditCents, params.currency, "credits.eitc"))
+		}
+	};
+}
+// src/us/stages/credits-care.ts
+/**
+* Calculates Child and Dependent Care Credit (IRC § 21).
+*
+* @statute IRC § 21
+*/
+function calculateUsCareCredit(credits, earnedDollars, agiDollars, params) {
+	const individuals = Math.max(0, credits?.qualifyingIndividualsForCare ?? 0);
+	if (individuals <= 0) return 0;
+	const maxExp = individuals >= 2 ? params.credits.careMaxExpenseTwoPlus : params.credits.careMaxExpenseOne;
+	const expenses = Math.min(Math.max(0, credits?.childAndDependentCareExpenses ?? 0), maxExp, earnedDollars);
+	const excessAgi = Math.max(0, agiDollars - params.credits.carePhaseoutAgiThreshold);
+	const rateReduction = Math.ceil(excessAgi / params.credits.carePhaseoutStepAgi) * params.credits.carePhaseoutStepRate;
+	const rate = Math.max(params.credits.careFloorRate, params.credits.careBaseRate - rateReduction);
+	return toMinorUnits(expenses * rate, params.currency);
+}
+// src/us/stages/credits-other.ts
+function calculateEducationCredits(credits, magiDollars, status, params) {
+	if (status === "married_filing_separately") return {
+		nonRefAotc: 0,
+		refAotc: 0,
+		nonRefLlc: 0
+	};
+	const pMin = params.credits.aotcPhaseoutMin[status];
+	const pMax = params.credits.aotcPhaseoutMax[status];
+	const factor = magiDollars <= pMin ? 1 : magiDollars >= pMax ? 0 : (pMax - magiDollars) / (pMax - pMin);
+	let rawAotc = 0;
+	let llcExp = 0;
+	for (const student of credits?.educationStudents ?? []) if (student.type === "aotc") {
+		const exp = Math.max(0, student.qualifiedExpenses);
+		const tier1 = Math.min(exp, params.credits.aotcTier1MaxExpense) * params.credits.aotcTier1Rate;
+		const tier2 = Math.max(0, Math.min(exp - params.credits.aotcTier1MaxExpense, params.credits.aotcTier2MaxExpense)) * params.credits.aotcTier2Rate;
+		const cappedStudentAotc = Math.min(tier1 + tier2, params.credits.aotcMaxPerStudent);
+		rawAotc += cappedStudentAotc * factor;
+	} else llcExp += Math.max(0, student.qualifiedExpenses);
+	const refAotc = toMinorUnits(rawAotc * params.credits.aotcRefundableRate, params.currency);
+	const nonRefAotc = toMinorUnits(rawAotc * (1 - params.credits.aotcRefundableRate), params.currency);
+	const rawLlc = Math.min(llcExp, params.credits.llcMaxExpensePerReturn) * params.credits.llcRate * factor;
+	return {
+		nonRefAotc,
+		refAotc,
+		nonRefLlc: toMinorUnits(rawLlc, params.currency)
+	};
+}
+/**
+* Computes Child and Dependent Care, Education, Foreign Tax, and Custom credits.
+*
+* @statute IRC §§ 21, 25A, 901
+*/
+function calculateUsOtherCredits(credits, earnedDollars, agiDollars, magiDollars, status, params) {
+	const careCents = calculateUsCareCredit(credits, earnedDollars, agiDollars, params);
+	const edu = calculateEducationCredits(credits, magiDollars, status, params);
+	const ftcCents = toMinorUnits(Math.max(0, credits?.foreignTaxCredit ?? 0), params.currency);
+	const custNonRefCents = toMinorUnits(Math.max(0, credits?.customNonRefundableCredits ?? 0), params.currency);
+	const custRefCents = toMinorUnits(Math.max(0, credits?.customRefundableCredits ?? 0), params.currency);
+	return {
+		careNonRefundableCents: careCents,
+		aotcNonRefundableCents: edu.nonRefAotc,
+		aotcRefundableCents: edu.refAotc,
+		llcNonRefundableCents: edu.nonRefLlc,
+		foreignTaxCreditCents: ftcCents,
+		customNonRefundableCents: custNonRefCents,
+		customRefundableCents: custRefCents,
+		educationBreakdown: {
+			aotcNonRefundable: usd(fromMinorUnits(edu.nonRefAotc, params.currency)),
+			aotcRefundable: usd(fromMinorUnits(edu.refAotc, params.currency)),
+			llcNonRefundable: usd(fromMinorUnits(edu.nonRefLlc, params.currency)),
+			totalNonRefundable: usd(fromMinorUnits(edu.nonRefAotc + edu.nonRefLlc, params.currency)),
+			totalRefundable: usd(fromMinorUnits(edu.refAotc, params.currency))
+		}
+	};
+}
+// src/us/stages/se.ts
+/**
+* Calculates net earnings from self-employment subject to SECA/FICA tax (IRC § 1402(a)).
+*
+* @statute IRC § 1402(a)
+*/
+function calculateNetSelfEmploymentEarnings(earnings, seNetEarningsFactor) {
+	return Math.max(0, (earnings ?? 0) * seNetEarningsFactor);
+}
+/**
+* Computes Schedule SE Self-Employment Tax (SECA).
+*
+* @statute IRC § 1401, § 1402
+*/
+function calculateUsScheduleSe(income, params) {
+	const rawNetEarnings = Math.max(0, income.selfEmploymentNetEarnings ?? 0);
+	const factor = params.payroll.seNetEarningsFactor;
+	const subjectAmount = calculateNetSelfEmploymentEarnings(rawNetEarnings, factor);
+	const applies = subjectAmount >= params.payroll.seThresholdFloor;
+	const w2Dollars = Math.max(0, income.w2Wages ?? 0);
+	const remainingWageBase = Math.max(0, params.payroll.socialSecurityWageBase - w2Dollars);
+	const ssTaxableDollars = applies ? Math.min(subjectAmount, remainingWageBase) : 0;
+	const ssTaxCents = Math.round(ssTaxableDollars * params.payroll.seSocialSecurityRate * 100);
+	const medTaxCents = applies ? Math.round(subjectAmount * params.payroll.seMedicareRate * 100) : 0;
+	const totalSeTaxCents = ssTaxCents + medTaxCents;
+	const deductibleCents = Math.round(totalSeTaxCents * params.payroll.seDeductibleRate);
+	return {
+		totalSeTaxCents,
+		deductiblePortionCents: deductibleCents,
+		deductiblePortionDollars: fromMinorUnits(deductibleCents, params.currency),
+		breakdown: {
+			netEarnings: usd(fromMinorUnits(toMinorUnits(rawNetEarnings, params.currency), params.currency)),
+			netEarningsMultiplier: factor,
+			subjectEarnings: usd(fromMinorUnits(toMinorUnits(applies ? subjectAmount : 0, params.currency), params.currency)),
+			socialSecurityTaxable: usd(fromMinorUnits(toMinorUnits(ssTaxableDollars, params.currency), params.currency)),
+			socialSecurityTax: usd(fromMinorUnits(ssTaxCents, params.currency, "payroll.se.socialSecurity")),
+			medicareTax: usd(fromMinorUnits(medTaxCents, params.currency, "payroll.se.medicare")),
+			totalSelfEmploymentTax: usd(fromMinorUnits(totalSeTaxCents, params.currency)),
+			deductiblePortion: usd(fromMinorUnits(deductibleCents, params.currency, "payroll.se.deductiblePortion"))
+		}
+	};
+}
+// src/us/stages/credits.ts
+/**
+* Coordinates and computes all statutory federal tax credits.
+*
+* @statute IRC §§ 21, 24, 25A, 32, 901
+*/
+function calculateUsCredits(input, agiCents, taxAvailableCents, params) {
+	const agiDollars = fromMinorUnits(agiCents, params.currency);
+	const magiDollars = input.magi ?? agiDollars;
+	const earnedDollars = Math.max(0, input.income.w2Wages ?? 0) + calculateNetSelfEmploymentEarnings(input.income.selfEmploymentNetEarnings, params.payroll.seNetEarningsFactor);
+	const invDollars = (input.credits?.eitcInvestmentIncome ?? 0) + Math.max(0, input.income.ordinaryInterest ?? 0) + Math.max(0, input.income.ordinaryDividends ?? 0) + Math.max(0, input.income.longTermCapitalGains ?? 0);
+	const child = calculateUsChildCredits(input.credits, magiDollars, earnedDollars, taxAvailableCents, input.filingStatus, params);
+	const eitc = calculateUsEitc(input.credits, earnedDollars, invDollars, agiDollars, input.filingStatus, params);
+	const other = calculateUsOtherCredits(input.credits, earnedDollars, agiDollars, magiDollars, input.filingStatus, params);
+	const totalNonRefClaimed = child.nonRefundableUsedCents + other.careNonRefundableCents + other.aotcNonRefundableCents + other.llcNonRefundableCents + other.foreignTaxCreditCents + other.customNonRefundableCents;
+	const allowedNonRefCents = Math.min(totalNonRefClaimed, taxAvailableCents);
+	const totalRefCents = child.actcRefundableCents + eitc.creditCents + other.aotcRefundableCents + other.customRefundableCents;
+	return {
+		allowedNonRefundableCents: allowedNonRefCents,
+		totalRefundableCents: totalRefCents,
+		breakdown: {
+			childCredits: child.breakdown,
+			eitc: eitc.breakdown,
+			childAndDependentCare: usd(fromMinorUnits(other.careNonRefundableCents, params.currency)),
+			education: other.educationBreakdown,
+			foreignTaxCredit: usd(fromMinorUnits(other.foreignTaxCreditCents, params.currency)),
+			customNonRefundable: usd(fromMinorUnits(other.customNonRefundableCents, params.currency)),
+			customRefundable: usd(fromMinorUnits(other.customRefundableCents, params.currency)),
+			totalNonRefundableClaimed: usd(fromMinorUnits(totalNonRefClaimed, params.currency)),
+			totalNonRefundableAllowed: usd(fromMinorUnits(allowedNonRefCents, params.currency)),
+			totalRefundable: usd(fromMinorUnits(totalRefCents, params.currency))
+		}
+	};
+}
+// src/us/stages/itemized-deduction.ts
+function resolveMedical(medDollars, agiCents, floorRate) {
+	const reqCents = toMinorUnits(medDollars ?? 0, "USD", "medicalExpenses");
+	const floorCents = applyPercentage(agiCents, floorRate);
+	const allowedCents = Math.max(0, reqCents - floorCents);
+	return {
+		cents: allowedCents,
+		clamped: {
+			requested: fromMinorUnits(reqCents, "USD"),
+			allowed: fromMinorUnits(allowedCents, "USD"),
+			cap: fromMinorUnits(floorCents, "USD"),
+			wasClamped: reqCents > 0 && allowedCents < reqCents
+		}
+	};
+}
+function resolveCharity(charityDollars, agiCents, ceilRate) {
+	const reqCents = toMinorUnits(charityDollars ?? 0, "USD", "charitableContributions");
+	const ceilCents = applyPercentage(agiCents, ceilRate);
+	const clamped = clampCap(reqCents, ceilCents, "charitableContributions");
+	return {
+		cents: clamped.allowed,
+		clamped: {
+			requested: fromMinorUnits(clamped.requested, "USD"),
+			allowed: fromMinorUnits(clamped.allowed, "USD"),
+			cap: fromMinorUnits(clamped.cap, "USD"),
+			wasClamped: clamped.wasClamped
+		}
+	};
+}
+/**
+* Computes Schedule A Itemized Deductions subject to floors and statutory caps.
+*
+* @statute IRC §§ 164, 170, 213
+*/
+function calculateUsItemizedDeductions(itemized, agiCents, filingStatus, params) {
+	const med = resolveMedical(itemized.medicalExpenses, agiCents, params.itemized.medicalFloorRate);
+	const saltCapDollars = filingStatus === "married_filing_separately" ? params.itemized.saltCapMfs : params.itemized.saltCap;
+	const saltReqCents = toMinorUnits(itemized.stateAndLocalTaxes ?? 0, "USD", "stateAndLocalTaxes");
+	const saltCapCents = toMinorUnits(saltCapDollars, "USD");
+	const saltClamped = clampCap(saltReqCents, saltCapCents, "stateAndLocalTaxes");
+	const mortCents = toMinorUnits(itemized.mortgageInterest ?? 0, "USD", "mortgageInterest");
+	const charity = resolveCharity(itemized.charitableContributions, agiCents, params.itemized.charityCeilingRate);
+	const totalCents = med.cents + saltClamped.allowed + mortCents + charity.cents;
+	return {
+		totalCents,
+		breakdown: {
+			medical: med.clamped,
+			salt: {
+				requested: fromMinorUnits(saltClamped.requested, "USD"),
+				allowed: fromMinorUnits(saltClamped.allowed, "USD"),
+				cap: fromMinorUnits(saltClamped.cap, "USD"),
+				wasClamped: saltClamped.wasClamped
+			},
+			mortgageInterest: usd(fromMinorUnits(mortCents, "USD")),
+			charity: charity.clamped,
+			total: usd(fromMinorUnits(totalCents, "USD"))
+		}
+	};
+}
+// src/us/stages/standard-deduction.ts
+function countAdditionalConditions(input, isUnmarried) {
+	let count = 0;
+	if (input.taxpayerAge65OrOlder) count++;
+	if (input.taxpayerBlind) count++;
+	if (!isUnmarried) {
+		if (input.spouseAge65OrOlder) count++;
+		if (input.spouseBlind) count++;
+	}
+	return count;
+}
+/**
+* Computes base and additional standard deduction for age and blindness in minor units.
+*
+* @statute IRC § 63(c), § 63(f)
+*/
+function calculateUsStandardDeduction(input, filingStatus, params) {
+	const baseDollars = params.standardDeduction[filingStatus];
+	const baseCents = toMinorUnits(baseDollars, "USD");
+	const isUnmarried = filingStatus === "single" || filingStatus === "head_of_household";
+	const perCondDollars = isUnmarried ? params.additionalStandardDeduction.unmarried : params.additionalStandardDeduction.married;
+	const perCondCents = toMinorUnits(perCondDollars, "USD");
+	const condCount = countAdditionalConditions(input, isUnmarried);
+	const addTotalCents = condCount * perCondCents;
+	const totalCents = baseCents + addTotalCents;
+	return {
+		totalCents,
+		breakdown: {
+			base: usd(fromMinorUnits(baseCents, "USD")),
+			additionalConditionsCount: condCount,
+			additionalPerCondition: usd(fromMinorUnits(perCondCents, "USD")),
+			additionalTotal: usd(fromMinorUnits(addTotalCents, "USD")),
+			total: usd(fromMinorUnits(totalCents, "USD"))
+		}
+	};
+}
+// src/us/stages/deductions.ts
+function resolveElectedMethod(election, itemizedCents, standardCents, hasItemized) {
+	if (election === "itemized") return "itemized";
+	if (election === "standard") return "standard";
+	return hasItemized && itemizedCents > standardCents ? "itemized" : "standard";
+}
+/**
+* Evaluates Standard vs. Schedule A Itemized Deduction election and slices taxable income.
+*
+* @statute IRC § 63, § 1(h)
+*/
+function calculateUsDeductions(input, agiCents, preferentialGrossCents, filingStatus, params) {
+	const std = calculateUsStandardDeduction(input, filingStatus, params);
+	const hasItemized = input.itemizedDeductions !== void 0;
+	const itm = hasItemized ? calculateUsItemizedDeductions(input.itemizedDeductions, agiCents, filingStatus, params) : void 0;
+	const elected = resolveElectedMethod(input.deductionElection, itm?.totalCents ?? 0, std.totalCents, hasItemized);
+	const allowableCents = elected === "itemized" && itm ? itm.totalCents : std.totalCents;
+	const taxableCents = Math.max(0, agiCents - allowableCents);
+	const ordinaryTaxableCents = Math.max(0, taxableCents - preferentialGrossCents);
+	const preferentialTaxableCents = taxableCents - ordinaryTaxableCents;
+	return {
+		electedDeduction: elected,
+		allowableDeductionCents: allowableCents,
+		allowableDeduction: usd(fromMinorUnits(allowableCents, "USD")),
+		taxableIncomeCents: taxableCents,
+		taxableIncome: usd(fromMinorUnits(taxableCents, "USD")),
+		ordinaryTaxableCents,
+		ordinaryTaxableIncome: usd(fromMinorUnits(ordinaryTaxableCents, "USD")),
+		preferentialTaxableCents,
+		preferentialTaxableIncome: usd(fromMinorUnits(preferentialTaxableCents, "USD")),
+		standardBreakdown: std.breakdown,
+		itemizedBreakdown: itm?.breakdown
+	};
+}
+// src/us/stages/fica.ts
+/**
+* Computes W-2 FICA payroll taxes and Additional Medicare Tax on earned income.
+*
+* @statute IRC § 3101, § 1401(b)(2)
+*/
+function calculateUsFica(income, filingStatus, includeFica, params) {
+	if (!includeFica) return {
+		totalFicaCents: 0,
+		breakdown: {
+			enabled: false,
+			socialSecurityWages: usd(0),
+			socialSecurityTax: usd(0),
+			medicareWages: usd(0),
+			medicareTax: usd(0),
+			additionalMedicareSubject: usd(0),
+			additionalMedicareTax: usd(0),
+			totalFicaTax: usd(0)
+		}
+	};
+	const w2 = Math.max(0, income.w2Wages ?? 0);
+	const ssWages = Math.min(w2, params.payroll.socialSecurityWageBase);
+	const ssTaxCents = Math.round(ssWages * params.payroll.ficaSocialSecurityRate * 100);
+	const medTaxCents = Math.round(w2 * params.payroll.ficaMedicareRate * 100);
+	const combinedEarned = w2 + calculateNetSelfEmploymentEarnings(income.selfEmploymentNetEarnings, params.payroll.seNetEarningsFactor);
+	const threshold = params.payroll.additionalMedicareThresholds[filingStatus];
+	const addMedSubject = Math.max(0, combinedEarned - threshold);
+	const addMedTaxCents = Math.round(addMedSubject * params.payroll.additionalMedicareRate * 100);
+	const totalCents = ssTaxCents + medTaxCents + addMedTaxCents;
+	return {
+		totalFicaCents: totalCents,
+		breakdown: {
+			enabled: true,
+			socialSecurityWages: usd(fromMinorUnits(toMinorUnits(ssWages, params.currency), params.currency)),
+			socialSecurityTax: usd(fromMinorUnits(ssTaxCents, params.currency, "payroll.fica.socialSecurity")),
+			medicareWages: usd(fromMinorUnits(toMinorUnits(w2, params.currency), params.currency)),
+			medicareTax: usd(fromMinorUnits(medTaxCents, params.currency, "payroll.fica.medicare")),
+			additionalMedicareSubject: usd(fromMinorUnits(toMinorUnits(addMedSubject, params.currency), params.currency)),
+			additionalMedicareTax: usd(fromMinorUnits(addMedTaxCents, params.currency, "payroll.fica.additionalMedicare")),
+			totalFicaTax: usd(fromMinorUnits(totalCents, params.currency))
+		}
+	};
+}
+// src/us/stages/niit.ts
+function resolveNiiCents(income, override) {
+	if (override !== void 0) return toMinorUnits(override, "USD", "netInvestmentIncome");
+	return toMinorUnits(income.ordinaryInterest ?? 0, "USD", "ordinaryInterest") + toMinorUnits(income.ordinaryDividends ?? 0, "USD", "ordinaryDividends") + toMinorUnits(income.qualifiedDividends ?? 0, "USD", "qualifiedDividends") + toMinorUnits(income.shortTermCapitalGains ?? 0, "USD", "shortTermCapitalGains") + toMinorUnits(income.longTermCapitalGains ?? 0, "USD", "longTermCapitalGains") + toMinorUnits(income.rentalAndOtherOrdinaryIncome ?? 0, "USD", "rentalAndOtherOrdinaryIncome");
+}
+/**
+* Computes 3.8% Net Investment Income Tax (NIIT) on the lesser of NII or excess MAGI.
+*
+* @statute IRC § 1411
+*/
+function calculateUsNiit(input, agiCents, filingStatus, params) {
+	const niiCents = resolveNiiCents(input.income, input.netInvestmentIncome);
+	const magiCents = input.magi !== void 0 ? toMinorUnits(input.magi, "USD", "magi") : agiCents;
+	const thresholdDollars = params.niit.thresholds[filingStatus];
+	const thresholdCents = toMinorUnits(thresholdDollars, "USD");
+	const excessMagiCents = Math.max(0, magiCents - thresholdCents);
+	const subjectCents = Math.min(niiCents, excessMagiCents);
+	const taxCents = applyPercentage(subjectCents, params.niit.rate);
+	return {
+		taxCents,
+		tax: usd(fromMinorUnits(taxCents, "USD")),
+		breakdown: {
+			netInvestmentIncome: usd(fromMinorUnits(niiCents, "USD")),
+			magi: usd(fromMinorUnits(magiCents, "USD")),
+			threshold: usd(fromMinorUnits(thresholdCents, "USD")),
+			excessMagi: usd(fromMinorUnits(excessMagiCents, "USD")),
+			subjectAmount: usd(fromMinorUnits(subjectCents, "USD")),
+			tax: usd(fromMinorUnits(taxCents, "USD"))
+		}
+	};
+}
+// src/us/stages/preferential.ts
+function computePreferentialTier(tier, bracket, tierLower, ordinaryTaxableCents, taxableIncomeCents) {
+	const tierUpper = bracket.upTo ?? Number.POSITIVE_INFINITY;
+	const taxableInTier = Math.max(0, Math.min(taxableIncomeCents, tierUpper) - Math.max(ordinaryTaxableCents, tierLower));
+	const taxCents = taxableInTier > 0 ? applyPercentage(taxableInTier, bracket.rate) : 0;
+	return {
+		slice: {
+			tier,
+			rate: bracket.rate,
+			taxableAmount: usd(fromMinorUnits(taxableInTier, "USD")),
+			tax: usd(fromMinorUnits(taxCents, "USD"))
+		},
+		taxCents,
+		tierUpper
+	};
+}
+/**
+* Evaluates preferential stacking for Long-Term Capital Gains and Qualified Dividends.
+*
+* @statute IRC § 1(h)
+*/
+function calculateUsPreferentialStacking(ordinaryTaxableCents, taxableIncomeCents, brackets) {
+	let totalTaxCents = 0;
+	let tierLower = 0;
+	const slices = [];
+	for (let i = 0; i < brackets.length; i++) {
+		const bracket = brackets[i];
+		if (!bracket) continue;
+		const result = computePreferentialTier(i, bracket, tierLower, ordinaryTaxableCents, taxableIncomeCents);
+		slices.push(result.slice);
+		totalTaxCents += result.taxCents;
+		if (bracket.upTo === null) break;
+		tierLower = result.tierUpper;
+	}
+	return {
+		preferentialTaxCents: totalTaxCents,
+		preferentialTax: usd(fromMinorUnits(totalTaxCents, "USD")),
+		slices
+	};
+}
+// src/us/state/breakdown.ts
+/**
+* Converts integer cents to non-negative USD Money tagged with its diagnostic field.
+*
+* Units: Input is integer minor units; output is major-unit Money.
+* Throws: TaxValidationError if the amount is negative or not a safe integer.
+*/
+function money(cents, currency, field) {
+	return usd(fromMinorUnits(cents, currency, field), field);
+}
+/**
+* Assembles the audit breakdown for one state individual income tax calculation.
+*
+* Purpose: Packages every deduction, exemption, bracket slice, surtax, credit, and withholding
+* figure so callers can audit the state liability.
+* Units: All monetary inputs are integer cents; outputs are major-unit Money.
+* Throws: TaxValidationError if any component amount is negative or not a safe integer
+* (net payable may be negative).
+*
+* @param p State calculation amounts and statutory parameters.
+* @returns Complete state tax audit breakdown.
+* @statute State individual income tax statutes; see per-state parameter tables.
+*/
+function buildUsStateBreakdown(p) {
+	const { currency, deductions: d, credits: c } = p;
+	return {
+		code: p.params.code,
+		name: p.params.name,
+		type: p.params.type,
+		agi: money(p.agiCents, currency, "state.agi"),
+		standardDeduction: money(d.standardDeductionCents, currency, "state.standardDeduction"),
+		personalExemption: money(d.personalExemptionCents, currency, "state.personalExemption"),
+		dependentExemption: money(d.dependentExemptionCents, currency, "state.dependentExemption"),
+		taxableIncome: money(d.taxableIncomeCents, currency, "state.taxableIncome"),
+		slices: p.evaluation.slices,
+		bracketTax: money(p.evaluation.totalTax, currency, "state.bracketTax"),
+		surtax: money(p.surtaxCents, currency, "state.surtax"),
+		taxBeforeCredits: money(p.taxBeforeCreditsCents, currency, "state.taxBeforeCredits"),
+		credits: {
+			personal: money(d.personalCreditCents, currency, "state.credits.personal"),
+			dependent: money(d.dependentCreditCents, currency, "state.credits.dependent"),
+			claimedNonRefundable: money(c.claimedNonRefundableCents, currency, "state.credits.claimedNonRefundable"),
+			allowedNonRefundable: money(c.allowedNonRefundableCents, currency, "state.credits.nonRefundable"),
+			refundable: money(c.refundableCents, currency, "state.credits.refundable")
+		},
+		totalTax: money(c.totalTaxCents, currency, "state.totalTax"),
+		withholding: money(c.withholdingCents, currency, "state.withholding"),
+		netTaxPayable: usd(fromMinorUnits(c.netTaxCents, currency, "state.netTaxPayable", { allowNegative: true }), "state.netTaxPayable", { allowNegative: true }),
+		effectiveRate: p.effectiveRate,
+		marginalRate: p.marginalRate
+	};
+}
+// src/us/state/credits.ts
+/**
+* Applies state personal, dependent, and caller-supplied credits plus state withholding.
+*
+* Math: non-refundable credits are capped at tax before credits; refundable credits and
+* withholding reduce net tax payable (possibly below zero).
+* Units: All amounts are integer cents; caller credit and withholding inputs are major dollars.
+* Throws: TaxValidationError if a credit or withholding amount is negative or not representable
+* as safe integer cents.
+*
+* @param taxBeforeCreditsCents State bracket tax plus surtax in integer cents.
+* @param personalCreditCents State personal non-refundable credit in cents.
+* @param dependentCreditCents State dependent non-refundable credit in cents.
+* @param credits Caller-supplied state non-refundable and refundable credits.
+* @param withholding Caller-supplied state income tax withholding in major dollars.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns Allowed non-refundable credits, total state tax, refundable credits,
+* withholding, and net state tax payable in integer cents.
+* @statute State individual income tax statutes; see per-state parameter tables.
+*/
+function calculateUsStateCredits(taxBeforeCreditsCents, personalCreditCents, dependentCreditCents, credits, withholding, currency) {
+	const claimedNonRefundableCents = personalCreditCents + dependentCreditCents + toMinorUnits(credits?.nonRefundable ?? 0, currency, "state.credits.nonRefundable");
+	const allowedNonRefundableCents = Math.min(taxBeforeCreditsCents, claimedNonRefundableCents);
+	const totalTaxCents = taxBeforeCreditsCents - allowedNonRefundableCents;
+	const refundableCents = toMinorUnits(credits?.refundable ?? 0, currency, "state.credits.refundable");
+	const withholdingCents = toMinorUnits(withholding ?? 0, currency, "state.withholding");
+	return {
+		claimedNonRefundableCents,
+		allowedNonRefundableCents,
+		totalTaxCents,
+		refundableCents,
+		withholdingCents,
+		netTaxCents: totalTaxCents - refundableCents - withholdingCents
+	};
+}
+// src/us/state/phase-out.ts
+function cents(amounts, status, currency) {
+	return toMinorUnits(amounts[status], currency, "state.phaseOutThreshold");
+}
+function linearReduction(amountCents, excessCents, rule, status, currency) {
+	const widthCents = cents(rule.width, status, currency);
+	if (excessCents >= widthCents) return amountCents;
+	return Math.round(amountCents * excessCents / widthCents);
+}
+function steppedReduction(amountCents, excessCents, rule, status, currency) {
+	const steps = Math.ceil(excessCents / cents(rule.step, status, currency));
+	return applyPercentage(amountCents, Math.min(1, steps * rule.ratePerStep));
+}
+function tieredReduction(amountCents, agiCents, rule, status, currency) {
+	const startCents = cents(rule.start, status, currency);
+	const secondCents = cents(rule.second, status, currency);
+	const lower = applyPercentage(Math.min(agiCents, secondCents) - startCents, rule.rate);
+	const upper = applyPercentage(Math.max(0, agiCents - secondCents), rule.secondRate);
+	return Math.min(lower + upper, applyPercentage(amountCents, rule.maxShare));
+}
+/**
+* Applies a statutory income-based phase-out to a deduction or exemption.
+*
+* Math: linear removes amount x (AGI - start) / width; stepped removes ratePerStep of the
+* amount for each step or fraction above start (capped at 100%); tiered removes
+* rate x (AGI up to second - start) + secondRate x (AGI - second), capped at maxShare of the
+* amount. Nothing is removed at or below the start threshold.
+* Units: AGI and amounts are integer cents; thresholds are major dollars converted to cents.
+* Throws: TaxValidationError if a threshold cannot be represented as safe integer cents.
+*
+* @param amountCents Deduction or exemption before the phase-out, in integer cents.
+* @param agiCents Federal adjusted gross income in integer cents.
+* @param status Filing status selecting the thresholds.
+* @param phaseOut Optional statutory phase-out rule.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns The amount still allowed after the phase-out, in integer cents.
+* @statute 36 M.R.S. § 5124-C(2); Minn. Stat. §§ 290.0121 subd. 2, 290.0123 subd. 5.
+*/
+function applyUsStatePhaseOut(amountCents, agiCents, status, phaseOut, currency) {
+	if (!phaseOut) return amountCents;
+	const excessCents = agiCents - cents(phaseOut.start, status, currency);
+	if (excessCents <= 0) return amountCents;
+	if (phaseOut.kind === "tiered") return amountCents - tieredReduction(amountCents, agiCents, phaseOut, status, currency);
+	return amountCents - (phaseOut.kind === "linear" ? linearReduction(amountCents, excessCents, phaseOut, status, currency) : steppedReduction(amountCents, excessCents, phaseOut, status, currency));
+}
+// src/us/state/deductions.ts
+/**
+* Resolves state standard deductions, personal/dependent exemptions, and credits.
+*
+* Math: taxable = max(0, AGI - standard deduction - personal exemption - dependent exemptions),
+* where the standard deduction and dependent exemptions first pass any statutory phase-out.
+* Units: AGI is integer cents; parameter amounts are major dollars converted to integer cents.
+* Throws: TaxValidationError if a parameter amount or the dependent product is not a safe
+* integer number of cents.
+*
+* @param agiCents Federal adjusted gross income in integer cents.
+* @param status Filing status.
+* @param dependents Validated non-negative dependent count.
+* @param params State statutory parameter table.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns Resolved deduction, exemption, credit, and taxable-income amounts.
+* @statute State individual income tax statutes; see per-state parameter tables.
+*/
+function calculateUsStateDeductions(agiCents, status, dependents, params, currency) {
+	const standardDeductionCents = applyUsStatePhaseOut(toMinorUnits(params.standardDeduction[status], currency, "state.standardDeduction"), agiCents, status, params.standardDeductionPhaseOut, currency);
+	const personalExemptionCents = toMinorUnits(params.personalExemption[status], currency, "state.personalExemption");
+	const dependentExemptionCents = applyUsStatePhaseOut(multiplySafeInteger(toMinorUnits(params.dependentExemption, currency, "state.dependentExemption"), dependents, "state.dependentExemption"), agiCents, status, params.dependentExemptionPhaseOut, currency);
+	return {
+		standardDeductionCents,
+		personalExemptionCents,
+		dependentExemptionCents,
+		personalCreditCents: toMinorUnits(params.personalCredit[status], currency, "state.credits.personal"),
+		dependentCreditCents: multiplySafeInteger(toMinorUnits(params.dependentCredit, currency, "state.credits.dependent"), dependents, "state.credits.dependent"),
+		taxableIncomeCents: Math.max(0, agiCents - standardDeductionCents - personalExemptionCents - dependentExemptionCents)
+	};
+}
+// src/us/state/surtax.ts
+/**
+* Computes a state high-income or millionaire surtax above a taxable-income threshold.
+*
+* Math: surtax = rate * max(0, taxable income - threshold); active when taxable income
+* reaches the threshold. A per-status threshold is looked up by filing status.
+* Units: Taxable income and result are integer cents; threshold is major dollars.
+* Throws: TaxValidationError if the threshold or rate cannot be converted or is invalid.
+*
+* @param taxableIncomeCents State taxable income in integer cents.
+* @param surtax Optional statutory surtax threshold and rate.
+* @param status Filing status, used when the threshold varies by status.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns Surtax amount in cents, statutory rate, and whether it applies.
+*/
+function calculateUsStateSurtax(taxableIncomeCents, surtax, status, currency) {
+	if (!surtax) return {
+		taxCents: 0,
+		rate: 0,
+		active: false
+	};
+	const threshold = typeof surtax.threshold === "number" ? surtax.threshold : surtax.threshold[status];
+	const thresholdCents = toMinorUnits(threshold, currency, "state.surtaxThreshold");
+	const baseCents = Math.max(0, taxableIncomeCents - thresholdCents);
+	return {
+		taxCents: applyPercentage(baseCents, surtax.rate),
+		rate: surtax.rate,
+		active: taxableIncomeCents >= thresholdCents
+	};
+}
+// src/us/stages/state.ts
+const EMPTY_RESULT = {
+	totalTaxCents: 0,
+	netTaxCents: 0,
+	breakdown: void 0
+};
+/**
+* Computes 2026 state individual income tax from federal AGI, state deductions,
+* personal/dependent exemptions and credits, state surtaxes, and state withholding.
+*
+* Math: state taxable income = max(0, AGI - state standard deduction - exemptions);
+* tax = progressive bracket tax + surtax - non-refundable credits.
+* Units: AGI and all outputs are integer cents; parameter amounts are major dollars.
+*
+* @param input Complete US tax input including optional state code and state credits.
+* @param agiCents Federal adjusted gross income in integer cents.
+* @param filingStatus Federal and state filing status.
+* @param currency Supported statutory currency threaded for minor-unit conversion.
+* @returns State tax, refundable credits, withholding, net payable, and audit breakdown.
+* @statute State individual income tax statutes; see per-state parameter tables.
+*/
+function calculateUsStateTax(input, agiCents, filingStatus, currency) {
+	if (input.state === void 0) return EMPTY_RESULT;
+	const params = US_2026_STATE_PARAMETERS[input.state];
+	const deductions = calculateUsStateDeductions(agiCents, filingStatus, input.stateDependents ?? 0, params, currency);
+	const evaluation = evaluateBrackets(deductions.taxableIncomeCents, params.brackets[filingStatus], void 0, "state.taxableIncome");
+	const surtax = calculateUsStateSurtax(deductions.taxableIncomeCents, params.surtax, filingStatus, currency);
+	const taxBeforeCreditsCents = evaluation.totalTax + surtax.taxCents;
+	const credits = calculateUsStateCredits(taxBeforeCreditsCents, deductions.personalCreditCents, deductions.dependentCreditCents, input.stateCredits, input.stateWithholding, currency);
+	const effectiveRate = agiCents > 0 ? credits.totalTaxCents / agiCents : 0;
+	const marginalRate = surtax.active ? evaluation.marginalRate + surtax.rate : evaluation.marginalRate;
+	return {
+		totalTaxCents: credits.totalTaxCents,
+		netTaxCents: credits.netTaxCents,
+		breakdown: buildUsStateBreakdown({
+			params,
+			agiCents,
+			deductions,
+			evaluation,
+			surtaxCents: surtax.taxCents,
+			taxBeforeCreditsCents,
+			credits,
+			effectiveRate,
+			marginalRate,
+			currency
+		})
+	};
+}
+/** Read-only runtime registry of every supported US state code. */
+const US_STATE_CODES = [
+	"AL",
+	"AK",
+	"AZ",
+	"AR",
+	"CA",
+	"CO",
+	"CT",
+	"DE",
+	"DC",
+	"FL",
+	"GA",
+	"HI",
+	"ID",
+	"IL",
+	"IN",
+	"IA",
+	"KS",
+	"KY",
+	"LA",
+	"ME",
+	"MD",
+	"MA",
+	"MI",
+	"MN",
+	"MS",
+	"MO",
+	"MT",
+	"NE",
+	"NV",
+	"NH",
+	"NJ",
+	"NM",
+	"NY",
+	"NC",
+	"ND",
+	"OH",
+	"OK",
+	"OR",
+	"PA",
+	"RI",
+	"SC",
+	"SD",
+	"TN",
+	"TX",
+	"UT",
+	"VT",
+	"VA",
+	"WA",
+	"WV",
+	"WI",
+	"WY"
+];
+// src/us/validate.ts
+const VALID_STATUSES = [
+	"single",
+	"married_filing_jointly",
+	"married_filing_separately",
+	"head_of_household"
+];
+function checkFiniteNumber(field, val) {
+	if (val === void 0) return;
+	if (typeof val !== "number" || !Number.isFinite(val)) throw new TaxValidationError(field, val, "Must be a finite number");
+}
+function checkNonNegative(field, val) {
+	if (val === void 0) return;
+	if (typeof val !== "number" || !Number.isFinite(val) || val < 0) throw new TaxValidationError(field, val, "Must be a non-negative finite number");
+}
+function checkNonNegativeInt(field, val) {
+	if (val === void 0) return;
+	if (typeof val !== "number" || !Number.isSafeInteger(val) || val < 0) throw new TaxValidationError(field, val, "Must be a non-negative integer");
+}
+function validateNoOrphanStateInputs(input) {
+	const orphan = [
+		["stateDependents", input.stateDependents],
+		["stateWithholding", input.stateWithholding],
+		["stateCredits", input.stateCredits]
+	].find(([, value]) => value !== void 0);
+	if (orphan) throw new TaxValidationError(String(orphan[0]), orphan[1], "Requires a `state` code");
+}
+function validateStateCreditsInput(credits) {
+	if (!credits) return;
+	checkNonNegative("stateCredits.nonRefundable", credits.nonRefundable);
+	checkNonNegative("stateCredits.refundable", credits.refundable);
+}
+function validateCreditsInput(credits) {
+	if (!credits) return;
+	checkNonNegativeInt("qualifyingChildrenForChildTaxCredit", credits.qualifyingChildrenForChildTaxCredit);
+	checkNonNegativeInt("otherDependents", credits.otherDependents);
+	checkNonNegativeInt("eitcQualifyingChildren", credits.eitcQualifyingChildren);
+	checkNonNegative("eitcInvestmentIncome", credits.eitcInvestmentIncome);
+	checkNonNegativeInt("qualifyingIndividualsForCare", credits.qualifyingIndividualsForCare);
+	checkNonNegative("childAndDependentCareExpenses", credits.childAndDependentCareExpenses);
+	checkNonNegative("foreignTaxCredit", credits.foreignTaxCredit);
+	checkNonNegative("customNonRefundableCredits", credits.customNonRefundableCredits);
+	checkNonNegative("customRefundableCredits", credits.customRefundableCredits);
+	for (const student of credits.educationStudents ?? []) {
+		if (!student) throw new TaxValidationError("educationStudents", student, "Invalid student entry");
+		checkNonNegative("educationStudent.qualifiedExpenses", student.qualifiedExpenses);
+	}
+}
+/**
+* Validates statutory US tax input parameters against bounds and types.
+*/
+function validateUsInput(input) {
+	if (input.taxYear !== void 0 && input.taxYear !== 2026) throw new TaxValidationError("taxYear", input.taxYear, "Unsupported tax year; currently only 2026 is supported");
+	if (!VALID_STATUSES.includes(input.filingStatus)) throw new TaxValidationError("filingStatus", input.filingStatus, "Invalid filing status");
+	checkNonNegative("withholding", input.withholding);
+	checkNonNegative("amtPreferences", input.amtPreferences);
+	checkNonNegative("income.w2Wages", input.income.w2Wages);
+	checkFiniteNumber("income.selfEmploymentNetEarnings", input.income.selfEmploymentNetEarnings);
+	if (input.state !== void 0 && !US_STATE_CODES.includes(input.state)) throw new TaxValidationError("state", input.state, "Unsupported US state code");
+	if (input.state === void 0) validateNoOrphanStateInputs(input);
+	checkNonNegativeInt("stateDependents", input.stateDependents);
+	checkNonNegative("stateWithholding", input.stateWithholding);
+	validateStateCreditsInput(input.stateCredits);
+	validateCreditsInput(input.credits);
+}
+// src/us/calculate.ts
+/**
+* Executes the 2026 US federal, payroll, and optional state income tax pipeline.
+*
+* Purpose: Chains federal AGI, deductions, brackets, AMT, NIIT, payroll, credits, and the
+* state stage into one result.
+* Units: Inputs and outputs are major USD; internal arithmetic uses integer cents.
+* Throws: TaxValidationError if any input is invalid.
+*
+* @statute IRC § 1 et seq.; state individual income tax statutes.
+*/
+function executeUsTaxCalculation(input) {
+	validateUsInput(input);
+	const seRes = calculateUsScheduleSe(input.income, US_2026_PARAMETERS);
+	const seTax = input.adjustments?.deductibleSelfEmploymentTax ?? seRes.deductiblePortionDollars;
+	const adjustments = {
+		...input.adjustments,
+		deductibleSelfEmploymentTax: seTax
+	};
+	const agiRes = calculateUsAgi(input.income, adjustments, input.filingStatus, US_2026_PARAMETERS);
+	const stateRes = calculateUsStateTax(input, agiRes.agiCents, input.filingStatus, US_2026_PARAMETERS.currency);
+	const dedRes = calculateUsDeductions(input, agiRes.agiCents, agiRes.preferentialGrossCents, input.filingStatus, US_2026_PARAMETERS);
+	const ordRes = evaluateBrackets(dedRes.ordinaryTaxableCents, US_2026_PARAMETERS.ordinaryBrackets[input.filingStatus], Math.max(0, agiRes.grossIncomeCents), "ordinaryTaxableIncome");
+	const prefRes = calculateUsPreferentialStacking(dedRes.ordinaryTaxableCents, dedRes.taxableIncomeCents, US_2026_PARAMETERS.preferentialBrackets[input.filingStatus]);
+	const regularTaxCents = ordRes.totalTax + prefRes.preferentialTaxCents;
+	const saltCents = resolveAmtSaltCents(dedRes, US_2026_PARAMETERS.currency);
+	const amtRes = calculateUsAmt(dedRes.taxableIncomeCents, saltCents, input.amtPreferences, regularTaxCents, input.filingStatus, US_2026_PARAMETERS);
+	const niitRes = calculateUsNiit(input, agiRes.agiCents, input.filingStatus, US_2026_PARAMETERS);
+	const ficaRes = calculateUsFica(input.income, input.filingStatus, input.includeFica ?? true, US_2026_PARAMETERS);
+	const creditsRes = calculateUsCredits(input, agiRes.agiCents, regularTaxCents + amtRes.amtTaxCents, US_2026_PARAMETERS);
+	const federalTaxCents = regularTaxCents + amtRes.amtTaxCents - creditsRes.allowedNonRefundableCents + niitRes.taxCents + ficaRes.totalFicaCents + seRes.totalSeTaxCents;
+	const totalTaxCents = federalTaxCents + stateRes.totalTaxCents;
+	const withhCents = toMinorUnits(input.withholding ?? 0, US_2026_PARAMETERS.currency, "withholding");
+	const netTaxCents = federalTaxCents - creditsRes.totalRefundableCents - withhCents + stateRes.netTaxCents;
+	return buildUsTaxResult({
+		agiRes,
+		dedRes,
+		ordTaxCents: ordRes.totalTax,
+		ordMarginalRate: ordRes.marginalRate,
+		ordSlices: ordRes.slices,
+		prefRes,
+		regularTaxCents,
+		amtRes,
+		niitRes,
+		ficaRes,
+		seRes,
+		creditsRes,
+		stateRes,
+		totalTaxCents,
+		withhCents,
+		netTaxCents
+	});
+}
+// src/us/system.ts
+/**
+* US Federal and state Individual Income Tax System implementation for 2026.
+*
+* @statute IRC § 1 et seq.; state individual income tax statutes for Tax Year 2026.
+*/
+const us = {
+	jurisdiction: "US",
+	taxYear: 2026,
+	currency: "USD",
+	calculate(input) {
+		return executeUsTaxCalculation(input);
+	}
+};
+/**
+* Calculates 2026 US federal and optional state Individual Income Tax for the specified input.
+*
+* @statute IRC § 1 et seq.; state individual income tax statutes for Tax Year 2026.
+*/
+function calculateUsTax(input) {
+	return us.calculate(input);
+}
+export { US_2026_ABOVE_THE_LINE_CAPS, US_2026_ADDITIONAL_STANDARD_DEDUCTION, US_2026_AMT, US_2026_CREDITS, US_2026_ITEMIZED, US_2026_NIIT, US_2026_ORDINARY_BRACKETS, US_2026_PARAMETERS, US_2026_PAYROLL, US_2026_PREFERENTIAL_BRACKETS, US_2026_STANDARD_DEDUCTION, US_2026_STATE_PARAMETERS, US_STATE_CODES, UsAdjustmentField, UsAmtField, UsCreditField, UsDeductionField, UsPayrollField as UsFicaField, UsPayrollField, UsIncomeField, UsStateField, UsTaxField, calculateUsTax, us };
+
+//# sourceMappingURL=index.mjs.map