An AI-powered tool that helps government staff identify procedural barriers, outdated requirements, and unnecessary complexity buried in state regulations.
Built with support from the Recoding America Fund.
Warning
This project is under active development and is provided as-is. We are not accepting any new issues or pull requests at this time.
States: NY | NJ | NYC Β· Next.js 16 Β· Python 3.10+ Β· Deployed on Vercel
This repository falls under U.S. Digital Responseβs Code of Conduct, and we will hold all participants in issues, pull requests, discussions, and other spaces related to this project to that Code of Conduct. Please see CODE_OF_CONDUCT.md for the full code.
State administrative codes contain tens of thousands of regulatory sections β many with outdated procedural requirements (fax-only submissions, wet signatures, certified mail mandates) that are invisible at scale. No human team can read 120,000+ sections looking for these problems.
Deproceduralizer applies Jennifer Pahlka's regulatory burden framework through a combination of regex pattern matching and multi-tier LLM verification. It scans regulation text for 49 types of compliance issues, then uses Claude to filter false positives, classify burden severity, and verify findings against source statutes.
The result is an interactive web application where policy reviewers can browse regulations, review AI-identified findings, track triage decisions, and export actionable data β all organized by the regulatory hierarchy they already know.
- Key Capabilities
- Architecture
- Tech Stack
- Getting Started
- Web Application
- Project Structure
- Analysis Pipeline
- Database Schema
- Getting Data
- Development
- Deployment
- Data Coverage
- Data Sources
- Contributing
- License & Copyright
- 49 compliance issue types β wet signatures, mail-only processes, fax requirements, obsolete technology mandates, excessive documentation, and more
- 3-tier research pipeline β regex scan β LLM filtering β LLM classification with optional web search verification
- Barrier burden analysis β single-pass LLM pipeline applying an 18-category framework inspired by Jennifer Pahlka's Recoding America, producing composite burden scores per document
- Tournament filtering β three-round LLM bracket over Barrier findings (importance β fixability β grouping) that surfaces 20β40 actionable recommendations (text edits + structural fixes), powering the
/barriersstrategies page - Fines, fees & penalties extraction β LLM structured extraction of monetary charges (amount, who pays, responsible agency, violation) from regulations and guidance, with post-scan enrichment for activity domain, estimated annual payers, and verbatim justification quotes
- Post-pipeline enrichments β multi-label topic tagging on Barrier findings (50-topic taxonomy), guidance audience classification (direction/expertise/target roles), and other Batch-API enrichments that layer on top of core pipeline output
- Hierarchical summarization β bottom-up summaries from sections through subchapters, chapters, parts, and titles using Anthropic Batch API
- Multi-jurisdiction support β New York State (NYCRR), New Jersey (NJAC), and New York City (RCNY + Charter/Admin Code) with extensible scraper architecture
- Guidance documents β sub-regulatory ADMs, LCMs, INFs, GIS, TSBs imported from the
nys-documentscatalog; a dedicated multi-step pipeline classifies them, detects supersedure chains, extracts cross-references to NYCRR and other guidance, and runs the same compliance scans as formal regulations - Human review workflow β review queues with keyboard navigation, status tracking, priority assignment, and reviewer notes
- Developer mode β implementation tracking, developer assignment, and resolution status for reviewed findings
- IBR detection β identifies external standards incorporated by reference (NFPA, ICC, ASTM, CFR)
- Analytics dashboard β visualizations of compliance issue distribution, severity trends, and pipeline coverage
- Statute mandate checking β verifies whether cited statutes actually mandate flagged requirements (NY)
- Cross-reference extraction β maps internal citations between regulatory documents for contextual analysis
- Saved items & marker groups β save and organize regulations, guidance, fines, and analyses of interest for focused review
Cornell Law Website (Regulations + Statutes)
β
Scraper Scripts (ny/nj_regulations_scraper.py, ny_statutes.py)
β
JSON cache (data/scraped_data/, data/nj_scraped_data/)
β
[Built-in: migrate_regulations_to_db() + refresh_all_stats()]
β
PostgreSQL (Neon)
β
Analysis Pipeline (13 steps β see "Analysis Pipeline" below for the
canonical sequence; plus a separate Guidance Import
pipeline that loads sub-regulatory documents)
β
Next.js Web App (server actions query DB directly via Drizzle)
β
Human Review + Analytics
The Python backend handles scraping and AI analysis, writing results to PostgreSQL. The Next.js frontend reads from the same database via Drizzle ORM server actions β it never calls the Python backend directly.
| Layer | Technology |
|---|---|
| Backend | Python 3.10+, Claude API (Anthropic), psycopg, Pydantic |
| Database | PostgreSQL via Neon, Drizzle ORM |
| Frontend | Next.js 16, React 19, TypeScript, Tailwind CSS 4, Radix UI |
| Visualization | D3, Visx, Nivo |
| Testing | Playwright (E2E smoke tests) |
| Package Manager | pnpm 9+ (workspaces monorepo) |
| Deployment | Vercel |
- Python 3.10+
- Node.js 18+
- pnpm 9+ (
npm install -g pnpm) - PostgreSQL (or Neon cloud database)
- Anthropic API key (for Claude LLM analysis)
# Python dependencies
uv pip install -r backend/requirements.txt
# Node.js dependencies
cd frontend && pnpm installCreate a .env file in the project root (start from .env.example):
DATABASE_URL=postgresql://user:password@host/dbname?sslmode=require
ANTHROPIC_API_KEY=sk-ant-...For the web app, also create frontend/apps/web/.env.local:
DATABASE_URL=postgresql://user:password@host/dbname?sslmode=requireSee DATABASE_SETUP.md for Postgres/Neon setup and migration instructions.
cd frontend/apps/web
pnpm dev --port 3010Open http://localhost:3010 to browse the application immediately (assuming the database is populated).
The full analysis pipeline has 13 steps (plus a separate guidance-import pipeline). For a quick demo on a single title:
# Scrape NY regulations (includes DB migration)
python backend/scripts/ny_regulations_scraper.py
# Scan compliance issues (regex only, free, fast)
python backend/scripts/scan_compliance_issues.py --state nySee docs/OPERATIONS.md for the complete runbook with all steps, flags, cost estimates, and timing.
| Route | Description |
|---|---|
/ |
Dashboard β cross-state overview and summary metrics |
/[state] |
Table View β paginated regulations table with search and filters |
/[state]/browse |
Browse β interactive hierarchy tree browser |
/[state]/search |
Search β full-text search across regulations with filters |
/[state]/definitions |
Glossary β definitions with A-Z filter, list/grouped views |
/[state]/statutes |
Statutes β browse linked state statutes |
/[state]/statutes/[id] |
Statute Detail β individual statute with linked regulations |
/[state]/guidance |
Guidance β sub-regulatory ADMs/LCMs/INFs from state agencies |
/[state]/ibr |
Standards (IBR) β incorporated-by-reference standards browser |
/[state]/fines |
Fines, Fees & Penalties β monetary charges with agency and who-pays breakdowns |
/[state]/barriers |
Barrier Strategies β single-pass burden analysis explorer |
/[state]/burden |
Burden β Barrier 18-category composite burden scores and drill-down |
/[state]/tags |
Tags β cross-domain tag analytics across regulations, guidance, fines, Barrier |
/[state]/review |
Review Mode β queues for compliance issues, definitions |
/[state]/review?mode=developer |
Developer Mode β implementation tracking and assignment |
/[state]/pipeline |
Pipeline β research pipeline status, funnel visualization, drill-downs |
/[state]/saved |
Saved β bookmarked regulations, guidance, fines, and analyses organized by marker group |
/[state]/analytics |
Analytics β compliance issue distribution and severity visualizations |
/[state]/regulations/[id] |
Regulation Detail β full text with analysis, flags, and cross-references |
/prompts |
Prompts β view and provide feedback on LLM prompts |
/onboarding |
Onboarding β first-run walkthrough for new reviewers |
Dashboard β Cross-state summary with key metrics, recent activity, and quick navigation to state-specific views.
Table View β Paginated regulation table with search. Filter by severity, complexity, flags, implementation issues, technical review, and reporting requirements. Sort by max severity, flag count, title, or complexity.
Browse Hierarchy β Interactive tree view of the regulation structure. Expand/collapse nodes, filter by analyzed status, flags, severity, or definitions. Shows descendant counts and max severity at each level.
Glossary β Searchable definitions with A-Z letter filter. List (flat) and Grouped (aggregated terms) view modes. Quality indicators based on overlap scoring, with links to source regulations.
Statutes β Browse state statutes linked to regulations. View which regulatory sections cite each statute and how requirements flow from legislation to administrative code.
Standards (IBR) β Browse external standards incorporated by reference in regulations (NFPA, ICC, ASTM, CFR). Shows which regulations reference each standard.
Review Mode β Separate queues for compliance issues and definitions. Filter by status, severity, category, or issue type. Keyboard navigation (j/k to navigate, n for next unreviewed, v to view regulation). Update items with review status, priority, impact type, notes, and reviewer name. Progress indicators showing review completion.
Developer Mode β Track implementation status of reviewed items. Developer assignment, resolution tracking (Implemented/Not Implemented), and "Need More Info" queue for back-and-forth discussions.
Pipeline β Monitor research pipeline execution with subtabs for different views, a research funnel visualization showing how candidates flow through tiers, and drill-down capabilities for investigating specific issues.
Bookmarks β Save regulations of interest for focused review sessions. Organize and manage saved items.
Analytics β Visualizations of compliance issue distribution across issue types and states, severity breakdowns, and pipeline coverage metrics.
deproceduralizer/
βββ backend/ # Python backend
β βββ config.py # Path configuration
β βββ lib/ # DB, LLM, parsing utilities
β βββ requirements.txt # Python dependencies
β βββ scripts/ # Analysis pipeline scripts
β βββ ny_regulations_scraper.py # NY scraper (includes DB migration)
β βββ nj_regulations_scraper.py # NJ scraper (includes DB migration)
β βββ scan_compliance_issues.py # Regex compliance issue scanner
β βββ batch_definitions.py # Batch definition extraction
β βββ ibr_scanner.py # Incorporation by reference scanner
β βββ fines_scanner.py # Fines/fees/penalties LLM extraction
β βββ enrich_fines_activity.py # Fines activity-category + payer-volume enrichment
β βββ enrich_guidance_audience.py # Guidance audience direction/expertise/role
β βββ classify_topics.py # Barrier 50-topic multi-label tagging
β βββ barrier_tournament.py # 3-round tournament filtering over Barrier findings
β βββ import_tournament_results.py # Load tournament JSON into DB
β βββ research_pipeline/ # 3-tier compliance research pipeline
β βββ barrier_pipeline/ # Single-pass 18-category burden analysis
β βββ guidance_pipeline/ # Guidance import + classify + supersedure + refs
β βββ summarization/ # Hierarchical summarization
β βββ cross_references/ # Internal citation extraction
β βββ ...
β
βββ frontend/ # Next.js monorepo
β βββ pnpm-workspace.yaml # Monorepo config
β βββ apps/
β β βββ web/ # Main web application
β β βββ src/
β β β βββ app/ # Next.js App Router (routes)
β β β βββ components/ # React components
β β β β βββ analytics/ # Analytics visualizations
β β β β βββ browse/ # Hierarchy tree browser
β β β β βββ home/ # Dashboard components
β β β β βββ ibr/ # IBR standards browser
β β β β βββ issues/ # Compliance issues
β β β β βββ review/ # Review queue components
β β β β βββ statutes/ # Statute browser
β β β β βββ ui/ # Shared UI primitives
β β β βββ lib/
β β β βββ actions/ # Server actions (data access)
β β β βββ constants/ # Centralized enums, nav config
β β β βββ url/ # nuqs URL state parsers
β β βββ e2e/ # Playwright smoke tests
β β βββ STYLE_GUIDE.md # Component style guide
β βββ packages/
β βββ database/ # Shared Drizzle ORM package
β βββ src/schema/ # Table definitions
β βββ src/repositories/ # Data access layer
β βββ migrations/ # DDL migrations
β
βββ prompts/ # LLM prompt definitions (YAML)
β βββ core.yaml # Definitions prompts
β βββ compliance_issues.yaml # 49 issue types with patterns
β βββ barriers.yaml # 18-category barrier framework
β βββ research_pipeline.yaml # 3-tier research pipeline prompts
β βββ topic_classification.yaml # Topic taxonomy prompts
β βββ tournament.yaml # Prompt-tournament evaluation
β βββ issue_configs/ # Per-issue-type prompt overrides
β
βββ data/
β βββ db_backup/<UTC-timestamp>/ # Database schema only (schema.sql); no records ship here
β
βββ scripts/
β βββ db-query.sh # Postgres query helpers
β βββ export_db_to_flatfiles.py # DB β JSONL snapshot exporter (for the private archive)
β
βββ docs/
β βββ OPERATIONS.md # Pipeline runbook
β
βββ .claude/ # Claude Code configuration
β βββ skills/ # Domain-specific skill docs
β
βββ DATABASE_SETUP.md # Database setup guide
βββ .env # Environment variables (gitignored)
The full pipeline transforms raw regulation text into structured, reviewable findings.
- Scrape β Fetch regulations from Cornell Law into JSON cache, then migrate to PostgreSQL
- Exclude β Mark non-regulatory sections (executive orders, military code, data tables) to skip in analysis
- Regulatory Status β Detect repealed, reserved, recodified, or expired sections
- Definitions β Extract defined terms using Anthropic Batch API (Haiku)
- Link Definitions β Match definitions to documents where terms appear
- Cross-References β Extract internal citations between regulatory documents
- Summaries β Generate hierarchical summaries (sections β subchapters β chapters β parts β titles)
- Compliance Scan β Regex-only detection of 49 compliance issue types (no LLM, free)
- Research Pipeline β 3-tier LLM analysis: filter false positives β classify burden/severity β web search verification
- IBR Scan β Detect external standards incorporated by reference
- Fines Scan β LLM structured extraction of fines, fees, penalties, surcharges, forfeitures
- Barrier Pipeline β Single-pass LLM analysis applying the 18-category barrier framework
- Refresh Stats β Precompute hierarchy statistics for frontend performance
Dependencies: Cross-References (6) can run anytime after Scrape (1). Summaries (7) and Compliance Scan (8) can run in parallel. Research Pipeline (9) and Barrier Pipeline (12) both depend on Cross-References (6) and Summaries (7). IBR (10) and Fines (11) are independent of the LLM pipelines. Refresh Stats (13) runs last.
Note:
docs/OPERATIONS.mdnumbers these the same way conceptually but labels Exclude as 1b and Fines as 9b (sub-steps grouped with their parent). The runbook is the source of truth for commands and flags.
A standalone multi-step pipeline (python3 -m scripts.guidance_pipeline) loads sub-regulatory documents from the nys-documents catalog and enriches them. Sub-steps:
| Sub-step | Flag | Output |
|---|---|---|
| Import | --execute |
guidance_documents rows (catalog id, canonical ref, content, metadata) |
| Classify | --classify |
policy_category, is_attachment (SQL rules, no LLM) |
| Clean refs | --clean-refs |
normalized canonical_ref values |
| Detect supersedure | --detect-supersedure |
supersedes, superseded_by, revision_of, status |
| Extract content refs | --extract-content-refs |
rows in cross_references from guidance to NYCRR/guidance |
| Regex scan | --regex-scan |
compliance_issues rows attributed to guidance |
| Gap analysis | --gap-analysis |
read-only coverage report by agency/year/doc_type |
Optional downstream enrichments (separate scripts): guidance_summarization (Batch API summaries with cited regulation context), enrich_guidance_audience (audience direction/expertise/target roles), readability metrics. Core sub-steps are free (SQL/regex); LLM enrichments cost ~$1β7 per full corpus.
Workflows that operate on top of the core pipeline output:
- Barrier Tournament (
backend/scripts/barrier_tournament.py) β Three-round LLM bracket (importance β tournament β pattern grouping) over Barrier findings, run as two passes (text edits + structural fixes). Outputs totournament_patterns,tournament_examples, andtournament_named_findingstables; results feed the/[state]/barriersstrategies page. Full run is ~$15 / ~40 min on Haiku 4.5. Import viaimport_tournament_results.py. - Topic Classification (
backend/scripts/classify_topics.py) β Multi-label tagging of Barrier findings against a 50-topic taxonomy. Writes tobarrier_issues.topics(GIN-indexed). Invoked automatically at the tail end of the Barrier pipeline; can also be re-run standalone with--execute. - Fines Activity Enrichment (
backend/scripts/enrich_fines_activity.py) β Classifies fines into 17 activity domains, estimates annual payer volume buckets, and extracts verbatim justification quotes. Updates columns onfines_fees_penalties. - Guidance Audience Enrichment (
backend/scripts/enrich_guidance_audience.py) β Classifies guidance documents by audience direction (public/government), expertise level (lay/specialized/mixed), and target-audience tags. Updates columns onguidance_documents.
Status: PROTOTYPED β A Top-N Burden Memos pipeline that uses headless CLI agents (
claude -p/gemini -p) with web search and DB query tools to generate long-form structured burden-analysis writeups per top-burden document is currently prototyped on branchworktree-shimmering-dancing-umbrella. Thirty manually-validated example memos live indocs/top-30-burden-analysis/on that branch, alongsideMETA-PLAN-automated-burden-analysis.mdwhich proposes JSON output stored in three new tables (burden_analysis_reports,burden_finding_reviews,burden_textual_changes). Not yet merged tomain.
See docs/OPERATIONS.md for the complete runbook with commands, flags, cost estimates, and timing for each step.
| Table | Purpose |
|---|---|
regulatory_documents |
Regulation text, metadata, hierarchy, denormalized stats |
guidance_documents |
Sub-regulatory guidance (ADMs, LCMs, INFs, GIS, TSBs) imported from nys-documents |
agencies |
Canonical agency lookup for deduplicating responsible_agency across pipelines |
definitions |
Extracted defined terms with scope tracking |
definition_document_occurrences |
Links definitions to documents where terms appear |
compliance_issues |
Regex-matched compliance issue candidates (49 types) |
compliance_issue_analyses |
LLM analysis + human review per document/issue type |
barrier_analyses |
Barrier single-pass burden analysis, one row per document |
barrier_issues |
Per-category findings (18 categories) with multi-label topics (50-topic taxonomy), linked to barrier_analyses |
tournament_patterns |
Mega-patterns produced by Barrier tournament filtering (per pass) |
tournament_examples |
Top-5 example findings per tournament pattern |
tournament_named_findings |
Named pass-1 tournament findings ("quick hits") |
fines_fees_penalties |
Structured extraction of monetary charges from regulations and guidance |
statute_references |
Legal citations extracted from regulations (USC, CFR, state) |
regulation_statute_links |
Many-to-many crosswalk between regulations and statutes |
statute_mandate_checks |
Whether cited statutes actually mandate flagged issues |
cross_references |
Internal citations between regulatory documents |
incorporations_by_reference |
External standards referenced in regulations |
See .claude/skills/database/schema.md for complete schema documentation, or frontend/packages/database/src/schema/ for Drizzle definitions.
The app reads everything from Postgres, never from files in this repo. A fresh clone runs, but every page stays empty until you point it at a populated database.
No regulation text, analysis results, or database records ship here. We keep full database snapshots in a private archive.
You have three ways to get data:
- Team members --- point
DATABASE_URLat the existing Neon database. Nothing else changes. - Collaborators with archive access --- restore a full snapshot from the private
deproceduralizer-backuprepository, following the steps in itsDATABASE_SETUP.md. - Everyone else --- create an empty database and build your own data with the pipeline.
- Just want the app running --- start the Docker stack and load the synthetic fixtures (see Local database with Docker). The fixtures are made-up prose, not regulations, but every page and the smoke tests work against them.
To build your own database:
- Create the schema. Load
data/db_backup/2026-05-15T20-22-11Z/schema.sql, or apply the migrations infrontend/packages/database/migrations/. SeeDATABASE_SETUP.md. - Run the scrapers for the jurisdictions you want. Data Sources lists them.
- Run the regex compliance scan, which is free:
python backend/scripts/scan_compliance_issues.py --state ny.
A few limits to know about before you start:
- AI steps cost money --- summarization, the research pipeline, Barrier, and fines extraction all call the Anthropic API. Check the cost estimates in
docs/OPERATIONS.mdfirst. - NY statutes need an API key --- request a free key from the NY Senate Open Legislation API and set
NY_OPEN_LEG_API_KEY. - NYC data needs manual downloads --- the NYC parsers read exports you download yourself from American Legal Publishing.
- Guidance documents need a separate repo --- they come from the
nys-documentsscraping pipeline, which isn't part of this repo. - Smoke tests need data ---
pnpm test:e2echecks for real records, so it fails against an empty database. The synthetic fixtures below are enough.
The app talks to Postgres through Neon's HTTP driver, which can't speak plain TCP. docker-compose.e2e.yml runs postgres:17 plus a local Neon proxy so the unchanged driver works against a local database. scripts/e2e-db-reset.sh loads the schema dump and then seeds deterministic fixtures from frontend/packages/database/seed/.
cd frontend
pnpm db:e2e:up # postgres + neon proxy (set E2E_PG_PORT=55432 first if 5432 is taken)
pnpm db:e2e:reset # schema.sql + synthetic fixtures, about ten secondsThen point the app at it in .env (see .env.example):
DATABASE_URL=postgres://postgres:postgres@localhost:5432/deproceduralizer_e2e
NEON_LOCAL_PROXY_URL=http://localhost:4444
pnpm db:e2e:down removes the containers and their data. This is the same stack GitHub Actions uses for the e2e job, so a green local run means a green CI run.
cd frontend/apps/web
pnpm dev --port 3010 # Start dev server
pnpm build # Production build
pnpm lint # Run ESLint
pnpm test # Run Vitest unit tests
pnpm test:e2e # Run Playwright smoke tests (needs a populated DB, see Getting Data)Running the smoke tests the way CI does, against a production build:
cd frontend/apps/web
pnpm build
E2E_SERVER=start pnpm test:e2e# Run module-based scripts
cd backend
python3 -m scripts.research_pipeline.cli --help
python3 -m scripts.summarization.cli --help
cd scripts && python3 -m cross_references.run_extraction --help && cd ..cd frontend/packages/database
pnpm generate # Drizzle code generation after schema changescd frontend && pnpm typecheck # both workspace packages
# Full build (includes type checking)
cd frontend && pnpm build.github/workflows/ci.yml runs on every pull request and on pushes to main: ESLint, tsc, Vitest, pytest (without the llm and db markers), a ruff syntax check of the backend, and the Playwright smoke suite against the Docker database stack above. Nothing in CI touches Vercel or a shared database.
All LLM prompts live in /prompts/ (YAML). The frontend copies them during build:
# If /prompts page shows "file not found" in dev:
cd frontend/apps/web && pnpm prebuildTypeScript types are auto-generated from YAML:
python scripts/generate_prompt_types.py-
Link your project:
vercel link
-
Add environment variables:
echo 'your-database-url' | vercel env add DATABASE_URL production
-
Deploy via git push (do NOT run
vercel --proddirectly):git push origin main
Vercel auto-deploys from the
mainbranch. You can also push a branch and promote it in the Vercel dashboard.
| Jurisdiction | Regulation Source | Documents | Statute Sources |
|---|---|---|---|
| New York (NY) | NYCRR (23 titles) | ~60,000 sections | NY Consolidated Laws (OpenLegislation API) |
| New Jersey (NJ) | NJAC | ~61,000 documents | NJ Statutes |
| New York City (NYC) | RCNY | sub-state | NYC Charter + Administrative Code |
In addition to the regulatory corpora above, the database holds a guidance documents corpus of ADMs, LCMs, INFs, GIS, TSBs, and similar sub-regulatory directives imported from the nys-documents catalog. Guidance is analyzed by the same downstream pipelines (compliance scan, fines extraction, Barrier burden analysis).
Every scraper reads from a public source, and that source's terms apply to anything you download. This repo ships the code, not the data.
| Data | Source | Script |
|---|---|---|
| NY regulations (NYCRR) | Cornell Legal Information Institute | backend/scripts/ny_regulations_scraper.py |
| NJ regulations (NJAC) | Cornell Legal Information Institute | backend/scripts/nj_regulations_scraper.py |
| NY Consolidated Laws | NY Senate Open Legislation API | backend/scripts/ny_statutes.py |
| NJ statutes | NJ Legislature bulk statutes file | backend/scripts/nj_statutes.py |
| NYC Rules (RCNY) and Health Code | American Legal Publishing, manual export | backend/scripts/rcny_parser.py, backend/scripts/health_code_parser.py |
| NYC Charter and Administrative Code | American Legal Publishing, manual export | backend/scripts/nyc_statutes.py |
| NY agency guidance documents | nys-documents, a separate scraping repo |
backend/scripts/guidance_pipeline/ |
The regulations scrapers identify themselves as deproceduralizer/1.0 and cache every page they fetch, so a rerun doesn't hit the source again. Keep request rates low, and if a site blocks automated access, skip it.
We're not accepting issues or pull requests right now. CONTRIBUTING.md explains how U.S. Digital Response projects take contributions in general.
Key conventions:
- Monorepo β pnpm workspaces with shared
@deproceduralizer/databasepackage - URL state β use
nuqswith predefined parsers fromlib/url/parsers.ts(never rawuseSearchParams) - Data access β server actions in
lib/actions/, always importserver-onlyin database-touching modules - Constants β centralize enums, nav config, and option arrays in
lib/constants/ - Components β follow
STYLE_GUIDE.mdfor patterns and conventions - Testing β run
pnpm test:e2einfrontend/apps/webbefore pushing
References:
frontend/apps/web/STYLE_GUIDE.mdβ component patterns and design systemdocs/OPERATIONS.mdβ pipeline runbook with all commands and costsCLAUDE.mdβ project conventions for AI-assisted development
Copyright 2026 U.S. Digital Response
Copyright 2026 Recoding America
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this software except in compliance with the License. You may obtain a copy of the License at:
LICENSE in this repository or http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
The bundled Inter and JetBrains Mono fonts are under the SIL Open Font License instead. See NOTICE.