From 94276cddabda0b14510f8cc3187d93a78c8a29e3 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Thu, 24 Jul 2025 18:17:33 -0400
Subject: [PATCH 01/14] Add debugging for OBBBA URL sync issue
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Added console logs to trace when iframe sends URL updates
- This will help diagnose the "one behind" issue where parent URL lags behind iframe selection

The issue might be that the iframe is sending the old URL params before updating its own state.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/pages/AppPage.jsx | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/pages/AppPage.jsx b/src/pages/AppPage.jsx
index b58590b0a..454f7b07f 100644
--- a/src/pages/AppPage.jsx
+++ b/src/pages/AppPage.jsx
@@ -17,11 +17,11 @@ export default function AppPage() {
   const isOBBBAApp = app?.slug === "obbba-household-by-household";
   const [initialUrl, setInitialUrl] = useState(null);
 
-  // Construct iframe URL with parameters (for OBBBA app only on initial load)
+  // Construct initial iframe URL with parameters
   useEffect(() => {
-    if (!app) return;
+    if (!app || initialUrl) return;
 
-    if (isOBBBAApp && !initialUrl) {
+    if (isOBBBAApp) {
       const baseUrl = app.url;
       const separator = baseUrl.includes("?") ? "&" : "?";
       const urlParams = new URLSearchParams(location.search);
@@ -31,11 +31,11 @@ export default function AppPage() {
         : baseUrl;
 
       setInitialUrl(url);
-    } else if (!isOBBBAApp) {
+    } else {
       // For non-OBBBA apps, just use the app URL
       setInitialUrl(app.url);
     }
-  }, [app, location.search, initialUrl, isOBBBAApp]);
+  }, [app, location.search, isOBBBAApp, initialUrl]);
 
   // Listen for messages from OBBBA iframe
   useEffect(() => {
@@ -48,8 +48,15 @@ export default function AppPage() {
 
         // Handle URL update messages from the iframe
         if (event.data?.type === "urlUpdate" && event.data?.params) {
+          console.log("Received urlUpdate from iframe:", event.data.params);
           const newParams = new URLSearchParams(event.data.params);
-          navigate(`${location.pathname}?${newParams.toString()}`, {
+          const newParamsString = newParams.toString();
+          console.log(
+            "Navigating to:",
+            `${location.pathname}?${newParamsString}`,
+          );
+
+          navigate(`${location.pathname}?${newParamsString}`, {
             replace: true,
           });
         }

From aedb61bc20dc5343103e7f131f7d3a7352904a0c Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Thu, 24 Jul 2025 18:25:16 -0400
Subject: [PATCH 02/14] Add tests demonstrating OBBBA 'one behind' URL sync
 issue
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Added comprehensive tests for AppPage iframe functionality
- Created specific test showing the "one behind" problem
- The issue: iframe sends OLD state before updating internally

The tests clearly show that the obbba-scatter app needs to:
1. Update its own state/URL first
2. THEN send the postMessage with the NEW state

Currently it's doing the opposite, causing parent URL to lag behind.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../pages/AppPage.integration.test.js         | 223 +++++++++++++++
 src/__tests__/pages/AppPage.oneBehind.test.js |  89 ++++++
 src/__tests__/pages/AppPage.test.js           | 256 ++++++++++++++++++
 3 files changed, 568 insertions(+)
 create mode 100644 src/__tests__/pages/AppPage.integration.test.js
 create mode 100644 src/__tests__/pages/AppPage.oneBehind.test.js
 create mode 100644 src/__tests__/pages/AppPage.test.js

diff --git a/src/__tests__/pages/AppPage.integration.test.js b/src/__tests__/pages/AppPage.integration.test.js
new file mode 100644
index 000000000..7fb884856
--- /dev/null
+++ b/src/__tests__/pages/AppPage.integration.test.js
@@ -0,0 +1,223 @@
+import { render, act, waitFor } from "@testing-library/react";
+import { BrowserRouter } from "react-router-dom";
+import AppPage from "../../pages/AppPage";
+
+// This integration test simulates the actual "one behind" issue
+// where the iframe might be sending outdated parameters
+
+// Mock the apps data
+jest.mock("../../apps/appTransformers", () => ({
+  apps: [
+    {
+      title: "OBBBA household-by-household analysis",
+      description: "Test description",
+      url: "https://policyengine.github.io/obbba-scatter",
+      slug: "obbba-household-by-household",
+      tags: ["us", "featured", "policy"],
+    },
+  ],
+}));
+
+// Track navigation calls
+const navigationHistory = [];
+const mockNavigate = jest.fn((url) => {
+  navigationHistory.push(url);
+});
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useParams: () => ({ appName: "obbba-household-by-household" }),
+  useNavigate: () => mockNavigate,
+  useLocation: () => ({
+    pathname: "/us/obbba-household-by-household",
+    search: navigationHistory.length > 0 
+      ? navigationHistory[navigationHistory.length - 1].split("?")[1] || ""
+      : "?household=initial",
+  }),
+}));
+
+// Mock the Header and Footer components
+jest.mock("../../layout/Header", () => {
+  return function Header() {
+    return <div data-testid="header">Header</div>;
+  };
+});
+
+jest.mock("../../layout/Footer", () => {
+  return function Footer() {
+    return <div data-testid="footer">Footer</div>;
+  };
+});
+
+describe("AppPage Integration - One Behind Issue", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    navigationHistory.length = 0;
+  });
+
+  it("demonstrates the 'one behind' issue when iframe sends old state", async () => {
+    const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+    
+    render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Simulate the problematic sequence where iframe sends old state
+    const sequence = [
+      {
+        iframeCurrentState: "household=12345",
+        iframeSendsState: "household=initial", // Sends old state
+        expectedParentUrl: "household=initial",
+      },
+      {
+        iframeCurrentState: "household=67890",
+        iframeSendsState: "household=12345", // Sends previous state
+        expectedParentUrl: "household=12345",
+      },
+      {
+        iframeCurrentState: "household=99999",
+        iframeSendsState: "household=67890", // Sends previous state
+        expectedParentUrl: "household=67890",
+      },
+    ];
+
+    for (const step of sequence) {
+      console.log(`\n--- Iframe shows: ${step.iframeCurrentState} ---`);
+      console.log(`Iframe sends: ${step.iframeSendsState}`);
+      
+      // Simulate iframe sending the OLD state
+      const messageEvent = new MessageEvent("message", {
+        data: {
+          type: "urlUpdate",
+          params: step.iframeSendsState,
+        },
+        origin: "https://policyengine.github.io",
+      });
+
+      act(() => {
+        window.dispatchEvent(messageEvent);
+      });
+
+      await waitFor(() => {
+        const lastCall = mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
+        if (lastCall) {
+          const urlParams = lastCall[0].split("?")[1];
+          console.log(`Parent URL updated to: ${urlParams}`);
+          expect(urlParams).toBe(step.expectedParentUrl);
+        }
+      });
+    }
+
+    console.log("\n--- Summary ---");
+    console.log("The parent URL is always one step behind what the iframe displays!");
+    console.log("This happens because the iframe sends its OLD state before updating internally.");
+
+    consoleSpy.mockRestore();
+  });
+
+  it("shows correct behavior when iframe sends current state", async () => {
+    const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+    
+    render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Simulate the CORRECT sequence where iframe sends current state
+    const sequence = [
+      {
+        iframeCurrentState: "household=12345",
+        iframeSendsState: "household=12345", // Sends current state
+        expectedParentUrl: "household=12345",
+      },
+      {
+        iframeCurrentState: "household=67890",
+        iframeSendsState: "household=67890", // Sends current state
+        expectedParentUrl: "household=67890",
+      },
+    ];
+
+    for (const step of sequence) {
+      console.log(`\n--- Iframe shows: ${step.iframeCurrentState} ---`);
+      console.log(`Iframe sends: ${step.iframeSendsState}`);
+      
+      const messageEvent = new MessageEvent("message", {
+        data: {
+          type: "urlUpdate",
+          params: step.iframeSendsState,
+        },
+        origin: "https://policyengine.github.io",
+      });
+
+      act(() => {
+        window.dispatchEvent(messageEvent);
+      });
+
+      await waitFor(() => {
+        const lastCall = mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
+        if (lastCall) {
+          const urlParams = lastCall[0].split("?")[1];
+          console.log(`Parent URL updated to: ${urlParams}`);
+          expect(urlParams).toBe(step.expectedParentUrl);
+        }
+      });
+    }
+
+    console.log("\n--- Summary ---");
+    console.log("When iframe sends its CURRENT state, URLs stay in sync!");
+
+    consoleSpy.mockRestore();
+  });
+
+  it("demonstrates timing issue with state updates", async () => {
+    render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Simulate what might be happening in the iframe
+    const simulateIframeClick = async (newHousehold) => {
+      // 1. User clicks on household
+      console.log(`User clicks household: ${newHousehold}`);
+      
+      // 2. Iframe might send message BEFORE updating its own state
+      const oldState = navigationHistory.length > 0 
+        ? navigationHistory[navigationHistory.length - 1].split("=")[1]
+        : "initial";
+      
+      const messageEvent = new MessageEvent("message", {
+        data: {
+          type: "urlUpdate",
+          params: `household=${oldState}`, // Sends OLD state!
+        },
+        origin: "https://policyengine.github.io",
+      });
+
+      window.dispatchEvent(messageEvent);
+      
+      // 3. Then iframe updates its own display
+      console.log(`Iframe now displays: ${newHousehold} (but parent got: ${oldState})`);
+    };
+
+    // Simulate user interactions
+    await simulateIframeClick("12345");
+    await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(1));
+    
+    await simulateIframeClick("67890");
+    await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(2));
+    
+    // Verify the "one behind" pattern
+    expect(mockNavigate).toHaveBeenNthCalledWith(1, 
+      "/us/obbba-household-by-household?household=initial", 
+      { replace: true }
+    );
+    expect(mockNavigate).toHaveBeenNthCalledWith(2, 
+      "/us/obbba-household-by-household?household=initial", // Still showing first value!
+      { replace: true }
+    );
+  });
+});
\ No newline at end of file
diff --git a/src/__tests__/pages/AppPage.oneBehind.test.js b/src/__tests__/pages/AppPage.oneBehind.test.js
new file mode 100644
index 000000000..cfc0ef648
--- /dev/null
+++ b/src/__tests__/pages/AppPage.oneBehind.test.js
@@ -0,0 +1,89 @@
+/**
+ * This test demonstrates the "one behind" issue with OBBBA URL synchronization
+ * 
+ * The problem: When clicking households in the iframe, the parent URL updates
+ * but shows the PREVIOUS household ID, not the current one.
+ * 
+ * Root cause: The iframe is sending its OLD state in the postMessage before
+ * updating its own internal state.
+ */
+
+describe("OBBBA 'One Behind' Issue", () => {
+  it("demonstrates the problem", () => {
+    // Simulate what's happening:
+    const iframeInternalState = { household: "initial" };
+    const parentUrlHistory = [];
+    
+    // Function to simulate iframe behavior (problematic version)
+    const simulateIframeClick_PROBLEMATIC = (newHousehold) => {
+      // 1. User clicks, iframe sends message with CURRENT (old) state
+      parentUrlHistory.push(iframeInternalState.household);
+      
+      // 2. THEN iframe updates its own state
+      iframeInternalState.household = newHousehold;
+      
+      console.log(`After clicking ${newHousehold}:`);
+      console.log(`  Iframe shows: ${iframeInternalState.household}`);
+      console.log(`  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`);
+      console.log(`  One behind? ${iframeInternalState.household !== parentUrlHistory[parentUrlHistory.length - 1]}`);
+    };
+    
+    // Simulate user interactions
+    console.log("\n=== PROBLEMATIC BEHAVIOR (what's happening now) ===");
+    simulateIframeClick_PROBLEMATIC("12345");
+    simulateIframeClick_PROBLEMATIC("67890");
+    simulateIframeClick_PROBLEMATIC("99999");
+    
+    // Verify the "one behind" pattern
+    expect(parentUrlHistory).toEqual(["initial", "12345", "67890"]);
+    expect(iframeInternalState.household).toBe("99999");
+    
+    // The parent is showing "67890" but iframe is showing "99999"!
+    expect(parentUrlHistory[parentUrlHistory.length - 1]).not.toBe(iframeInternalState.household);
+  });
+  
+  it("shows how it should work", () => {
+    const iframeInternalState = { household: "initial" };
+    const parentUrlHistory = [];
+    
+    // Function to simulate iframe behavior (correct version)
+    const simulateIframeClick_CORRECT = (newHousehold) => {
+      // 1. User clicks, iframe updates its own state FIRST
+      iframeInternalState.household = newHousehold;
+      
+      // 2. THEN sends message with NEW state
+      parentUrlHistory.push(iframeInternalState.household);
+      
+      console.log(`After clicking ${newHousehold}:`);
+      console.log(`  Iframe shows: ${iframeInternalState.household}`);
+      console.log(`  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`);
+      console.log(`  In sync? ${iframeInternalState.household === parentUrlHistory[parentUrlHistory.length - 1]}`);
+    };
+    
+    // Simulate user interactions
+    console.log("\n=== CORRECT BEHAVIOR (how it should work) ===");
+    simulateIframeClick_CORRECT("12345");
+    simulateIframeClick_CORRECT("67890");
+    simulateIframeClick_CORRECT("99999");
+    
+    // Verify they stay in sync
+    expect(parentUrlHistory).toEqual(["12345", "67890", "99999"]);
+    expect(iframeInternalState.household).toBe("99999");
+    
+    // The parent and iframe show the same value!
+    expect(parentUrlHistory[parentUrlHistory.length - 1]).toBe(iframeInternalState.household);
+  });
+  
+  it("explains the fix needed", () => {
+    console.log("\n=== FIX NEEDED ===");
+    console.log("The obbba-scatter app needs to:");
+    console.log("1. Update its own state/URL first");
+    console.log("2. THEN send the postMessage with the NEW state");
+    console.log("\nCurrently it's doing:");
+    console.log("1. Send postMessage with OLD state");
+    console.log("2. Then update its own state");
+    
+    // This test always passes - it's just for documentation
+    expect(true).toBe(true);
+  });
+});
\ No newline at end of file
diff --git a/src/__tests__/pages/AppPage.test.js b/src/__tests__/pages/AppPage.test.js
new file mode 100644
index 000000000..2cbb948ac
--- /dev/null
+++ b/src/__tests__/pages/AppPage.test.js
@@ -0,0 +1,256 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import { BrowserRouter, useLocation } from "react-router-dom";
+import AppPage from "../../pages/AppPage";
+import { apps } from "../../apps/appTransformers";
+
+// Mock the apps data
+jest.mock("../../apps/appTransformers", () => ({
+  apps: [
+    {
+      title: "OBBBA household-by-household analysis",
+      description: "Test description",
+      url: "https://policyengine.github.io/obbba-scatter",
+      slug: "obbba-household-by-household",
+      tags: ["us", "featured", "policy"],
+    },
+    {
+      title: "Other App",
+      description: "Other app description",
+      url: "https://example.com/other-app",
+      slug: "other-app",
+      tags: ["us"],
+    },
+  ],
+}));
+
+// Mock react-router-dom hooks
+const mockNavigate = jest.fn();
+const mockLocation = {
+  pathname: "/us/obbba-household-by-household",
+  search: "?household=12345&baseline=current",
+};
+
+jest.mock("react-router-dom", () => ({
+  ...jest.requireActual("react-router-dom"),
+  useParams: () => ({ appName: "obbba-household-by-household" }),
+  useNavigate: () => mockNavigate,
+  useLocation: () => mockLocation,
+}));
+
+// Mock the Header and Footer components
+jest.mock("../../layout/Header", () => {
+  return function Header() {
+    return <div data-testid="header">Header</div>;
+  };
+});
+
+jest.mock("../../layout/Footer", () => {
+  return function Footer() {
+    return <div data-testid="footer">Footer</div>;
+  };
+});
+
+describe("AppPage", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Reset location mock
+    mockLocation.search = "";
+  });
+
+  it("renders the OBBBA iframe with URL parameters on initial load", () => {
+    mockLocation.search = "?household=12345&baseline=current";
+    
+    const { container } = render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    const iframe = container.querySelector("iframe");
+    expect(iframe).toBeTruthy();
+    expect(iframe.src).toBe(
+      "https://policyengine.github.io/obbba-scatter?household=12345&baseline=current"
+    );
+  });
+
+  it("does not add URL parameters to non-OBBBA apps", () => {
+    // Change to other app
+    jest.mock("react-router-dom", () => ({
+      ...jest.requireActual("react-router-dom"),
+      useParams: () => ({ appName: "other-app" }),
+      useNavigate: () => mockNavigate,
+      useLocation: () => ({ ...mockLocation, pathname: "/us/other-app" }),
+    }));
+
+    const { container } = render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    const iframe = container.querySelector("iframe");
+    expect(iframe).toBeTruthy();
+    expect(iframe.src).toBe("https://example.com/other-app");
+  });
+
+  it("handles postMessage from iframe and updates parent URL", async () => {
+    const { container } = render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Wait for iframe to be rendered
+    await waitFor(() => {
+      expect(container.querySelector("iframe")).toBeTruthy();
+    });
+
+    // Simulate postMessage from iframe
+    const messageEvent = new MessageEvent("message", {
+      data: {
+        type: "urlUpdate",
+        params: "household=67890&baseline=reform",
+      },
+      origin: "https://policyengine.github.io",
+    });
+
+    window.dispatchEvent(messageEvent);
+
+    // Check that navigate was called with the new parameters
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalledWith(
+        "/us/obbba-household-by-household?household=67890&baseline=reform",
+        { replace: true }
+      );
+    });
+  });
+
+  it("ignores postMessage from unauthorized origins", async () => {
+    render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Simulate postMessage from wrong origin
+    const messageEvent = new MessageEvent("message", {
+      data: {
+        type: "urlUpdate",
+        params: "household=99999",
+      },
+      origin: "https://malicious-site.com",
+    });
+
+    window.dispatchEvent(messageEvent);
+
+    // Navigate should not have been called
+    expect(mockNavigate).not.toHaveBeenCalled();
+  });
+
+  it("does not reload iframe when URL is updated from iframe message", async () => {
+    const { container } = render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Get initial iframe
+    const iframe = container.querySelector("iframe");
+    const initialSrc = iframe.src;
+
+    // Simulate postMessage from iframe
+    const messageEvent = new MessageEvent("message", {
+      data: {
+        type: "urlUpdate",
+        params: "household=67890&baseline=reform",
+      },
+      origin: "https://policyengine.github.io",
+    });
+
+    window.dispatchEvent(messageEvent);
+
+    // Wait a bit to ensure any potential re-render would have happened
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalled();
+    });
+
+    // Check that iframe src hasn't changed (no reload)
+    const iframeAfter = container.querySelector("iframe");
+    expect(iframeAfter.src).toBe(initialSrc);
+  });
+
+  it("logs debug information when receiving URL updates", async () => {
+    const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+
+    render(
+      <BrowserRouter>
+        <AppPage />
+      </BrowserRouter>
+    );
+
+    // Simulate postMessage from iframe
+    const messageEvent = new MessageEvent("message", {
+      data: {
+        type: "urlUpdate",
+        params: "household=67890&baseline=reform",
+      },
+      origin: "https://policyengine.github.io",
+    });
+
+    window.dispatchEvent(messageEvent);
+
+    await waitFor(() => {
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "Received urlUpdate from iframe:",
+        "household=67890&baseline=reform"
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "Navigating to:",
+        "/us/obbba-household-by-household?household=67890&baseline=reform"
+      );
+    });
+
+    consoleSpy.mockRestore();
+  });
+
+  describe("URL synchronization sequence", () => {
+    it("should handle rapid sequential URL updates correctly", async () => {
+      render(
+        <BrowserRouter>
+          <AppPage />
+        </BrowserRouter>
+      );
+
+      // Simulate rapid sequential messages
+      const messages = [
+        { household: "11111", baseline: "current" },
+        { household: "22222", baseline: "current" },
+        { household: "33333", baseline: "current" },
+      ];
+
+      for (const params of messages) {
+        const messageEvent = new MessageEvent("message", {
+          data: {
+            type: "urlUpdate",
+            params: new URLSearchParams(params).toString(),
+          },
+          origin: "https://policyengine.github.io",
+        });
+
+        window.dispatchEvent(messageEvent);
+        
+        // Small delay to simulate real-world timing
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+
+      // Check that navigate was called for each update
+      await waitFor(() => {
+        expect(mockNavigate).toHaveBeenCalledTimes(3);
+        expect(mockNavigate).toHaveBeenLastCalledWith(
+          "/us/obbba-household-by-household?household=33333&baseline=current",
+          { replace: true }
+        );
+      });
+    });
+  });
+});
\ No newline at end of file

From aabd788cc958cff775a3bc277adc40164b827fea Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Thu, 24 Jul 2025 18:39:47 -0400
Subject: [PATCH 03/14] Remove debugging logs since obbba-scatter fix resolved
 the issue
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 'one behind' issue has been resolved in the obbba-scatter app by ensuring
it sends the NEW state after updating internally, rather than the OLD state.
Removing the extra debug logging that was added for troubleshooting.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../pages/AppPage.integration.test.js         | 88 +++++++++++--------
 src/__tests__/pages/AppPage.oneBehind.test.js | 60 ++++++++-----
 src/__tests__/pages/AppPage.test.js           | 37 ++++----
 src/pages/AppPage.jsx                         |  5 --
 4 files changed, 103 insertions(+), 87 deletions(-)

diff --git a/src/__tests__/pages/AppPage.integration.test.js b/src/__tests__/pages/AppPage.integration.test.js
index 7fb884856..d60f188eb 100644
--- a/src/__tests__/pages/AppPage.integration.test.js
+++ b/src/__tests__/pages/AppPage.integration.test.js
@@ -30,9 +30,10 @@ jest.mock("react-router-dom", () => ({
   useNavigate: () => mockNavigate,
   useLocation: () => ({
     pathname: "/us/obbba-household-by-household",
-    search: navigationHistory.length > 0 
-      ? navigationHistory[navigationHistory.length - 1].split("?")[1] || ""
-      : "?household=initial",
+    search:
+      navigationHistory.length > 0
+        ? navigationHistory[navigationHistory.length - 1].split("?")[1] || ""
+        : "?household=initial",
   }),
 }));
 
@@ -57,11 +58,11 @@ describe("AppPage Integration - One Behind Issue", () => {
 
   it("demonstrates the 'one behind' issue when iframe sends old state", async () => {
     const consoleSpy = jest.spyOn(console, "log").mockImplementation();
-    
+
     render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Simulate the problematic sequence where iframe sends old state
@@ -86,7 +87,7 @@ describe("AppPage Integration - One Behind Issue", () => {
     for (const step of sequence) {
       console.log(`\n--- Iframe shows: ${step.iframeCurrentState} ---`);
       console.log(`Iframe sends: ${step.iframeSendsState}`);
-      
+
       // Simulate iframe sending the OLD state
       const messageEvent = new MessageEvent("message", {
         data: {
@@ -101,29 +102,33 @@ describe("AppPage Integration - One Behind Issue", () => {
       });
 
       await waitFor(() => {
-        const lastCall = mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
-        if (lastCall) {
-          const urlParams = lastCall[0].split("?")[1];
-          console.log(`Parent URL updated to: ${urlParams}`);
-          expect(urlParams).toBe(step.expectedParentUrl);
-        }
+        const lastCall =
+          mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
+        expect(lastCall).toBeTruthy();
+        const urlParams = lastCall[0].split("?")[1];
+        console.log(`Parent URL updated to: ${urlParams}`);
+        expect(urlParams).toBe(step.expectedParentUrl);
       });
     }
 
     console.log("\n--- Summary ---");
-    console.log("The parent URL is always one step behind what the iframe displays!");
-    console.log("This happens because the iframe sends its OLD state before updating internally.");
+    console.log(
+      "The parent URL is always one step behind what the iframe displays!",
+    );
+    console.log(
+      "This happens because the iframe sends its OLD state before updating internally.",
+    );
 
     consoleSpy.mockRestore();
   });
 
   it("shows correct behavior when iframe sends current state", async () => {
     const consoleSpy = jest.spyOn(console, "log").mockImplementation();
-    
+
     render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Simulate the CORRECT sequence where iframe sends current state
@@ -143,7 +148,7 @@ describe("AppPage Integration - One Behind Issue", () => {
     for (const step of sequence) {
       console.log(`\n--- Iframe shows: ${step.iframeCurrentState} ---`);
       console.log(`Iframe sends: ${step.iframeSendsState}`);
-      
+
       const messageEvent = new MessageEvent("message", {
         data: {
           type: "urlUpdate",
@@ -157,12 +162,12 @@ describe("AppPage Integration - One Behind Issue", () => {
       });
 
       await waitFor(() => {
-        const lastCall = mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
-        if (lastCall) {
-          const urlParams = lastCall[0].split("?")[1];
-          console.log(`Parent URL updated to: ${urlParams}`);
-          expect(urlParams).toBe(step.expectedParentUrl);
-        }
+        const lastCall =
+          mockNavigate.mock.calls[mockNavigate.mock.calls.length - 1];
+        expect(lastCall).toBeTruthy();
+        const urlParams = lastCall[0].split("?")[1];
+        console.log(`Parent URL updated to: ${urlParams}`);
+        expect(urlParams).toBe(step.expectedParentUrl);
       });
     }
 
@@ -176,19 +181,20 @@ describe("AppPage Integration - One Behind Issue", () => {
     render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Simulate what might be happening in the iframe
     const simulateIframeClick = async (newHousehold) => {
       // 1. User clicks on household
       console.log(`User clicks household: ${newHousehold}`);
-      
+
       // 2. Iframe might send message BEFORE updating its own state
-      const oldState = navigationHistory.length > 0 
-        ? navigationHistory[navigationHistory.length - 1].split("=")[1]
-        : "initial";
-      
+      const oldState =
+        navigationHistory.length > 0
+          ? navigationHistory[navigationHistory.length - 1].split("=")[1]
+          : "initial";
+
       const messageEvent = new MessageEvent("message", {
         data: {
           type: "urlUpdate",
@@ -198,26 +204,30 @@ describe("AppPage Integration - One Behind Issue", () => {
       });
 
       window.dispatchEvent(messageEvent);
-      
+
       // 3. Then iframe updates its own display
-      console.log(`Iframe now displays: ${newHousehold} (but parent got: ${oldState})`);
+      console.log(
+        `Iframe now displays: ${newHousehold} (but parent got: ${oldState})`,
+      );
     };
 
     // Simulate user interactions
     await simulateIframeClick("12345");
     await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(1));
-    
+
     await simulateIframeClick("67890");
     await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(2));
-    
+
     // Verify the "one behind" pattern
-    expect(mockNavigate).toHaveBeenNthCalledWith(1, 
-      "/us/obbba-household-by-household?household=initial", 
-      { replace: true }
+    expect(mockNavigate).toHaveBeenNthCalledWith(
+      1,
+      "/us/obbba-household-by-household?household=initial",
+      { replace: true },
     );
-    expect(mockNavigate).toHaveBeenNthCalledWith(2, 
+    expect(mockNavigate).toHaveBeenNthCalledWith(
+      2,
       "/us/obbba-household-by-household?household=initial", // Still showing first value!
-      { replace: true }
+      { replace: true },
     );
   });
-});
\ No newline at end of file
+});
diff --git a/src/__tests__/pages/AppPage.oneBehind.test.js b/src/__tests__/pages/AppPage.oneBehind.test.js
index cfc0ef648..623d24c70 100644
--- a/src/__tests__/pages/AppPage.oneBehind.test.js
+++ b/src/__tests__/pages/AppPage.oneBehind.test.js
@@ -1,9 +1,9 @@
 /**
  * This test demonstrates the "one behind" issue with OBBBA URL synchronization
- * 
+ *
  * The problem: When clicking households in the iframe, the parent URL updates
  * but shows the PREVIOUS household ID, not the current one.
- * 
+ *
  * Root cause: The iframe is sending its OLD state in the postMessage before
  * updating its own internal state.
  */
@@ -13,67 +13,79 @@ describe("OBBBA 'One Behind' Issue", () => {
     // Simulate what's happening:
     const iframeInternalState = { household: "initial" };
     const parentUrlHistory = [];
-    
+
     // Function to simulate iframe behavior (problematic version)
     const simulateIframeClick_PROBLEMATIC = (newHousehold) => {
       // 1. User clicks, iframe sends message with CURRENT (old) state
       parentUrlHistory.push(iframeInternalState.household);
-      
+
       // 2. THEN iframe updates its own state
       iframeInternalState.household = newHousehold;
-      
+
       console.log(`After clicking ${newHousehold}:`);
       console.log(`  Iframe shows: ${iframeInternalState.household}`);
-      console.log(`  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`);
-      console.log(`  One behind? ${iframeInternalState.household !== parentUrlHistory[parentUrlHistory.length - 1]}`);
+      console.log(
+        `  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`,
+      );
+      console.log(
+        `  One behind? ${iframeInternalState.household !== parentUrlHistory[parentUrlHistory.length - 1]}`,
+      );
     };
-    
+
     // Simulate user interactions
     console.log("\n=== PROBLEMATIC BEHAVIOR (what's happening now) ===");
     simulateIframeClick_PROBLEMATIC("12345");
     simulateIframeClick_PROBLEMATIC("67890");
     simulateIframeClick_PROBLEMATIC("99999");
-    
+
     // Verify the "one behind" pattern
     expect(parentUrlHistory).toEqual(["initial", "12345", "67890"]);
     expect(iframeInternalState.household).toBe("99999");
-    
+
     // The parent is showing "67890" but iframe is showing "99999"!
-    expect(parentUrlHistory[parentUrlHistory.length - 1]).not.toBe(iframeInternalState.household);
+    expect(parentUrlHistory[parentUrlHistory.length - 1]).not.toBe(
+      iframeInternalState.household,
+    );
   });
-  
+
   it("shows how it should work", () => {
     const iframeInternalState = { household: "initial" };
     const parentUrlHistory = [];
-    
+
     // Function to simulate iframe behavior (correct version)
     const simulateIframeClick_CORRECT = (newHousehold) => {
       // 1. User clicks, iframe updates its own state FIRST
       iframeInternalState.household = newHousehold;
-      
+
       // 2. THEN sends message with NEW state
       parentUrlHistory.push(iframeInternalState.household);
-      
+
       console.log(`After clicking ${newHousehold}:`);
       console.log(`  Iframe shows: ${iframeInternalState.household}`);
-      console.log(`  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`);
-      console.log(`  In sync? ${iframeInternalState.household === parentUrlHistory[parentUrlHistory.length - 1]}`);
+      console.log(
+        `  Parent URL shows: ${parentUrlHistory[parentUrlHistory.length - 1]}`,
+      );
+      console.log(
+        `  In sync? ${iframeInternalState.household === parentUrlHistory[parentUrlHistory.length - 1]}`,
+      );
     };
-    
+
     // Simulate user interactions
     console.log("\n=== CORRECT BEHAVIOR (how it should work) ===");
     simulateIframeClick_CORRECT("12345");
     simulateIframeClick_CORRECT("67890");
     simulateIframeClick_CORRECT("99999");
-    
+
     // Verify they stay in sync
     expect(parentUrlHistory).toEqual(["12345", "67890", "99999"]);
     expect(iframeInternalState.household).toBe("99999");
-    
+
     // The parent and iframe show the same value!
-    expect(parentUrlHistory[parentUrlHistory.length - 1]).toBe(iframeInternalState.household);
+    expect(parentUrlHistory[parentUrlHistory.length - 1]).toBe(
+      iframeInternalState.household,
+    );
   });
-  
+
   it("explains the fix needed", () => {
     console.log("\n=== FIX NEEDED ===");
     console.log("The obbba-scatter app needs to:");
@@ -82,8 +94,8 @@ describe("OBBBA 'One Behind' Issue", () => {
     console.log("\nCurrently it's doing:");
     console.log("1. Send postMessage with OLD state");
     console.log("2. Then update its own state");
-    
+
     // This test always passes - it's just for documentation
     expect(true).toBe(true);
   });
-});
\ No newline at end of file
+});
diff --git a/src/__tests__/pages/AppPage.test.js b/src/__tests__/pages/AppPage.test.js
index 2cbb948ac..ecdbabc73 100644
--- a/src/__tests__/pages/AppPage.test.js
+++ b/src/__tests__/pages/AppPage.test.js
@@ -1,7 +1,6 @@
-import { render, screen, waitFor } from "@testing-library/react";
-import { BrowserRouter, useLocation } from "react-router-dom";
+import { render, waitFor } from "@testing-library/react";
+import { BrowserRouter } from "react-router-dom";
 import AppPage from "../../pages/AppPage";
-import { apps } from "../../apps/appTransformers";
 
 // Mock the apps data
 jest.mock("../../apps/appTransformers", () => ({
@@ -59,17 +58,17 @@ describe("AppPage", () => {
 
   it("renders the OBBBA iframe with URL parameters on initial load", () => {
     mockLocation.search = "?household=12345&baseline=current";
-    
+
     const { container } = render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     const iframe = container.querySelector("iframe");
     expect(iframe).toBeTruthy();
     expect(iframe.src).toBe(
-      "https://policyengine.github.io/obbba-scatter?household=12345&baseline=current"
+      "https://policyengine.github.io/obbba-scatter?household=12345&baseline=current",
     );
   });
 
@@ -85,7 +84,7 @@ describe("AppPage", () => {
     const { container } = render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     const iframe = container.querySelector("iframe");
@@ -97,7 +96,7 @@ describe("AppPage", () => {
     const { container } = render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Wait for iframe to be rendered
@@ -120,7 +119,7 @@ describe("AppPage", () => {
     await waitFor(() => {
       expect(mockNavigate).toHaveBeenCalledWith(
         "/us/obbba-household-by-household?household=67890&baseline=reform",
-        { replace: true }
+        { replace: true },
       );
     });
   });
@@ -129,7 +128,7 @@ describe("AppPage", () => {
     render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Simulate postMessage from wrong origin
@@ -151,7 +150,7 @@ describe("AppPage", () => {
     const { container } = render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Get initial iframe
@@ -185,7 +184,7 @@ describe("AppPage", () => {
     render(
       <BrowserRouter>
         <AppPage />
-      </BrowserRouter>
+      </BrowserRouter>,
     );
 
     // Simulate postMessage from iframe
@@ -202,11 +201,11 @@ describe("AppPage", () => {
     await waitFor(() => {
       expect(consoleSpy).toHaveBeenCalledWith(
         "Received urlUpdate from iframe:",
-        "household=67890&baseline=reform"
+        "household=67890&baseline=reform",
       );
       expect(consoleSpy).toHaveBeenCalledWith(
         "Navigating to:",
-        "/us/obbba-household-by-household?household=67890&baseline=reform"
+        "/us/obbba-household-by-household?household=67890&baseline=reform",
       );
     });
 
@@ -218,7 +217,7 @@ describe("AppPage", () => {
       render(
         <BrowserRouter>
           <AppPage />
-        </BrowserRouter>
+        </BrowserRouter>,
       );
 
       // Simulate rapid sequential messages
@@ -238,9 +237,9 @@ describe("AppPage", () => {
         });
 
         window.dispatchEvent(messageEvent);
-        
+
         // Small delay to simulate real-world timing
-        await new Promise(resolve => setTimeout(resolve, 10));
+        await new Promise((resolve) => setTimeout(resolve, 10));
       }
 
       // Check that navigate was called for each update
@@ -248,9 +247,9 @@ describe("AppPage", () => {
         expect(mockNavigate).toHaveBeenCalledTimes(3);
         expect(mockNavigate).toHaveBeenLastCalledWith(
           "/us/obbba-household-by-household?household=33333&baseline=current",
-          { replace: true }
+          { replace: true },
         );
       });
     });
   });
-});
\ No newline at end of file
+});
diff --git a/src/pages/AppPage.jsx b/src/pages/AppPage.jsx
index 454f7b07f..7cc244fbe 100644
--- a/src/pages/AppPage.jsx
+++ b/src/pages/AppPage.jsx
@@ -48,13 +48,8 @@ export default function AppPage() {
 
         // Handle URL update messages from the iframe
         if (event.data?.type === "urlUpdate" && event.data?.params) {
-          console.log("Received urlUpdate from iframe:", event.data.params);
           const newParams = new URLSearchParams(event.data.params);
           const newParamsString = newParams.toString();
-          console.log(
-            "Navigating to:",
-            `${location.pathname}?${newParamsString}`,
-          );
 
           navigate(`${location.pathname}?${newParamsString}`, {
             replace: true,

From 5d35ba8d708f738c712a62d43e10e6d986a4bb0c Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 07:06:05 -0400
Subject: [PATCH 04/14] Add blog post explaining OBBBA modeling methodology
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This technical report explains how PolicyEngine models the One Big Beautiful Bill Act,
including:
- Policy provisions captured (tax changes, benefit program changes)
- Data sources (Enhanced CPS, imputations for tips/overtime/immigration)
- Calibration to CBO projections (SNAP, Medicaid, ACA take-up rates)
- Modeling limitations and validation approaches

Fixes #2705

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../posts/obbba-modeling-methodology.png      |  0
 .../articles/obbba-modeling-methodology.md    | 96 +++++++++++++++++++
 src/posts/posts.json                          |  9 ++
 3 files changed, 105 insertions(+)
 create mode 100644 src/images/posts/obbba-modeling-methodology.png
 create mode 100644 src/posts/articles/obbba-modeling-methodology.md

diff --git a/src/images/posts/obbba-modeling-methodology.png b/src/images/posts/obbba-modeling-methodology.png
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
new file mode 100644
index 000000000..12070c26c
--- /dev/null
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -0,0 +1,96 @@
+At PolicyEngine, we strive to provide transparent and accurate modeling of major policy changes. The One Big Beautiful Bill Act (OBBBA), signed into law on July 4, 2025, represents one of the most comprehensive tax and spending reforms in recent history. This report explains how PolicyEngine models the OBBBA, including the policy provisions we capture, our data sources, and calibration methodology.
+
+## Overview
+
+PolicyEngine's OBBBA modeling captures the major tax provisions and benefit program changes while calibrating to Congressional Budget Office (CBO) projections. Our approach leverages detailed microsimulation at the household level to project both individual and economy-wide impacts.
+
+## Policy provisions modeled
+
+### Tax provisions
+
+PolicyEngine models all major individual income tax provisions of the OBBBA:
+
+- **TCJA extension**: Permanent extension of the 2017 Tax Cuts and Jobs Act individual tax rates (12%, 22%, 24%, 32%, 37%), increased standard deduction, and elimination of personal exemptions
+- **Child Tax Credit changes**: $2,000 base amount with $1,800 refundability cap for 2026, with new SSN requirements that restrict eligibility
+- **Senior standard deduction**: Additional $6,000 deduction for taxpayers age 65 and over (2025-2028)
+- **Tips and overtime exemptions**: Exemption of up to $25,000 of tip income and overtime wages from income tax (2025-2028)
+- **Auto loan interest deduction**: Deduction of up to $10,000 of interest on qualifying vehicle loans (2025-2028)
+- **SALT deduction changes**: Increase in the state and local tax deduction cap to $40,000 for taxpayers earning under $500,000 (reverting to $10,000 after 5 years)
+- **Qualified Business Income Deduction**: Increased from 20% to 23% with modified phase-out thresholds
+
+### Benefit program changes
+
+The OBBBA implements significant changes to safety net programs:
+
+- **Medicaid work requirements**: Adults eligible through ACA expansion must meet work and reporting requirements
+- **SNAP work requirements**: Enhanced requirements for able-bodied adults without dependents
+- **ACA premium tax credit changes**: Non-extension of enhanced subsidies that were set to expire
+
+## Data sources
+
+### Enhanced Current Population Survey
+
+PolicyEngine uses the Enhanced CPS as our primary data source. This dataset builds on the Census Bureau's Current Population Survey by:
+
+- **Income imputation**: We impute tip income using a quantile random forest model trained on the Survey of Income and Program Participation (SIPP), which contains detailed tip income data from employer reports
+- **Overtime income**: We calculate overtime premiums based on hours worked, occupation categories, and Fair Labor Standards Act eligibility
+- **Immigration status**: We implement the ASEC Undocumented Algorithm to impute SSN card types, critical for modeling CTC eligibility under the new SSN requirements
+
+### Tax data integration
+
+While we use the IRS Public Use File for certain tax modeling components, we note that:
+- Mortgage interest deduction remains imputed from the PUF without modification
+- We do not model estate tax or corporate tax provisions
+- Capital gains and dividend income follow SOI-calibrated fractions
+
+## Calibration methodology
+
+### Program take-up rates
+
+PolicyEngine calibrates benefit program take-up rates to match CBO's coverage loss projections:
+
+- **SNAP take-up**: 77.5% (2026-2028) to align with projected enrollment reductions
+- **Medicaid take-up**: 92.0% (2026-2028) to match CBO's 10.5 million coverage loss estimate
+- **ACA take-up**: 65.5% (2026-2028) reflecting marketplace enrollment changes
+
+These calibrated rates ensure our microsimulation produces aggregate impacts consistent with official estimates while maintaining household-level accuracy.
+
+### Revenue calibration
+
+Our model projects federal revenue changes that align with CBO estimates:
+- Individual income tax provisions: -$3.8 trillion over 10 years
+- Coverage-related savings: +$1.02 trillion from Medicaid/CHIP reductions
+- Net fiscal impact: Approximately $3.0-4.1 trillion added to the debt
+
+## Modeling limitations
+
+Several provisions of the OBBBA are not captured in our current modeling:
+
+- **Estate tax changes**: Not modeled due to data limitations
+- **Corporate tax provisions**: Outside the scope of individual microsimulation
+- **Immigration enforcement**: Indirect effects on population and workforce not modeled
+- **State fiscal impacts**: Secondary effects on state budgets not captured
+- **Provider tax changes**: Medicaid provider tax moratorium effects not modeled
+
+## Validation
+
+We validate our modeling through several approaches:
+
+1. **Aggregate comparisons**: Total revenue and spending changes match CBO projections within reasonable bounds
+2. **Distributional analysis**: Income decile impacts align with independent analyses
+3. **Edge case testing**: Specific household scenarios tested against hand calculations
+4. **State-level validation**: Coverage losses by state compared to KFF allocations of CBO estimates
+
+## Technical implementation
+
+The OBBBA reforms are implemented across PolicyEngine's infrastructure:
+
+- **Parameter files**: Located in `policyengine_us/parameters/gov/contrib/reconciliation/`
+- **Reform definitions**: Consolidated in `obbba-scatter/data/reforms.py`
+- **Visualization**: Interactive household-by-household calculator at [policyengine.org/us/research/obbba-scatter](https://policyengine.org/us/research/obbba-scatter)
+
+## Conclusion
+
+PolicyEngine's OBBBA modeling provides comprehensive analysis of the law's major provisions while acknowledging areas where data or scope limitations prevent full modeling. By calibrating to CBO projections while maintaining detailed household-level simulation, we offer both accuracy and transparency in understanding this landmark legislation's impacts.
+
+For researchers and policymakers seeking to understand specific provisions or household impacts, our open-source implementation allows full inspection of modeling choices and assumptions. We continue to refine our modeling as new data and analyses become available.
\ No newline at end of file
diff --git a/src/posts/posts.json b/src/posts/posts.json
index 0e868b00a..e18e0cb62 100644
--- a/src/posts/posts.json
+++ b/src/posts/posts.json
@@ -1,4 +1,13 @@
 [
+  {
+    "title": "How PolicyEngine models the One Big Beautiful Bill Act",
+    "description": "A technical guide to our OBBBA modeling methodology, including policy rules, data sources, and calibration to CBO projections.",
+    "date": "2025-07-27",
+    "tags": ["us", "policy", "featured", "reconciliation"],
+    "filename": "obbba-modeling-methodology.md",
+    "image": "obbba-modeling-methodology.png",
+    "authors": ["max-ghenis"]
+  },
   {
     "title": "Analysis of individual income tax provisions in the final reconciliation bill",
     "description": "Our simulation projects a reduction in federal revenues of $3.8 trillion from 2026 to 2035 compared to current law.",

From da1c5d31e603a3f80952c71f770fb1b53f86add8 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 07:08:03 -0400
Subject: [PATCH 05/14] Fix formatting in OBBBA blog post
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Run Prettier to fix code style issues

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 12070c26c..9cd5e21a3 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -39,6 +39,7 @@ PolicyEngine uses the Enhanced CPS as our primary data source. This dataset buil
 ### Tax data integration
 
 While we use the IRS Public Use File for certain tax modeling components, we note that:
+
 - Mortgage interest deduction remains imputed from the PUF without modification
 - We do not model estate tax or corporate tax provisions
 - Capital gains and dividend income follow SOI-calibrated fractions
@@ -58,6 +59,7 @@ These calibrated rates ensure our microsimulation produces aggregate impacts con
 ### Revenue calibration
 
 Our model projects federal revenue changes that align with CBO estimates:
+
 - Individual income tax provisions: -$3.8 trillion over 10 years
 - Coverage-related savings: +$1.02 trillion from Medicaid/CHIP reductions
 - Net fiscal impact: Approximately $3.0-4.1 trillion added to the debt
@@ -93,4 +95,4 @@ The OBBBA reforms are implemented across PolicyEngine's infrastructure:
 
 PolicyEngine's OBBBA modeling provides comprehensive analysis of the law's major provisions while acknowledging areas where data or scope limitations prevent full modeling. By calibrating to CBO projections while maintaining detailed household-level simulation, we offer both accuracy and transparency in understanding this landmark legislation's impacts.
 
-For researchers and policymakers seeking to understand specific provisions or household impacts, our open-source implementation allows full inspection of modeling choices and assumptions. We continue to refine our modeling as new data and analyses become available.
\ No newline at end of file
+For researchers and policymakers seeking to understand specific provisions or household impacts, our open-source implementation allows full inspection of modeling choices and assumptions. We continue to refine our modeling as new data and analyses become available.

From 9d38212e5b655fee3b76198b2aec13fb718b367e Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:34:00 -0400
Subject: [PATCH 06/14] Correct revenue calibration section to clarify modeling
 scope
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Specify that the $3.8 trillion figure is PolicyEngine's projection for tax provisions
- Clarify that we don't directly model full fiscal impact of coverage losses
- Note CBO's separate estimates for Medicaid/CHIP spending reductions
- Remove unsupported claims about net fiscal impact

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 9cd5e21a3..c81cdccdf 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -56,13 +56,11 @@ PolicyEngine calibrates benefit program take-up rates to match CBO's coverage lo
 
 These calibrated rates ensure our microsimulation produces aggregate impacts consistent with official estimates while maintaining household-level accuracy.
 
-### Revenue calibration
+### Alignment with projections
 
-Our model projects federal revenue changes that align with CBO estimates:
+PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our analysis of the reconciliation bill's tax provisions projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
 
-- Individual income tax provisions: -$3.8 trillion over 10 years
-- Coverage-related savings: +$1.02 trillion from Medicaid/CHIP reductions
-- Net fiscal impact: Approximately $3.0-4.1 trillion added to the debt
+While we model the eligibility changes for programs like Medicaid and SNAP through our calibrated take-up rates, we do not directly model the full fiscal impact of coverage losses. The Congressional Budget Office has separately estimated that the OBBBA will reduce federal spending on Medicaid and CHIP by approximately $1 trillion through coverage reductions.
 
 ## Modeling limitations
 

From ff548f0912a661bb60472ceaa01de123e92d7186 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:37:08 -0400
Subject: [PATCH 07/14] Add link to final reconciliation tax analysis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Link the $3.8 trillion revenue projection to PolicyEngine's previous analysis

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index c81cdccdf..0bb899ee6 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -58,7 +58,7 @@ These calibrated rates ensure our microsimulation produces aggregate impacts con
 
 ### Alignment with projections
 
-PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our analysis of the reconciliation bill's tax provisions projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
+PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our [analysis of the reconciliation bill's tax provisions](https://policyengine.org/us/research/final-2025-reconciliation-tax) projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
 
 While we model the eligibility changes for programs like Medicaid and SNAP through our calibrated take-up rates, we do not directly model the full fiscal impact of coverage losses. The Congressional Budget Office has separately estimated that the OBBBA will reduce federal spending on Medicaid and CHIP by approximately $1 trillion through coverage reductions.
 

From 4414f8b27fa83dd2018ea9b93248132941f20e56 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:37:59 -0400
Subject: [PATCH 08/14] Use relative links for internal navigation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Update links to use relative paths that work both locally and in production

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 0bb899ee6..a30db607d 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -58,7 +58,7 @@ These calibrated rates ensure our microsimulation produces aggregate impacts con
 
 ### Alignment with projections
 
-PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our [analysis of the reconciliation bill's tax provisions](https://policyengine.org/us/research/final-2025-reconciliation-tax) projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
+PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our [analysis of the reconciliation bill's tax provisions](/us/research/final-2025-reconciliation-tax) projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
 
 While we model the eligibility changes for programs like Medicaid and SNAP through our calibrated take-up rates, we do not directly model the full fiscal impact of coverage losses. The Congressional Budget Office has separately estimated that the OBBBA will reduce federal spending on Medicaid and CHIP by approximately $1 trillion through coverage reductions.
 
@@ -87,7 +87,7 @@ The OBBBA reforms are implemented across PolicyEngine's infrastructure:
 
 - **Parameter files**: Located in `policyengine_us/parameters/gov/contrib/reconciliation/`
 - **Reform definitions**: Consolidated in `obbba-scatter/data/reforms.py`
-- **Visualization**: Interactive household-by-household calculator at [policyengine.org/us/research/obbba-scatter](https://policyengine.org/us/research/obbba-scatter)
+- **Visualization**: Interactive household-by-household calculator at [policyengine.org/us/research/obbba-scatter](/us/research/obbba-scatter)
 
 ## Conclusion
 

From 09cb22a125922062e6e04bb657d044fbf41acfa9 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:40:51 -0400
Subject: [PATCH 09/14] Add baseline comparison and clarify take-up calibration
 methodology
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Show baseline vs OBBBA take-up rates in a table
- Explain the two-stage calibration process (weights then take-up)
- Clarify that effective enrollment changes differ from raw percentages
- Note how this achieves CBO's aggregate projections

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index a30db607d..56cd74c2b 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -48,13 +48,15 @@ While we use the IRS Public Use File for certain tax modeling components, we not
 
 ### Program take-up rates
 
-PolicyEngine calibrates benefit program take-up rates to match CBO's coverage loss projections:
+PolicyEngine's approach to modeling OBBBA's coverage impacts involves adjusting program take-up rates from their baseline values:
 
-- **SNAP take-up**: 77.5% (2026-2028) to align with projected enrollment reductions
-- **Medicaid take-up**: 92.0% (2026-2028) to match CBO's 10.5 million coverage loss estimate
-- **ACA take-up**: 65.5% (2026-2028) reflecting marketplace enrollment changes
+| Program | Baseline Take-up | OBBBA Take-up (2026-2028) | Change |
+|---------|-----------------|---------------------------|---------|
+| SNAP | 82.0% | 77.5% | -4.5pp |
+| Medicaid | 93.0% | 92.0% | -1.0pp |
+| ACA | 67.2% | 65.5% | -1.7pp |
 
-These calibrated rates ensure our microsimulation produces aggregate impacts consistent with official estimates while maintaining household-level accuracy.
+These adjustments reflect CBO's projected coverage losses due to work requirements and administrative changes. However, the actual impact on enrollment is more complex than these raw percentages suggest. PolicyEngine first calibrates household weights to match baseline program enrollment, then applies the adjusted take-up rates. This two-stage process means the effective enrollment changes may differ from the simple percentage point differences shown above, but produces aggregate impacts consistent with CBO's estimates of 10.5 million Medicaid coverage losses and corresponding SNAP enrollment reductions.
 
 ### Alignment with projections
 

From 19eaa9a1b2abbc516d2dfa92c7a1c8ca22dfa6bc Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:42:22 -0400
Subject: [PATCH 10/14] Fix long hyperlink display text to prevent line
 wrapping
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Shorten the OBBBA scatter calculator link text for better formatting

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/posts/articles/obbba-modeling-methodology.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 56cd74c2b..3002ecb25 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -89,7 +89,7 @@ The OBBBA reforms are implemented across PolicyEngine's infrastructure:
 
 - **Parameter files**: Located in `policyengine_us/parameters/gov/contrib/reconciliation/`
 - **Reform definitions**: Consolidated in `obbba-scatter/data/reforms.py`
-- **Visualization**: Interactive household-by-household calculator at [policyengine.org/us/research/obbba-scatter](/us/research/obbba-scatter)
+- **Visualization**: Interactive [household-by-household calculator](/us/research/obbba-scatter)
 
 ## Conclusion
 

From ae15a0ab39fa144249cbf06e960e8813b7a66651 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:45:39 -0400
Subject: [PATCH 11/14] Correct and expand tax provisions section
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Fix CTC refundability cap ($1,700 in 2026, not $1,800)
- Add AMT changes and itemized deduction limitation
- Note higher standard deduction vs TCJA ($32,600 vs $30,300)
- Correct QBI deduction (maintained at 20%, not increased to 23%)
- Add CDCC enhancements
- Clarify phase-outs for tips/overtime exemptions
- Reorganize into clearer categories

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../articles/obbba-modeling-methodology.md    | 26 ++++++++++++++-----
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 3002ecb25..7e2fe54a4 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -8,15 +8,27 @@ PolicyEngine's OBBBA modeling captures the major tax provisions and benefit prog
 
 ### Tax provisions
 
-PolicyEngine models all major individual income tax provisions of the OBBBA:
+PolicyEngine models the OBBBA's comprehensive individual income tax changes, which go beyond a simple TCJA extension:
 
-- **TCJA extension**: Permanent extension of the 2017 Tax Cuts and Jobs Act individual tax rates (12%, 22%, 24%, 32%, 37%), increased standard deduction, and elimination of personal exemptions
-- **Child Tax Credit changes**: $2,000 base amount with $1,800 refundability cap for 2026, with new SSN requirements that restrict eligibility
+**Core rate and deduction changes**:
+- **Tax rates**: Permanent extension of TCJA rates (12%, 22%, 24%, 32%, 37%)
+- **Standard deduction**: Increased to $32,600 for joint filers in 2026 (higher than TCJA's $30,300)
+- **Personal exemptions**: Remain eliminated
+- **Alternative Minimum Tax**: Higher exemption amounts ($139,000 for joint filers) with modified phase-out rates
+- **Itemized deduction limitation**: New limitations based on income levels, replacing the previous Pease limitation
+
+**Credit modifications**:
+- **Child Tax Credit**: $2,200 base amount with $1,700 refundability cap for 2026 (not $1,800 as in TCJA), rising to $1,800 in 2027-2028, with new SSN requirements
 - **Senior standard deduction**: Additional $6,000 deduction for taxpayers age 65 and over (2025-2028)
-- **Tips and overtime exemptions**: Exemption of up to $25,000 of tip income and overtime wages from income tax (2025-2028)
-- **Auto loan interest deduction**: Deduction of up to $10,000 of interest on qualifying vehicle loans (2025-2028)
-- **SALT deduction changes**: Increase in the state and local tax deduction cap to $40,000 for taxpayers earning under $500,000 (reverting to $10,000 after 5 years)
-- **Qualified Business Income Deduction**: Increased from 20% to 23% with modified phase-out thresholds
+- **Child and Dependent Care Credit**: Enhanced maximum credit and two-tier phase-down structure
+
+**New deductions and exemptions**:
+- **Tips and overtime**: Exemption of up to $25,000 of tip income and overtime wages from income tax (2025-2028), phasing out at higher incomes
+- **Auto loan interest**: Deduction of up to $10,000 of interest on qualifying vehicle loans (2025-2028)
+- **SALT deduction**: Increased cap to $40,000 for taxpayers earning under $500,000, reverting to $10,000 in 2030
+
+**Business provisions**:
+- **Qualified Business Income Deduction**: Maintained at 20% (not increased to 23%) with minimum $400 deduction for qualifying businesses
 
 ### Benefit program changes
 

From ca8fb6bc5354c3e65bc9df0ba4452893e780a4c2 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:47:15 -0400
Subject: [PATCH 12/14] Add comprehensive modeling approach section and fix
 Pease reference
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add section explaining state/local tax integration
- Explain how federal changes flow through to state taxes
- Detail integrated benefit program modeling (SNAP, Medicaid, ACA)
- Note important interactions between tax and benefit systems
- Fix markdown formatting (blank lines around lists)
- Clarify that Pease was repealed by TCJA

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../articles/obbba-modeling-methodology.md    | 29 ++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 7e2fe54a4..8c3df7305 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -11,23 +11,27 @@ PolicyEngine's OBBBA modeling captures the major tax provisions and benefit prog
 PolicyEngine models the OBBBA's comprehensive individual income tax changes, which go beyond a simple TCJA extension:
 
 **Core rate and deduction changes**:
+
 - **Tax rates**: Permanent extension of TCJA rates (12%, 22%, 24%, 32%, 37%)
 - **Standard deduction**: Increased to $32,600 for joint filers in 2026 (higher than TCJA's $30,300)
 - **Personal exemptions**: Remain eliminated
 - **Alternative Minimum Tax**: Higher exemption amounts ($139,000 for joint filers) with modified phase-out rates
-- **Itemized deduction limitation**: New limitations based on income levels, replacing the previous Pease limitation
+- **Itemized deduction limitation**: New income-based limitations on itemized deductions (Pease limitation was repealed by TCJA)
 
 **Credit modifications**:
+
 - **Child Tax Credit**: $2,200 base amount with $1,700 refundability cap for 2026 (not $1,800 as in TCJA), rising to $1,800 in 2027-2028, with new SSN requirements
 - **Senior standard deduction**: Additional $6,000 deduction for taxpayers age 65 and over (2025-2028)
 - **Child and Dependent Care Credit**: Enhanced maximum credit and two-tier phase-down structure
 
 **New deductions and exemptions**:
+
 - **Tips and overtime**: Exemption of up to $25,000 of tip income and overtime wages from income tax (2025-2028), phasing out at higher incomes
 - **Auto loan interest**: Deduction of up to $10,000 of interest on qualifying vehicle loans (2025-2028)
 - **SALT deduction**: Increased cap to $40,000 for taxpayers earning under $500,000, reverting to $10,000 in 2030
 
 **Business provisions**:
+
 - **Qualified Business Income Deduction**: Maintained at 20% (not increased to 23%) with minimum $400 deduction for qualifying businesses
 
 ### Benefit program changes
@@ -38,6 +42,29 @@ The OBBBA implements significant changes to safety net programs:
 - **SNAP work requirements**: Enhanced requirements for able-bodied adults without dependents
 - **ACA premium tax credit changes**: Non-extension of enhanced subsidies that were set to expire
 
+## Comprehensive modeling approach
+
+### State and local tax integration
+
+PolicyEngine maintains a complete model of state and local income taxes for all 50 states and DC. This enables:
+
+- **Accurate SALT deduction calculations**: Our state tax models calculate the exact state and local tax liabilities that feed into the federal SALT deduction
+- **Mechanical effects on state taxes**: Many states begin with federal adjusted gross income or taxable income as their starting point. The OBBBA's new deductions (tips, overtime, auto loan interest) automatically flow through to reduce state tax liabilities in these states
+- **Interaction effects**: Changes to federal itemized deductions affect state taxes in states that conform to federal itemization rules
+
+### Integrated benefit program modeling
+
+PolicyEngine models the complete rules for major benefit programs, not just their take-up rates:
+
+- **SNAP**: Full eligibility determination based on income, assets, household composition, and work requirements
+- **Medicaid/CHIP**: State-specific eligibility pathways including expansion status, income limits, and categorical eligibility
+- **ACA subsidies**: Premium tax credit calculations based on income, family size, and local benchmark premiums
+
+This integrated approach captures important interactions:
+- Federal tax changes affect modified adjusted gross income (MAGI) used for ACA and Medicaid eligibility
+- Work requirements interact with existing categorical eligibility rules
+- Benefit cliffs and phase-outs combine with tax provisions to create complex marginal rate effects
+
 ## Data sources
 
 ### Enhanced Current Population Survey

From ba1631ef9184512e071988364149d23be45dc578 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:55:07 -0400
Subject: [PATCH 13/14] Expand data sources section with specific imputation
 details
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- List specific variables used in tip income model (employment income, age, children counts)
- Detail overtime calculation inputs (hours, occupation codes, FLSA status)
- Add auto loan imputation variables from SCF (age, state, income sources)
- Link to Ryan (2022) paper for ASEC Undocumented Algorithm
- Describe the 14 conditions examined in immigration status imputation
- Remove subjective adjectives, present facts directly

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../articles/obbba-modeling-methodology.md    | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index 8c3df7305..d28ef5096 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -69,11 +69,33 @@ This integrated approach captures important interactions:
 
 ### Enhanced Current Population Survey
 
-PolicyEngine uses the Enhanced CPS as our primary data source. This dataset builds on the Census Bureau's Current Population Survey by:
-
-- **Income imputation**: We impute tip income using a quantile random forest model trained on the Survey of Income and Program Participation (SIPP), which contains detailed tip income data from employer reports
-- **Overtime income**: We calculate overtime premiums based on hours worked, occupation categories, and Fair Labor Standards Act eligibility
-- **Immigration status**: We implement the ASEC Undocumented Algorithm to impute SSN card types, critical for modeling CTC eligibility under the new SSN requirements
+PolicyEngine uses the Enhanced CPS as our primary data source. This dataset builds on the Census Bureau's Current Population Survey through several imputation models:
+
+**Tip income imputation**: We train a quantile random forest model on the Survey of Income and Program Participation (SIPP), which contains employer-reported tip income. The model uses:
+- Employment income
+- Age
+- Number of children under 18
+- Number of children under 6
+
+**Overtime income**: We calculate overtime premiums using:
+- Hours worked per week from CPS
+- Occupation codes to determine Fair Labor Standards Act exemption status
+- Base employment income to derive hourly rates
+- Standard time-and-a-half (1.5x) premium for hours over 40
+
+**Auto loan interest**: We impute from the Survey of Consumer Finances using predictors:
+- Age and state
+- Household size and number of children
+- Employment, interest/dividend, and Social Security/pension income
+- The model imputes net worth, auto loan balance, and auto loan interest simultaneously
+
+**Immigration status**: We implement the [ASEC Undocumented Algorithm (Ryan 2022)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4662801), which uses a process-of-elimination approach. The algorithm examines 14 conditions including:
+- Arrival year (pre-1982 for IRCA amnesty eligibility)
+- Receipt of federal programs (Medicare, Social Security, SSI)
+- Government employment or military service
+- Other legal status indicators
+
+Those not meeting any condition are assigned SSN card type "NONE" (likely undocumented), calibrated to match external estimates (13 million for 2024-2025)
 
 ### Tax data integration
 

From 62a5beaf678ae0c946b9a1d7027eac3a11bbb0b8 Mon Sep 17 00:00:00 2001
From: Max Ghenis <mghenis@gmail.com>
Date: Sun, 27 Jul 2025 08:59:47 -0400
Subject: [PATCH 14/14] Add comprehensive sources and code links throughout
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add footnote for CBO's $1.02 trillion Medicaid/CHIP estimate with CAP and KFF sources
- Add code links for all imputation models (tips, overtime, auto loan, immigration)
- Link to specific line numbers in GitHub for implementation details
- Add sources for baseline take-up rates from parameter files
- Link reform definitions and parameter files
- Fix markdown list formatting issues
- Use footnotes for cleaner inline text

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../articles/obbba-modeling-methodology.md    | 39 ++++++++++++++-----
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/src/posts/articles/obbba-modeling-methodology.md b/src/posts/articles/obbba-modeling-methodology.md
index d28ef5096..206253243 100644
--- a/src/posts/articles/obbba-modeling-methodology.md
+++ b/src/posts/articles/obbba-modeling-methodology.md
@@ -61,6 +61,7 @@ PolicyEngine models the complete rules for major benefit programs, not just thei
 - **ACA subsidies**: Premium tax credit calculations based on income, family size, and local benchmark premiums
 
 This integrated approach captures important interactions:
+
 - Federal tax changes affect modified adjusted gross income (MAGI) used for ACA and Medicaid eligibility
 - Work requirements interact with existing categorical eligibility rules
 - Benefit cliffs and phase-outs combine with tax provisions to create complex marginal rate effects
@@ -71,25 +72,29 @@ This integrated approach captures important interactions:
 
 PolicyEngine uses the Enhanced CPS as our primary data source. This dataset builds on the Census Bureau's Current Population Survey through several imputation models:
 
-**Tip income imputation**: We train a quantile random forest model on the Survey of Income and Program Participation (SIPP), which contains employer-reported tip income. The model uses:
+**Tip income imputation**: We train a quantile random forest model on the Survey of Income and Program Participation (SIPP), which contains employer-reported tip income.[^2] The model uses:
+
 - Employment income
 - Age
 - Number of children under 18
 - Number of children under 6
 
-**Overtime income**: We calculate overtime premiums using:
+**Overtime income**: We calculate overtime premiums using:[^3]
+
 - Hours worked per week from CPS
 - Occupation codes to determine Fair Labor Standards Act exemption status
 - Base employment income to derive hourly rates
 - Standard time-and-a-half (1.5x) premium for hours over 40
 
-**Auto loan interest**: We impute from the Survey of Consumer Finances using predictors:
+**Auto loan interest**: We impute from the Survey of Consumer Finances using predictors:[^4]
+
 - Age and state
 - Household size and number of children
 - Employment, interest/dividend, and Social Security/pension income
 - The model imputes net worth, auto loan balance, and auto loan interest simultaneously
 
-**Immigration status**: We implement the [ASEC Undocumented Algorithm (Ryan 2022)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4662801), which uses a process-of-elimination approach. The algorithm examines 14 conditions including:
+**Immigration status**: We implement the [ASEC Undocumented Algorithm (Ryan 2022)](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4662801), which uses a process-of-elimination approach.[^5] The algorithm examines 14 conditions including:
+
 - Arrival year (pre-1982 for IRCA amnesty eligibility)
 - Receipt of federal programs (Medicare, Social Security, SSI)
 - Government employment or military service
@@ -111,8 +116,8 @@ While we use the IRS Public Use File for certain tax modeling components, we not
 
 PolicyEngine's approach to modeling OBBBA's coverage impacts involves adjusting program take-up rates from their baseline values:
 
-| Program | Baseline Take-up | OBBBA Take-up (2026-2028) | Change |
-|---------|-----------------|---------------------------|---------|
+| Program | Baseline Take-up[^6] | OBBBA Take-up (2026-2028)[^7] | Change |
+|---------|---------------------|-------------------------------|---------|
 | SNAP | 82.0% | 77.5% | -4.5pp |
 | Medicaid | 93.0% | 92.0% | -1.0pp |
 | ACA | 67.2% | 65.5% | -1.7pp |
@@ -123,7 +128,7 @@ These adjustments reflect CBO's projected coverage losses due to work requiremen
 
 PolicyEngine's modeling focuses on the individual income tax provisions and their interactions with benefit programs. Our [analysis of the reconciliation bill's tax provisions](/us/research/final-2025-reconciliation-tax) projects a $3.8 trillion reduction in federal revenues from 2026 to 2035 compared to current law.
 
-While we model the eligibility changes for programs like Medicaid and SNAP through our calibrated take-up rates, we do not directly model the full fiscal impact of coverage losses. The Congressional Budget Office has separately estimated that the OBBBA will reduce federal spending on Medicaid and CHIP by approximately $1 trillion through coverage reductions.
+While we model the eligibility changes for programs like Medicaid and SNAP through our calibrated take-up rates, we do not directly model the full fiscal impact of coverage losses. The Congressional Budget Office has separately estimated that the OBBBA will reduce federal spending on Medicaid and CHIP by $1.02 trillion through coverage reductions.[^1]
 
 ## Modeling limitations
 
@@ -148,8 +153,8 @@ We validate our modeling through several approaches:
 
 The OBBBA reforms are implemented across PolicyEngine's infrastructure:
 
-- **Parameter files**: Located in `policyengine_us/parameters/gov/contrib/reconciliation/`
-- **Reform definitions**: Consolidated in `obbba-scatter/data/reforms.py`
+- **Parameter files**: Located in [`policyengine_us/parameters/gov/contrib/reconciliation/`](https://github.com/PolicyEngine/policyengine-us/tree/master/policyengine_us/parameters/gov/contrib/reconciliation)
+- **Reform definitions**: Consolidated in [`obbba-scatter/data/reforms.py`](https://github.com/PolicyEngine/obbba-scatter/blob/main/data/reforms.py)
 - **Visualization**: Interactive [household-by-household calculator](/us/research/obbba-scatter)
 
 ## Conclusion
@@ -157,3 +162,19 @@ The OBBBA reforms are implemented across PolicyEngine's infrastructure:
 PolicyEngine's OBBBA modeling provides comprehensive analysis of the law's major provisions while acknowledging areas where data or scope limitations prevent full modeling. By calibrating to CBO projections while maintaining detailed household-level simulation, we offer both accuracy and transparency in understanding this landmark legislation's impacts.
 
 For researchers and policymakers seeking to understand specific provisions or household impacts, our open-source implementation allows full inspection of modeling choices and assumptions. We continue to refine our modeling as new data and analyses become available.
+
+---
+
+[^1]: Center for American Progress, ["The Truth About the One Big Beautiful Bill Act's Cuts to Medicaid and Medicare"](https://www.americanprogress.org/article/the-truth-about-the-one-big-beautiful-bill-acts-cuts-to-medicaid-and-medicare/), July 2025. See also KFF's [state-by-state allocation](https://www.kff.org/medicaid/issue-brief/allocating-cbos-estimates-of-federal-medicaid-spending-reductions-across-the-states-enacted-reconciliation-package/) of CBO's estimates.
+
+[^2]: Implementation in [`policyengine_us_data/datasets/sipp/sipp.py`](https://github.com/PolicyEngine/policyengine-us-data/blob/master/policyengine_us_data/datasets/sipp/sipp.py#L39-L71) and [`policyengine_us_data/datasets/cps/cps.py`](https://github.com/PolicyEngine/policyengine-us-data/blob/master/policyengine_us_data/datasets/cps/cps.py#L1219-L1233).
+
+[^3]: Overtime calculation in [`policyengine_us/variables/household/income/person/fsla_overtime_premium.py`](https://github.com/PolicyEngine/policyengine-us/blob/master/policyengine_us/variables/household/income/person/fsla_overtime_premium.py) and occupation mapping in [`policyengine_us_data/datasets/cps/cps.py`](https://github.com/PolicyEngine/policyengine-us-data/blob/master/policyengine_us_data/datasets/cps/cps.py#L1236-L1273).
+
+[^4]: Auto loan imputation in [`policyengine_us_data/datasets/cps/cps.py`](https://github.com/PolicyEngine/policyengine-us-data/blob/master/policyengine_us_data/datasets/cps/cps.py#L1275-L1356).
+
+[^5]: Full SSN status imputation implementation in [`policyengine_us_data/datasets/cps/cps.py`](https://github.com/PolicyEngine/policyengine-us-data/blob/master/policyengine_us_data/datasets/cps/cps.py#L1407-L1686) and detailed documentation in the [SSN statuses imputation notebook](https://github.com/PolicyEngine/policyengine-us-data/blob/master/docs/SSN_statuses_imputation.ipynb).
+
+[^6]: Baseline take-up rates from PolicyEngine parameters: [SNAP](https://github.com/PolicyEngine/policyengine-us/blob/master/policyengine_us/parameters/gov/usda/snap/takeup_rate.yaml), [Medicaid](https://github.com/PolicyEngine/policyengine-us/blob/master/policyengine_us/parameters/gov/hhs/medicaid/takeup_rate.yaml), [ACA](https://github.com/PolicyEngine/policyengine-us/blob/master/policyengine_us/parameters/gov/aca/takeup_rate.yaml).
+
+[^7]: OBBBA take-up adjustments in [`obbba-scatter/data/reforms.py`](https://github.com/PolicyEngine/obbba-scatter/blob/main/data/reforms.py#L535-L570).