statetakehome-mcp 0.1.0

package/dist/lib/tax-calc.js

@@ -0,0 +1,510 @@
+import { FEDERAL, STATES, } from "./state-data.js";
+import { CA_FEDERAL, PROVINCES, } from "./ca-data.js";
+function applyBrackets(taxable, brackets) {
+    let tax = 0;
+    for (const b of brackets) {
+        if (taxable <= b.min)
+            break;
+        const top = b.max ?? Infinity;
+        const slice = Math.max(0, Math.min(taxable, top) - b.min);
+        tax += slice * b.rate;
+    }
+    return tax;
+}
+function findMarginalRate(taxable, brackets) {
+    for (const b of brackets) {
+        const top = b.max ?? Infinity;
+        if (taxable >= b.min && taxable < top)
+            return b.rate;
+    }
+    return brackets[brackets.length - 1]?.rate ?? 0;
+}
+function bracketsFor(state, status) {
+    if (state.tax_type !== "progressive" || !state.brackets)
+        return undefined;
+    if (status === "married_filing_jointly") {
+        if (state.brackets.married_filing_jointly) {
+            return state.brackets.married_filing_jointly;
+        }
+        // MFJ brackets missing: most progressive states (incl. CA) double the
+        // single thresholds for joint filers. Falling back to raw single brackets
+        // would roughly double the joint tax bill.
+        return state.brackets.single?.map((b) => ({
+            rate: b.rate,
+            min: b.min * 2,
+            max: b.max === null ? null : b.max * 2,
+        }));
+    }
+    // single / MFS / HoH: single schedule is the standard state treatment
+    return state.brackets.single;
+}
+function stateStdDeduction(state, status) {
+    if (!state.standard_deduction)
+        return 0;
+    const explicit = state.standard_deduction[status];
+    if (explicit !== undefined)
+        return explicit;
+    const single = state.standard_deduction.single ?? 0;
+    // Same doubling convention as brackets when the MFJ amount is missing.
+    return status === "married_filing_jointly" ? single * 2 : single;
+}
+export function calculate(input) {
+    const gross = Math.max(0, Math.round(input.grossIncome || 0));
+    const status = input.filingStatus;
+    const stateAbbr = input.state.toUpperCase();
+    const state = STATES[stateAbbr];
+    const retirementContribution = Math.min(gross * Math.min(Math.max(input.pretax401kPct ?? 0, 0), 100) / 100, 23500 // 2026 employee deferral limit baseline
+    );
+    const pretaxHealth = Math.max(0, input.pretaxHealthAnnual ?? 0);
+    // FICA on full wages (FICA does NOT exempt 401k; DOES exempt some pretax health/HSA)
+    const ficaWages = Math.max(0, gross - pretaxHealth);
+    const socialSecurity = Math.min(ficaWages, FEDERAL.fica.social_security_wage_base) *
+        FEDERAL.fica.social_security_rate;
+    const medicare = ficaWages * FEDERAL.fica.medicare_rate;
+    const addlMedicareThreshold = status === "married_filing_jointly"
+        ? FEDERAL.fica.additional_medicare_threshold_mfj
+        : FEDERAL.fica.additional_medicare_threshold_single;
+    const additionalMedicare = Math.max(0, ficaWages - addlMedicareThreshold) *
+        FEDERAL.fica.additional_medicare_rate;
+    // Federal taxable: gross - 401k - pretax health - federal std deduction
+    const fedStd = FEDERAL.standard_deduction[status] ?? FEDERAL.standard_deduction.single;
+    const federalTaxableIncome = Math.max(0, gross - retirementContribution - pretaxHealth - fedStd);
+    const fedBrackets = FEDERAL.tax_brackets[status] ?? FEDERAL.tax_brackets.single ?? [];
+    const federalTax = applyBrackets(federalTaxableIncome, fedBrackets);
+    // State tax
+    let stateTax = 0;
+    let stateTaxableIncome = 0;
+    const stateExtras = [];
+    if (state) {
+        if (state.tax_type === "none") {
+            stateTax = 0;
+            stateTaxableIncome = 0;
+        }
+        else if (state.tax_type === "flat") {
+            stateTaxableIncome = Math.max(0, gross - retirementContribution - pretaxHealth - stateStdDeduction(state, status));
+            stateTax = stateTaxableIncome * (state.rate ?? 0);
+        }
+        else {
+            // progressive
+            stateTaxableIncome = Math.max(0, gross - retirementContribution - pretaxHealth - stateStdDeduction(state, status));
+            const sb = bracketsFor(state, status);
+            if (sb)
+                stateTax = applyBrackets(stateTaxableIncome, sb);
+        }
+        // State-specific extras
+        if (state.extra) {
+            if (state.extra.sdi_rate) {
+                // sdi_wage_base null = no cap (CA depuis 2024, SB 951). Sans ce ?? Infinity,
+                // la condition tombait à false et la SDI n'était jamais prélevée.
+                const sdiCap = state.extra.sdi_wage_base ?? Infinity;
+                const sdi = Math.min(gross, sdiCap) * state.extra.sdi_rate;
+                stateExtras.push({ name: `${state.abbr} SDI`, amount: sdi });
+            }
+            if (state.extra.mental_health_tax_rate &&
+                state.extra.mental_health_threshold &&
+                gross > state.extra.mental_health_threshold) {
+                const mht = (gross - state.extra.mental_health_threshold) *
+                    state.extra.mental_health_tax_rate;
+                stateExtras.push({ name: "CA Mental Health Tax", amount: mht });
+            }
+            if (state.extra.transit_tax) {
+                stateExtras.push({
+                    name: "OR Transit Tax",
+                    amount: gross * state.extra.transit_tax,
+                });
+            }
+        }
+    }
+    const stateExtraTotal = stateExtras.reduce((s, x) => s + x.amount, 0);
+    const totalTax = federalTax + stateTax + socialSecurity + medicare + additionalMedicare + stateExtraTotal;
+    const takeHome = gross - retirementContribution - pretaxHealth - totalTax;
+    const marginalFed = findMarginalRate(federalTaxableIncome, fedBrackets);
+    const marginalState = (() => {
+        if (!state || state.tax_type === "none")
+            return 0;
+        if (state.tax_type === "flat")
+            return state.rate ?? 0;
+        const sb = bracketsFor(state, status);
+        return sb ? findMarginalRate(stateTaxableIncome, sb) : 0;
+    })();
+    const marginalRate = marginalFed +
+        marginalState +
+        FEDERAL.fica.social_security_rate +
+        FEDERAL.fica.medicare_rate;
+    const perPaycheck = {
+        weekly: takeHome / 52,
+        biweekly: takeHome / 26,
+        semimonthly: takeHome / 24,
+        monthly: takeHome / 12,
+    };
+    const row = (label, annual, kind) => ({
+        label,
+        annual,
+        monthly: annual / 12,
+        perPaycheck: annual / 26,
+        pctOfGross: gross > 0 ? annual / gross : 0,
+        kind,
+    });
+    const breakdown = [
+        row("Gross Income", gross, "income"),
+        ...(retirementContribution > 0
+            ? [row("401(k) (pre-tax)", -retirementContribution, "deduction")]
+            : []),
+        ...(pretaxHealth > 0
+            ? [row("Pre-tax Health Insurance", -pretaxHealth, "deduction")]
+            : []),
+        row("Federal Income Tax", -federalTax, "tax"),
+        ...(state && state.tax_type !== "none"
+            ? [row(`${state.name} Income Tax`, -stateTax, "tax")]
+            : []),
+        row("Social Security (6.2%)", -socialSecurity, "tax"),
+        row("Medicare (1.45%)", -medicare, "tax"),
+        ...(additionalMedicare > 0
+            ? [row("Add'l Medicare (0.9%)", -additionalMedicare, "tax")]
+            : []),
+        ...stateExtras.map((x) => row(x.name, -x.amount, "tax")),
+        row("Take-Home Pay", takeHome, "total"),
+    ];
+    return {
+        gross,
+        retirementContribution,
+        pretaxHealth,
+        federalTaxableIncome,
+        federalTax,
+        stateTaxableIncome,
+        stateTax,
+        socialSecurity,
+        medicare,
+        additionalMedicare,
+        stateExtras,
+        totalTax,
+        takeHome,
+        effectiveRate: gross > 0 ? totalTax / gross : 0,
+        marginalRate,
+        perPaycheck,
+        breakdown,
+    };
+}
+// Useful sanity helper for tests
+export function quickTakeHome(gross, stateAbbr) {
+    return calculate({
+        grossIncome: gross,
+        state: stateAbbr,
+        filingStatus: "single",
+    }).takeHome;
+}
+export function selfEmploymentTax(input) {
+    const netProfit = Math.max(0, Math.round(input.netProfit || 0));
+    const otherIncome = Math.max(0, input.otherIncome ?? 0);
+    const status = input.filingStatus;
+    const ssRate = FEDERAL.fica.social_security_rate * 2; // 12.4%
+    const medRate = FEDERAL.fica.medicare_rate * 2; // 2.9%
+    const wageBase = FEDERAL.fica.social_security_wage_base;
+    const seBase = netProfit * 0.9235;
+    // SS portion: 12.4% on the SE base, but the wage base is shared with any W-2
+    // wages already taxed for Social Security (otherIncome treated as such here).
+    const ssRoom = Math.max(0, wageBase - otherIncome);
+    const socialSecurityPortion = Math.min(seBase, ssRoom) * ssRate;
+    const medicarePortion = seBase * medRate;
+    const seTax = socialSecurityPortion + medicarePortion;
+    const seTaxDeduction = seTax * 0.5;
+    // Additional Medicare 0.9% above the threshold (on combined Medicare wages).
+    const addlThreshold = status === "married_filing_jointly"
+        ? FEDERAL.fica.additional_medicare_threshold_mfj
+        : FEDERAL.fica.additional_medicare_threshold_single;
+    const additionalMedicare = Math.max(0, seBase + otherIncome - addlThreshold) * FEDERAL.fica.additional_medicare_rate;
+    // Federal income tax on (net profit + other income − half SE tax − std deduction).
+    const fedStd = FEDERAL.standard_deduction[status] ?? FEDERAL.standard_deduction.single;
+    const federalTaxableIncome = Math.max(0, netProfit + otherIncome - seTaxDeduction - fedStd);
+    const fedBrackets = FEDERAL.tax_brackets[status] ?? FEDERAL.tax_brackets.single ?? [];
+    const federalIncomeTax = applyBrackets(federalTaxableIncome, fedBrackets);
+    // Optional state income tax (approx: starts from net profit + other income − half SE tax).
+    let stateTax = 0;
+    const stateAbbr = (input.state ?? "").toUpperCase();
+    const state = STATES[stateAbbr];
+    if (state && state.tax_type !== "none") {
+        const stateTaxable = Math.max(0, netProfit + otherIncome - seTaxDeduction - stateStdDeduction(state, status));
+        if (state.tax_type === "flat") {
+            stateTax = stateTaxable * (state.rate ?? 0);
+        }
+        else {
+            const sb = bracketsFor(state, status);
+            if (sb)
+                stateTax = applyBrackets(stateTaxable, sb);
+        }
+    }
+    const totalTax = seTax + additionalMedicare + federalIncomeTax + stateTax;
+    const netAfterTax = netProfit + otherIncome - totalTax;
+    const marginalFed = findMarginalRate(federalTaxableIncome, fedBrackets);
+    const marginalState = (() => {
+        if (!state || state.tax_type === "none")
+            return 0;
+        if (state.tax_type === "flat")
+            return state.rate ?? 0;
+        const sb = bracketsFor(state, status);
+        return sb ? findMarginalRate(federalTaxableIncome, sb) : 0;
+    })();
+    // SE marginal on the next dollar: 15.3% under the wage base, else 2.9%, on 92.35%.
+    const seMarginal = (seBase < ssRoom ? ssRate + medRate : medRate) * 0.9235;
+    const marginalRate = marginalFed + marginalState + seMarginal;
+    return {
+        netProfit,
+        seBase,
+        socialSecurityPortion,
+        medicarePortion,
+        additionalMedicare,
+        seTax,
+        seTaxDeduction,
+        federalTaxableIncome,
+        federalIncomeTax,
+        stateTax,
+        totalTax,
+        netAfterTax,
+        setAsidePct: netProfit > 0 ? totalTax / netProfit : 0,
+        effectiveRate: netProfit + otherIncome > 0 ? totalTax / (netProfit + otherIncome) : 0,
+        marginalRate,
+        quarterlyEstimate: totalTax / 4,
+    };
+}
+// ============================================================================
+// CAPITAL GAINS ENGINE (2026)
+// Long-term: stacked 0% / 15% / 20% by taxable income (Rev. Proc. 2025-32,
+// verified vs Tax Foundation + Schwab, 2026-06-20). Short-term: ordinary rates.
+// Plus the 3.8% Net Investment Income Tax (NIIT) above the MAGI threshold
+// ($200k single / $250k MFJ, fixed since 2013). State capital gains usually
+// taxed as ordinary income (some states differ — noted on-page).
+// ============================================================================
+// Upper bound of the 0% and 15% long-term bands, by taxable income (2026).
+const LTCG_2026 = {
+    single: { zeroTop: 49450, fifteenTop: 545500 },
+    married_filing_jointly: { zeroTop: 98900, fifteenTop: 613700 },
+    head_of_household: { zeroTop: 66200, fifteenTop: 579600 },
+    married_filing_separately: { zeroTop: 49450, fifteenTop: 306850 },
+};
+const NIIT_RATE = 0.038;
+const NIIT_THRESHOLD = {
+    single: 200000,
+    married_filing_jointly: 250000,
+    head_of_household: 200000,
+    married_filing_separately: 125000,
+};
+export function capitalGains(input) {
+    const gain = Math.max(0, Math.round(input.gain || 0));
+    const exclusion = Math.min(gain, Math.max(0, input.exclusion ?? 0));
+    const taxableGain = Math.max(0, gain - exclusion);
+    const inc = Math.max(0, input.ordinaryTaxableIncome || 0);
+    const status = input.filingStatus;
+    const fedBrackets = FEDERAL.tax_brackets[status] ?? FEDERAL.tax_brackets.single ?? [];
+    let federalTax = 0;
+    let ltcgRate = 0;
+    if (input.term === "short") {
+        // Short-term = ordinary rates, stacked on top of other income.
+        federalTax =
+            applyBrackets(inc + taxableGain, fedBrackets) - applyBrackets(inc, fedBrackets);
+        ltcgRate = findMarginalRate(inc + taxableGain, fedBrackets);
+    }
+    else {
+        const b = LTCG_2026[status] ?? LTCG_2026.single;
+        const top = inc + taxableGain;
+        const at0 = Math.max(0, Math.min(top, b.zeroTop) - inc);
+        const at15 = Math.max(0, Math.min(top, b.fifteenTop) - Math.max(inc, b.zeroTop));
+        const at20 = Math.max(0, top - Math.max(inc, b.fifteenTop));
+        federalTax = at15 * 0.15 + at20 * 0.2;
+        ltcgRate = at20 > 0 ? 0.2 : at15 > 0 ? 0.15 : 0;
+    }
+    // NIIT: 3.8% on the lesser of the taxable gain or (MAGI − threshold).
+    const magi = inc + taxableGain;
+    const niitThreshold = NIIT_THRESHOLD[status] ?? NIIT_THRESHOLD.single;
+    const niit = NIIT_RATE * Math.max(0, Math.min(taxableGain, magi - niitThreshold));
+    // State: treated as ordinary income (the common case), stacked.
+    let stateTax = 0;
+    const stateAbbr = (input.state ?? "").toUpperCase();
+    const state = STATES[stateAbbr];
+    if (state && state.tax_type !== "none" && taxableGain > 0) {
+        if (state.tax_type === "flat") {
+            stateTax = taxableGain * (state.rate ?? 0);
+        }
+        else {
+            const sb = bracketsFor(state, status);
+            if (sb)
+                stateTax = applyBrackets(inc + taxableGain, sb) - applyBrackets(inc, sb);
+        }
+    }
+    const totalTax = federalTax + niit + stateTax;
+    return {
+        gain,
+        exclusion,
+        taxableGain,
+        term: input.term,
+        federalTax,
+        niit,
+        stateTax,
+        totalTax,
+        netProceeds: taxableGain - totalTax,
+        effectiveRate: taxableGain > 0 ? totalTax / taxableGain : 0,
+        ltcgRate,
+    };
+}
+// Basic Personal Amount with optional high-income phase-out (federal + Yukon).
+function caBpaAmount(income, p) {
+    if (income <= p.phaseout_start)
+        return p.max;
+    if (income >= p.phaseout_end)
+        return p.base;
+    return p.max - ((p.max - p.base) * (income - p.phaseout_start)) / (p.phaseout_end - p.phaseout_start);
+}
+// CPP/QPP contribution: base on (pensionable earnings − exemption), capped,
+// plus the second additional contribution (CPP2/QPP2) on the upper band.
+function caPensionContribution(gross, plan, plan2) {
+    const pensionable = Math.min(gross, plan.max_pensionable_earnings);
+    const contributory = Math.max(0, pensionable - plan.basic_exemption);
+    const base = Math.min(contributory * plan.rate, plan.max_contribution);
+    const secondBand = Math.max(0, Math.min(gross, plan2.upper) - plan2.lower);
+    const second = Math.min(secondBand * plan2.rate, plan2.max_contribution);
+    return { base, second };
+}
+// Ontario Health Premium (2026 schedule — unchanged for years), by taxable income.
+function ontarioHealthPremium(ti) {
+    if (ti <= 20000)
+        return 0;
+    if (ti <= 36000)
+        return Math.min((ti - 20000) * 0.06, 300);
+    if (ti <= 48000)
+        return Math.min(300 + (ti - 36000) * 0.06, 450);
+    if (ti <= 72000)
+        return Math.min(450 + (ti - 48000) * 0.25, 600);
+    if (ti <= 200000)
+        return Math.min(600 + (ti - 72000) * 0.25, 750);
+    return Math.min(750 + (ti - 200000) * 0.25, 900);
+}
+export function calculateCanada(input) {
+    const gross = Math.max(0, Math.round(input.grossIncome || 0));
+    const provAbbr = input.province.toUpperCase();
+    const prov = PROVINCES[provAbbr];
+    const F = CA_FEDERAL;
+    const rrsp = Math.max(0, input.rrspContribution ?? 0);
+    const pretaxHealth = Math.max(0, input.pretaxHealthAnnual ?? 0);
+    // Taxable income (Canada): gross − RRSP − other pre-tax. No standard deduction;
+    // the Basic Personal Amount is applied as a non-refundable tax credit.
+    const taxableIncome = Math.max(0, gross - rrsp - pretaxHealth);
+    // --- Federal income tax (BPA is a credit at the lowest rate) ---
+    const fedBpa = caBpaAmount(taxableIncome, F.basic_personal_amount);
+    let federalTax = Math.max(0, applyBrackets(taxableIncome, F.brackets) - fedBpa * F.bpa_credit_rate);
+    // Quebec abatement: 16.5% of net federal tax for QC residents.
+    if (prov && prov.abatement) {
+        federalTax = federalTax * (1 - F.quebec_abatement_rate);
+    }
+    // --- Provincial income tax ---
+    let provincialTax = 0;
+    let basicProvTax = 0;
+    const provExtras = [];
+    if (prov) {
+        const provBpa = prov.bpa_phaseout
+            ? caBpaAmount(taxableIncome, prov.bpa_phaseout)
+            : prov.basic_personal_amount;
+        basicProvTax = Math.max(0, applyBrackets(taxableIncome, prov.brackets) - provBpa * prov.bpa_credit_rate);
+        let provTax = basicProvTax;
+        // Provincial surtax (Ontario) — on basic provincial tax above thresholds.
+        if (prov.surtax) {
+            for (const s of prov.surtax)
+                provTax += Math.max(0, basicProvTax - s.threshold) * s.rate;
+        }
+        provincialTax = provTax;
+        // Ontario Health Premium (separate levy by taxable income).
+        if (prov.health_premium) {
+            const ohp = ontarioHealthPremium(taxableIncome);
+            if (ohp > 0)
+                provExtras.push({ name: "Ontario Health Premium", amount: ohp });
+        }
+    }
+    // --- CPP/QPP + EI/QPIP (on gross employment income) ---
+    const usesQpp = !!prov && prov.pension === "QPP";
+    const pensionPlan = usesQpp ? F.qpp : F.cpp;
+    const pensionPlan2 = usesQpp ? F.qpp2 : F.cpp2;
+    const { base: pension1, second: pension2 } = caPensionContribution(gross, pensionPlan, pensionPlan2);
+    const pensionName = usesQpp ? "QPP (RRQ)" : "CPP";
+    const pension2Name = usesQpp ? "QPP2 (RRQ)" : "CPP2";
+    const eiPlan = prov && prov.ei === "quebec" ? F.ei_quebec : F.ei_federal;
+    const ei = Math.min(gross, eiPlan.max_insurable_earnings) * eiPlan.rate;
+    const eiName = prov && prov.ei === "quebec" ? "EI (Quebec rate)" : "Employment Insurance";
+    let qpip = 0;
+    if (prov && prov.qpip) {
+        qpip = Math.min(gross, F.qpip.max_insurable_earnings) * F.qpip.rate;
+    }
+    // Map Canadian payroll contributions into stateExtras (so the widget renders them).
+    const payroll = [{ name: pensionName, amount: pension1 }];
+    if (pension2 > 0)
+        payroll.push({ name: pension2Name, amount: pension2 });
+    payroll.push({ name: eiName, amount: ei });
+    if (qpip > 0)
+        payroll.push({ name: "QPIP (RQAP)", amount: qpip });
+    const stateExtras = [...payroll, ...provExtras];
+    const stateExtraTotal = stateExtras.reduce((s, x) => s + x.amount, 0);
+    const totalTax = federalTax + provincialTax + stateExtraTotal;
+    const takeHome = gross - rrsp - pretaxHealth - totalTax;
+    // --- Marginal rate (income tax only, matching published combined marginal tables) ---
+    let marginalFed = findMarginalRate(taxableIncome, F.brackets);
+    if (prov && prov.abatement)
+        marginalFed *= 1 - F.quebec_abatement_rate;
+    let marginalProv = 0;
+    if (prov) {
+        marginalProv = findMarginalRate(taxableIncome, prov.brackets);
+        if (prov.surtax) {
+            let factor = 1;
+            for (const s of prov.surtax)
+                if (basicProvTax > s.threshold)
+                    factor += s.rate;
+            marginalProv *= factor;
+        }
+    }
+    const marginalRate = marginalFed + marginalProv;
+    const perPaycheck = {
+        weekly: takeHome / 52,
+        biweekly: takeHome / 26,
+        semimonthly: takeHome / 24,
+        monthly: takeHome / 12,
+    };
+    const row = (label, annual, kind) => ({
+        label,
+        annual,
+        monthly: annual / 12,
+        perPaycheck: annual / 26,
+        pctOfGross: gross > 0 ? annual / gross : 0,
+        kind,
+    });
+    const breakdown = [
+        row("Gross Income", gross, "income"),
+        ...(rrsp > 0 ? [row("RRSP/Pension (pre-tax)", -rrsp, "deduction")] : []),
+        ...(pretaxHealth > 0 ? [row("Pre-tax deductions", -pretaxHealth, "deduction")] : []),
+        row("Federal Income Tax", -federalTax, "tax"),
+        ...(prov ? [row(`${prov.name} Provincial Tax`, -provincialTax, "tax")] : []),
+        row(pensionName, -pension1, "tax"),
+        ...(pension2 > 0 ? [row(pension2Name, -pension2, "tax")] : []),
+        row(eiName, -ei, "tax"),
+        ...(qpip > 0 ? [row("QPIP (RQAP)", -qpip, "tax")] : []),
+        ...provExtras.map((x) => row(x.name, -x.amount, "tax")),
+        row("Take-Home Pay", takeHome, "total"),
+    ];
+    return {
+        gross,
+        retirementContribution: rrsp,
+        pretaxHealth,
+        federalTaxableIncome: taxableIncome,
+        federalTax,
+        stateTaxableIncome: taxableIncome,
+        stateTax: provincialTax,
+        socialSecurity: 0,
+        medicare: 0,
+        additionalMedicare: 0,
+        stateExtras,
+        totalTax,
+        takeHome,
+        effectiveRate: gross > 0 ? totalTax / gross : 0,
+        marginalRate,
+        perPaycheck,
+        breakdown,
+    };
+}
+export function quickTakeHomeCanada(gross, province) {
+    return calculateCanada({ grossIncome: gross, province }).takeHome;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "statetakehome-mcp",
+  "version": "0.1.0",
+  "description": "Take-home pay MCP server for all 50 US states + DC — 2026 federal & state brackets, FICA, and the new OBBBA tips/overtime deductions, straight from statetakehome.com's calculation engine.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "statetakehome-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node --eval \"const fs=require('fs');fs.cpSync('src/data','dist/data',{recursive:true})\"",
+    "test": "node test/smoke.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "take-home-pay",
+    "paycheck",
+    "salary-calculator",
+    "payroll",
+    "state-taxes",
+    "income-tax",
+    "fica",
+    "self-employment-tax",
+    "capital-gains-tax",
+    "obbba",
+    "paycheck-calculator",
+    "tax-calculator"
+  ],
+  "author": "tresor4k",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tresor4k/statetakehome-mcp.git"
+  },
+  "homepage": "https://statetakehome.com",
+  "bugs": {
+    "url": "https://github.com/tresor4k/statetakehome-mcp/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.23"
+  },
+  "devDependencies": {
+    "typescript": "^5.5",
+    "@types/node": "^20.14.0"
+  }
+}