diff --git a/docs/STATE_OF_THE_NATION_DATA_SPEC.md b/docs/STATE_OF_THE_NATION_DATA_SPEC.md
new file mode 100644
index 0000000..22da369
--- /dev/null
+++ b/docs/STATE_OF_THE_NATION_DATA_SPEC.md
@@ -0,0 +1,309 @@
+# State of the Nation — new measures spec
+
+york_factory (branch `mikaal/state-of-the-nation-additions`) now serves 34 new
+measures covering employment, wages, business formation, investment, government
+debt, and immigration. This doc is everything the frontend needs to chart them.
+
+All measures are served by the existing endpoint:
+
+```
+GET /api/v1/kpis/series?measure=<slug>
+GET /api/v1/kpis/series?measure=<slug>&from=2000&to=2026
+GET /api/v1/kpis/series?measure=<slug>&jurisdictions=ca
+```
+
+## API change: quarterly series
+
+Until now `points` came in two shapes: annual `{ year, value }` and monthly
+`{ date, value }`. There is now a third measure frequency, `quarterly`, which
+serializes **the same way as monthly**: `{ date, value }`, where `date` is the
+first day of the quarter (`"2026-01-01"` = Q1 2026).
+
+Switch on `data.measure.frequency`:
+
+| `measure.frequency` | point shape | example |
+|---|---|---|
+| `annual` | `{ year, value }` | `{ "year": 2024, "value": 435421 }` |
+| `monthly` | `{ date, value }` | `{ "date": "2026-06-01", "value": 60.8 }` |
+| `quarterly` | `{ date, value }` | `{ "date": "2026-01-01", "value": 20133.0 }` |
+
+If your chart code currently assumes `points[0].date != null` implies monthly
+spacing, update it — quarterly points are 3 months apart. Anything keyed off
+`frequency` rather than point shape needs the new `"quarterly"` value handled.
+
+Everything else is unchanged: `meta.source` carries `name`, `url`,
+`last_fetched_at`, `license`, `attribution`. **Attribution must be displayed**
+for all of these (Statistics Canada Open Licence; IRCC is Open Government
+Licence – Canada) — same treatment as the existing OWID/StatCan charts.
+
+All new series are **Canada-only** (single series, jurisdiction slug `ca`)
+except `capital-formation-pct-gdp`, which has the full G7 + OECD + computed-G7
+jurisdiction set like the other World Bank measures.
+
+There is also a new measure `category` value, `population`, alongside the
+existing `economy` / `welfare` / etc.
+
+---
+
+## 1. Employment by age group
+
+Monthly, seasonally adjusted, percent, 1976→present. Source: StatCan LFS
+table 14-10-0287. All four share unit and frequency, so they work as a
+combined overlay chart.
+
+| slug | series |
+|---|---|
+| `employment-rate-15-plus` | Employment rate, 15 years and over |
+| `employment-rate-15-to-24` | Employment rate, 15–24 |
+| `employment-rate-25-to-54` | Employment rate, 25–54 (core working age) |
+| `employment-rate-55-to-64` | Employment rate, 55–64 |
+
+Note: the existing annual `employment-rate` (World Bank, G7 comparison) is a
+different measure and stays as-is; these are the Canadian monthly detail.
+
+## 2. Private vs public employment
+
+Monthly, seasonally adjusted, **thousands of persons**, 1976→present.
+Source: StatCan LFS table 14-10-0288.
+
+| slug | series |
+|---|---|
+| `employment-all-classes` | Total employed, all classes |
+| `employment-public-sector` | Public sector employees |
+| `employment-private-sector` | Private sector employees |
+| `employment-self-employed` | Self-employed |
+
+**Shares are not stored** — compute client-side, e.g. public share =
+`employment-public-sector / employment-all-classes`. The three components sum
+to the total (within rounding), so a 100%-stacked area chart works.
+
+## 3. Wages
+
+Annual, current dollars per hour, 1997→present. Source: StatCan LFS table
+14-10-0064 (all employees, all industries, full- and part-time).
+
+| slug | series |
+|---|---|
+| `average-hourly-wage` | Average hourly wage rate |
+| `median-hourly-wage` | Median hourly wage rate |
+
+**The requested 10th/90th percentile series do not exist** in StatCan's public
+API — verified against every LFS wage table and the full cube catalog. They
+would require LFS microdata or a custom tabulation. Average vs median is the
+closest available dispersion signal (the gap widening = top-heavy wage growth).
+Copy for this chart should not promise percentiles.
+
+## 4. New business formation
+
+Monthly, seasonally adjusted, counts of businesses, 2015→present. Source:
+StatCan table 33-10-0270 (business sector industries).
+
+| slug | series | higher_is_bad |
+|---|---|---|
+| `business-entrants` | Businesses appearing for the first time (true new-business formation) | false |
+| `business-exits` | Businesses permanently ceasing operations | true |
+| `active-businesses` | Businesses with 1+ employees | false |
+
+Entrants/exits measure genuine business creation and death — unlike the same
+table's "openings/closings", which count any month a business crosses 0↔1+
+employees (including seasonal reopenings). StatCan's dedicated entry/exit
+table (33-10-0165, with entry/exit *rates*) stopped publishing at 2019 Q4, so
+this monthly table is the live source.
+
+Two footnotes for the chart: StatCan labels these **experimental estimates**,
+and **`business-exits` runs ~6 months behind `business-entrants`** (an exit is
+only confirmed once the business stays closed) — expect the exits line to end
+earlier than the entrants line, and don't render the gap as a decline. Net
+formation (entrants − exits) can be derived client-side where both months
+exist.
+
+## 5. Investment flows (FDI)
+
+Quarterly, millions of CAD (total net flows), 2007→present. Source: StatCan
+table 36-10-0025 (balance of payments).
+
+| slug | series |
+|---|---|
+| `fdi-inflows` | Foreign direct investment **into** Canada |
+| `fdi-outflows` | Canadian direct investment **abroad** |
+
+These are flows, not stocks; values can be negative in principle
+(disinvestment). "Outflows" is not bad per se — it's Canadian firms investing
+abroad — so avoid red/green framing.
+
+## 6. Capital formation
+
+| slug | frequency | unit | coverage |
+|---|---|---|---|
+| `gross-fixed-capital-formation` | quarterly | chained 2017 $M, SAAR | Canada, 1961→ |
+| `business-gross-fixed-capital-formation` | quarterly | chained 2017 $M, SAAR | Canada, 1961→ |
+| `capital-formation-pct-gdp` | annual | % of GDP | **G7 comparison** (World Bank) |
+
+The two StatCan series are levels (seasonally adjusted at annual rates); the
+World Bank one is the cross-country comparison chart. Reasonable layout:
+featured chart = `capital-formation-pct-gdp` (Canada vs G7), detail charts =
+the quarterly Canadian levels.
+
+## 7. Government debt-to-GDP (all levels)
+
+Quarterly, percent of GDP, 1990→present, `higher_is_bad: true`. Source:
+StatCan table 38-10-0237 — general government consolidated: federal +
+provincial/territorial + local + CPP/QPP, national balance sheet accounts
+basis.
+
+| slug | series | latest (Q1 2026) |
+|---|---|---|
+| `govt-gross-debt-to-gdp` | Gross debt to GDP | ~132% |
+| `govt-net-debt-to-gdp` | Net financial liabilities to GDP | ~21% |
+
+The gross/net gap is large because net subtracts financial assets (including
+CPP/QPP assets). Show both or label carefully — "net" here is much lower than
+the federal-budget "net debt" figures people know from the news, because of
+the NBSA market-value methodology. Don't average or mix them.
+
+## 8. Immigration & population (new `population` category)
+
+### Components of population growth — annual, persons, 1971→present
+
+Source: StatCan table 17-10-0008. **Reference years run July 1–June 30**: the
+point `year: 2024` covers July 2023–June 2024. Label as "July–June year" or
+"demographic year" to avoid mismatch with calendar-year IRCC numbers.
+
+| slug | series |
+|---|---|
+| `immigrants-annual` | Immigrants (PR admissions) |
+| `emigrants-annual` | Emigrants |
+| `returning-emigrants-annual` | Returning emigrants |
+| `net-non-permanent-residents-annual` | Net change in non-permanent residents (can be negative) |
+
+**Net emigration is derived client-side** as
+`emigrants-annual − returning-emigrants-annual`. (StatCan's own "net temporary
+emigration" series died in a 2016 methodology change and is not served.)
+
+### Non-permanent residents by type — quarterly, persons, 2021 Q3→present
+
+Source: StatCan table 17-10-0121. These are **stocks** (how many people, as of
+the first day of the quarter), not flows. Short history — charts will only
+have ~20 points; suppress any "20-year trend" framing.
+
+| slug | series |
+|---|---|
+| `npr-total` | All non-permanent residents |
+| `npr-asylum-claimants` | Asylum claimants, protected persons and related |
+| `npr-work-permit-holders` | Work permit holders only — **closest proxy for "temporary foreign workers"** |
+| `npr-study-permit-holders` | Study permit holders only |
+| `npr-work-and-study-permit-holders` | Holding both permits |
+
+There is no series literally called "temporary foreign workers" (the TFWP/IMP
+program split isn't in StatCan tables); if the chart is titled "Temporary
+foreign workers", footnote that it shows work-permit holders.
+
+### PR admissions by immigration class — monthly, persons, 2015→present
+
+Source: IRCC Permanent Residents Monthly Updates (~2-month publication lag).
+
+| slug | series |
+|---|---|
+| `pr-admissions-total` | All categories |
+| `pr-admissions-economic` | Economic (worker programs, PNP, business, TR-to-PR) |
+| `pr-admissions-family` | Sponsored family |
+| `pr-admissions-refugee` | Resettled refugees & protected persons |
+| `pr-admissions-other` | Humanitarian & compassionate, public policy, permit holders |
+
+The four categories stack to the total → good stacked-area candidate.
+**Data caveat for the footnote:** IRCC suppresses cells under 6 and rounds
+everything to the nearest 5, so values are approximate and won't exactly match
+StatCan's `immigrants-annual` (which also uses July–June years). "Student" is
+not a PR class — students appear in `npr-study-permit-holders` above.
+
+---
+
+## History coverage & matched chart windows
+
+Every series is served at its **full published history** — nothing is
+truncated on the backend. The series cannot all start at the same date
+because the underlying StatCan programs began at different times, so
+matching happens client-side with the `from=` parameter. Confirmed coverage
+(first data point, verified against loaded data):
+
+| starts | series |
+|---|---|
+| 1961 | capital formation (both StatCan levels and World Bank % of GDP) |
+| 1971 | population components (immigrants, emigrants, returning, net NPR) |
+| 1976 | employment rates by age; employment by class of worker |
+| 1990 | debt-to-GDP (gross and net) |
+| 1997 | average/median hourly wage |
+| 2007 | FDI inflows/outflows |
+| 2015 | business entrants/exits/active; PR admissions by category |
+| 2021 Q3 | non-permanent residents by type |
+
+Recommended convention for visual consistency:
+
+- **Default window: `from=1990`** — 5 of 8 dataset families cover it fully,
+  and it spans a full generation. Use it wherever the section's series reach
+  that far (employment, wages from 1997, capital formation, debt, population
+  components).
+- Series that physically can't reach 1990 (FDI, business dynamics, PR
+  admissions, NPR) should render their full history and state the start year
+  in the chart subtitle (e.g. "since 2015") rather than pad empty space.
+- Within a combined/overlay chart, clip all series to the **latest common
+  start** so lines begin together.
+
+## Suggested section mapping
+
+Against the existing `SECTIONS` ids in
+`src/app/prosperity-dashboard/indicators.ts`:
+
+- `economy` → business formation (3), FDI (2), capital formation (3),
+  debt-to-GDP (2)
+- `welfare` → employment by age (4), class of worker (4), wages (2)
+- **new section** (suggest `id: "population"`, title "Population &
+  Immigration") → components (4), NPR (5), PR admissions (5)
+
+Combined-overlay candidates (same unit + frequency within group): employment
+rates by age; class-of-worker levels; NPR types; PR admission categories;
+gross vs net debt-to-GDP; average vs median wage; entrants vs exits.
+
+## Quick reference — all 34 slugs
+
+```
+employment-rate-15-plus            monthly    %
+employment-rate-15-to-24           monthly    %
+employment-rate-25-to-54           monthly    %
+employment-rate-55-to-64           monthly    %
+employment-all-classes             monthly    thousands
+employment-public-sector           monthly    thousands
+employment-private-sector          monthly    thousands
+employment-self-employed           monthly    thousands
+average-hourly-wage                annual     $/hour
+median-hourly-wage                 annual     $/hour
+business-entrants                  monthly    count
+business-exits                     monthly    count (lags ~6 months)
+active-businesses                  monthly    count
+fdi-inflows                        quarterly  $M
+fdi-outflows                       quarterly  $M
+gross-fixed-capital-formation      quarterly  $M (chained 2017, SAAR)
+business-gross-fixed-capital-formation  quarterly  $M (chained 2017, SAAR)
+capital-formation-pct-gdp          annual     % of GDP (G7 comparison)
+govt-gross-debt-to-gdp             quarterly  %
+govt-net-debt-to-gdp               quarterly  %
+immigrants-annual                  annual     persons (July–June year)
+emigrants-annual                   annual     persons (July–June year)
+returning-emigrants-annual         annual     persons (July–June year)
+net-non-permanent-residents-annual annual     persons (July–June year)
+npr-total                          quarterly  persons (stock)
+npr-asylum-claimants               quarterly  persons (stock)
+npr-work-permit-holders            quarterly  persons (stock)
+npr-study-permit-holders           quarterly  persons (stock)
+npr-work-and-study-permit-holders  quarterly  persons (stock)
+pr-admissions-total                monthly    persons
+pr-admissions-economic             monthly    persons
+pr-admissions-family               monthly    persons
+pr-admissions-refugee              monthly    persons
+pr-admissions-other                monthly    persons
+```
+
+To develop against this locally: run york_factory (`bin/rails server`), point
+`YORK_FACTORY_API_URL=http://localhost:3000/api/v1` in `.env.local`, and the
+data is already loaded. Example:
+`curl "http://localhost:3000/api/v1/kpis/series?measure=pr-admissions-economic"`.
diff --git a/next.config.ts b/next.config.ts
index 64ec06a..1a0a862 100644
--- a/next.config.ts
+++ b/next.config.ts
@@ -30,14 +30,26 @@ const nextConfig: NextConfig = {
         destination: "/builders/:slug",
         permanent: true,
       },
+      // Both prior names of the State of the Nation dashboard redirect
+      // straight to the current route (no chained hops).
       {
         source: "/economic-indicators",
-        destination: "/prosperity-dashboard",
+        destination: "/state-of-the-nation",
         permanent: true,
       },
       {
         source: "/economic-indicators/:path*",
-        destination: "/prosperity-dashboard/:path*",
+        destination: "/state-of-the-nation/:path*",
+        permanent: true,
+      },
+      {
+        source: "/prosperity-dashboard",
+        destination: "/state-of-the-nation",
+        permanent: true,
+      },
+      {
+        source: "/prosperity-dashboard/:path*",
+        destination: "/state-of-the-nation/:path*",
         permanent: true,
       },
     ];
diff --git a/src/app/api/economy/series/route.ts b/src/app/api/economy/series/route.ts
index 30fec77..e27659a 100644
--- a/src/app/api/economy/series/route.ts
+++ b/src/app/api/economy/series/route.ts
@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getEconomicSeries } from "@/lib/api/economy";
-import { MEASURE_SLUGS } from "@/app/prosperity-dashboard/indicators";
+import { MEASURE_SLUGS } from "@/app/state-of-the-nation/indicators";
 
 // Same-origin proxy for york_factory's public series endpoint so client
 // components (the canvas page) can fetch without cross-origin config. The
diff --git a/src/app/prosperity-dashboard/page.tsx b/src/app/prosperity-dashboard/page.tsx
deleted file mode 100644
index a1fd4b0..0000000
--- a/src/app/prosperity-dashboard/page.tsx
+++ /dev/null
@@ -1,124 +0,0 @@
-import type { Metadata } from "next";
-import Link from "next/link";
-import { getSiteConfig } from "@/lib/api";
-import { getEconomicSeries } from "@/lib/api/economy";
-import { PageHeader } from "@/components/ui/page-header";
-import { buildGraph } from "@/lib/schemas/graph";
-import { generateOrganizationSchema } from "@/lib/schemas/generators/organization";
-import { generateBreadcrumbSchema } from "@/lib/schemas/generators/breadcrumb";
-import SectionNav from "./SectionNav";
-import SectionSparkline from "./SectionSparkline";
-import { SECTIONS } from "./indicators";
-
-const DESCRIPTION =
-  "Are we moving in the right direction? Canada's growth, incomes, housing, safety, and wellbeing, measured against the G7 and OECD.";
-
-export const metadata: Metadata = {
-  title: "Prosperity Dashboard",
-  description: DESCRIPTION,
-  alternates: { canonical: "/prosperity-dashboard" },
-  openGraph: {
-    title: "Prosperity Dashboard",
-    description: DESCRIPTION,
-    type: "website",
-  },
-  twitter: {
-    card: "summary_large_image",
-    title: "Prosperity Dashboard",
-  },
-};
-
-export default async function ProsperityDashboardPage() {
-  const configData = getSiteConfig();
-
-  const featuredSeries = await Promise.all(
-    SECTIONS.map((section) =>
-      getEconomicSeries(section.featuredSlug).catch(() => null),
-    ),
-  );
-
-  const jsonLd = buildGraph(
-    generateOrganizationSchema(configData),
-    generateBreadcrumbSchema(
-      "/prosperity-dashboard",
-      "Prosperity Dashboard",
-      configData.siteUrl,
-    ),
-  );
-
-  return (
-    <div className="mx-[10px] my-[10px] border border-border-light bg-bg overflow-x-clip">
-      <script
-        type="application/ld+json"
-        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
-      />
-      <PageHeader
-        title="Prosperity Dashboard"
-      />
-
-      <SectionNav />
-
-      <section className="px-5 py-12">
-        <div className="max-w-[1080px] mx-auto">
-
-
-          <div className="grid gap-5 sm:grid-cols-2">
-            {SECTIONS.map((section, i) => {
-              const preview = featuredSeries[i];
-              const featuredHeading = section.indicators.find(
-                (indicator) => indicator.slug === section.featuredSlug,
-              )?.heading;
-              return (
-                <Link
-                  key={section.id}
-                  href={`/prosperity-dashboard/${section.id}`}
-                  className="group flex flex-col border border-border-light p-6 hover:border-dark transition-colors"
-                >
-                  <h2 className="type-h4 text-dark group-hover:underline underline-offset-4">
-                    {section.title}
-                  </h2>
-                  {preview && (
-                    <div className="mt-5">
-                      <p className="type-label-sm text-dark/50">
-                        {featuredHeading}
-                      </p>
-                      <div className="mt-2">
-                        <SectionSparkline response={preview} />
-                      </div>
-                    </div>
-                  )}
-                  <p className="mt-4 type-label-sm text-dark/50">
-                    {section.indicators.map((i) => i.heading).join(" · ")}
-                  </p>
-                  <span className="mt-auto pt-4 type-label text-dark/70 group-hover:text-dark">
-                    View {section.indicators.length}{" "}
-                    {section.indicators.length === 1 ? "chart" : "charts"}{" "}
-                    &rarr;
-                  </span>
-                </Link>
-              );
-            })}
-
-          </div>
-
-          <div className="mt-16 border-t border-border-light pt-12 text-center">
-            <h2 className="type-h3 text-dark">
-              Missing a measure that matters?
-            </h2>
-            <p className="mt-2 type-body text-dark/70 max-w-[560px] mx-auto">
-              We&rsquo;re expanding this dashboard. If there&rsquo;s an
-              indicator that would sharpen the picture — for better or worse
-              — tell us and we&rsquo;ll track it.
-            </p>
-            <a
-              href="mailto:hi@buildcanada.com?subject=Prosperity%20dashboard%20indicator%20request"
-              className="mt-6 inline-block border border-dark px-5 py-2.5 type-label text-dark hover:bg-dark hover:text-bg transition-colors"
-            >
-              Email us
-            </a>
-          </div>
-        </div>
-      </section>
-    </div>
-  );
-}
diff --git a/src/app/sitemap.ts b/src/app/sitemap.ts
index 21887af..e3ab732 100644
--- a/src/app/sitemap.ts
+++ b/src/app/sitemap.ts
@@ -8,7 +8,7 @@ import type {
 import { getBillsFromCivicsProject } from "@/app/bills/server/get-all-bills-from-civics-project";
 import { getAllBillsFromDB } from "@/app/bills/server/get-all-bills-from-db";
 import { buildAbsoluteUrl } from "@/app/bills/utils/basePath";
-import { SECTIONS as ECONOMIC_SECTIONS } from "@/app/prosperity-dashboard/indicators";
+import { SECTIONS as ECONOMIC_SECTIONS } from "@/app/state-of-the-nation/indicators";
 
 function toValidDate(value?: Date | string): Date | undefined {
   if (!value) return undefined;
@@ -24,14 +24,14 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
     { url: `${baseUrl}/memos`, lastModified: new Date(), changeFrequency: "daily", priority: 0.9 },
     { url: `${baseUrl}/posts`, lastModified: new Date(), changeFrequency: "daily", priority: 0.8 },
     { url: `${baseUrl}/projects`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.8 },
-    { url: `${baseUrl}/prosperity-dashboard`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.7 },
+    { url: `${baseUrl}/state-of-the-nation`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.7 },
     ...ECONOMIC_SECTIONS.map((section) => ({
-      url: `${baseUrl}/prosperity-dashboard/${section.id}`,
+      url: `${baseUrl}/state-of-the-nation/${section.id}`,
       lastModified: new Date(),
       changeFrequency: "weekly" as const,
       priority: 0.6,
     })),
-    { url: `${baseUrl}/prosperity-dashboard/canvas`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.5 },
+    { url: `${baseUrl}/state-of-the-nation/canvas`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.5 },
     { url: `${baseUrl}/tracker`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.8 },
     { url: `${baseUrl}/tracker/commitments`, lastModified: new Date(), changeFrequency: "weekly", priority: 0.7 },
     { url: `${baseUrl}/tracker/faq`, lastModified: new Date(), changeFrequency: "monthly", priority: 0.4 },
diff --git a/src/app/prosperity-dashboard/CombinedSectionChart.tsx b/src/app/state-of-the-nation/CombinedSectionChart.tsx
similarity index 92%
rename from src/app/prosperity-dashboard/CombinedSectionChart.tsx
rename to src/app/state-of-the-nation/CombinedSectionChart.tsx
index 4967d8a..eab392d 100644
--- a/src/app/prosperity-dashboard/CombinedSectionChart.tsx
+++ b/src/app/state-of-the-nation/CombinedSectionChart.tsx
@@ -41,7 +41,9 @@ function buildGrapherState(
 ): GrapherState | null {
   const first = items[0]?.response;
   if (!first) return null;
-  const monthly = first.data.measure.frequency === "monthly";
+  // Monthly and quarterly points both carry ISO dates and use Grapher's
+  // day-based time axis; annual points stay on integer years.
+  const dated = first.data.measure.frequency !== "annual";
   const { source } = first.meta;
 
   const itemSeries = items.map(
@@ -54,7 +56,7 @@ function buildGrapherState(
     const series = itemSeries[idx];
     if (!series) return [];
     return series.points.map((p) => ({
-      year: monthly && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
+      year: dated && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
       entity: { id: idx + 1, code: item.label, name: item.label },
       value: p.value,
     }));
@@ -74,7 +76,7 @@ function buildGrapherState(
     };
     data.push(
       ...longest.points.map((p) => ({
-        year: monthly && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
+        year: dated && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
         entity,
         value: benchmarkValue(benchmark, p.year),
       })),
@@ -89,7 +91,7 @@ function buildGrapherState(
     display: {
       name: heading,
       ...displayUnit(first.data.measure.unit),
-      ...(monthly ? { yearIsDay: true } : {}),
+      ...(dated ? { yearIsDay: true } : {}),
     },
     origins: source
       ? [
diff --git a/src/app/prosperity-dashboard/CombinedSectionChartClient.tsx b/src/app/state-of-the-nation/CombinedSectionChartClient.tsx
similarity index 100%
rename from src/app/prosperity-dashboard/CombinedSectionChartClient.tsx
rename to src/app/state-of-the-nation/CombinedSectionChartClient.tsx
diff --git a/src/app/state-of-the-nation/DashboardNav.tsx b/src/app/state-of-the-nation/DashboardNav.tsx
new file mode 100644
index 0000000..430b732
--- /dev/null
+++ b/src/app/state-of-the-nation/DashboardNav.tsx
@@ -0,0 +1,24 @@
+import { DASHBOARD_SECTIONS } from "./dashboard";
+
+// Anchor nav for the single-page dashboard. Sits below the global navbar
+// (~70px) in the sticky stack, mirroring SectionNav on the subpages.
+export default function DashboardNav() {
+  return (
+    <nav
+      aria-label="Dashboard sections"
+      className="sticky top-[70px] z-40 border-b border-border-light bg-bg px-5 py-3"
+    >
+      <div className="max-w-[1080px] mx-auto flex flex-wrap gap-x-6 gap-y-1 overflow-x-auto [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
+        {DASHBOARD_SECTIONS.map((section) => (
+          <a
+            key={section.id}
+            href={`#${section.id}`}
+            className="type-label text-dark/60 hover:text-dark underline-offset-4 hover:underline whitespace-nowrap"
+          >
+            {section.title}
+          </a>
+        ))}
+      </div>
+    </nav>
+  );
+}
diff --git a/src/app/prosperity-dashboard/IndicatorChart.tsx b/src/app/state-of-the-nation/IndicatorChart.tsx
similarity index 93%
rename from src/app/prosperity-dashboard/IndicatorChart.tsx
rename to src/app/state-of-the-nation/IndicatorChart.tsx
index c491fb7..e8beb5f 100644
--- a/src/app/prosperity-dashboard/IndicatorChart.tsx
+++ b/src/app/state-of-the-nation/IndicatorChart.tsx
@@ -54,11 +54,13 @@ function buildGrapherState(
 ): GrapherState | null {
   const { measure, series } = response.data;
   const { source } = response.meta;
-  const monthly = measure.frequency === "monthly";
+  // Monthly and quarterly points both carry ISO dates and use Grapher's
+  // day-based time axis; annual points stay on integer years.
+  const dated = measure.frequency !== "annual";
 
   const data = series.flatMap((s, idx) =>
     s.points.map((p) => ({
-      year: monthly && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
+      year: dated && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
       entity: { id: idx + 1, code: s.jurisdiction.code, name: s.jurisdiction.name },
       value: p.value,
     })),
@@ -78,7 +80,7 @@ function buildGrapherState(
     };
     data.push(
       ...longest.points.map((p) => ({
-        year: monthly && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
+        year: dated && p.date ? daysSinceGrapherEpoch(p.date) : p.year,
         entity,
         value: benchmarkValue(benchmark, p.year),
       })),
@@ -93,7 +95,7 @@ function buildGrapherState(
     display: {
       name: measure.name,
       ...displayUnit(measure.unit),
-      ...(monthly ? { yearIsDay: true } : {}),
+      ...(dated ? { yearIsDay: true } : {}),
     },
     origins: source
       ? [
diff --git a/src/app/prosperity-dashboard/IndicatorChartClient.tsx b/src/app/state-of-the-nation/IndicatorChartClient.tsx
similarity index 100%
rename from src/app/prosperity-dashboard/IndicatorChartClient.tsx
rename to src/app/state-of-the-nation/IndicatorChartClient.tsx
diff --git a/src/app/prosperity-dashboard/SectionNav.tsx b/src/app/state-of-the-nation/SectionNav.tsx
similarity index 93%
rename from src/app/prosperity-dashboard/SectionNav.tsx
rename to src/app/state-of-the-nation/SectionNav.tsx
index 547ae1a..33bb266 100644
--- a/src/app/prosperity-dashboard/SectionNav.tsx
+++ b/src/app/state-of-the-nation/SectionNav.tsx
@@ -10,7 +10,7 @@ export default function SectionNav({ currentId }: { currentId?: string }) {
     >
       <div className="max-w-[1080px] mx-auto flex flex-wrap gap-x-6 gap-y-1 overflow-x-auto [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
         <Link
-          href="/prosperity-dashboard"
+          href="/state-of-the-nation"
           aria-current={currentId === undefined ? "page" : undefined}
           className={
             currentId === undefined
@@ -25,7 +25,7 @@ export default function SectionNav({ currentId }: { currentId?: string }) {
           return (
             <Link
               key={section.id}
-              href={`/prosperity-dashboard/${section.id}`}
+              href={`/state-of-the-nation/${section.id}`}
               aria-current={isActive ? "page" : undefined}
               className={
                 isActive
diff --git a/src/app/prosperity-dashboard/SectionSparkline.tsx b/src/app/state-of-the-nation/SectionSparkline.tsx
similarity index 100%
rename from src/app/prosperity-dashboard/SectionSparkline.tsx
rename to src/app/state-of-the-nation/SectionSparkline.tsx
diff --git a/src/app/state-of-the-nation/SourceLine.tsx b/src/app/state-of-the-nation/SourceLine.tsx
new file mode 100644
index 0000000..1634000
--- /dev/null
+++ b/src/app/state-of-the-nation/SourceLine.tsx
@@ -0,0 +1,43 @@
+import {
+  humanizeSourceName,
+  humanizeSourceUrl,
+  type EconomySeriesResponse,
+} from "@/lib/api/economy";
+
+function formatFetchedDate(iso: string): string {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return "";
+  return new Intl.DateTimeFormat("en-CA", { dateStyle: "long" }).format(date);
+}
+
+export default function SourceLine({
+  response,
+}: {
+  response: EconomySeriesResponse;
+}) {
+  const source = response.meta.source;
+  if (!source) return null;
+  const updated = source.last_fetched_at
+    ? formatFetchedDate(source.last_fetched_at)
+    : "";
+  const sourceName = humanizeSourceName(source.name);
+  const sourceUrl = humanizeSourceUrl(source.name, source.url);
+  return (
+    <p className="mt-3 type-label-sm text-dark/60">
+      Source:{" "}
+      {sourceUrl ? (
+        <a
+          href={sourceUrl}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="underline hover:text-dark"
+        >
+          {sourceName}
+        </a>
+      ) : (
+        sourceName
+      )}
+      {updated && <> &middot; Updated {updated}</>}
+    </p>
+  );
+}
diff --git a/src/app/state-of-the-nation/StateChart.tsx b/src/app/state-of-the-nation/StateChart.tsx
new file mode 100644
index 0000000..a818c88
--- /dev/null
+++ b/src/app/state-of-the-nation/StateChart.tsx
@@ -0,0 +1,419 @@
+// SVG charts for the State of the Nation page — a direct translation of the
+// claude.ai/design "State of the Nation.dc.html" line and bar charts.
+// Server-rendered, no client JS. The warm greys (#E3D9CE grid, #6f6a63
+// labels) are the design's own values and have no site token; ink and
+// auburn map to the site palette.
+
+export type ChartFmt =
+  | "money"
+  | "pct"
+  | "pct1"
+  | "x"
+  | "index"
+  | "count"
+  | "num";
+
+// au = brand accent for the headline series; ink = comparison (usually
+// dashed); clay/stone/sand = warm muted tones for additional series.
+export type SeriesColor = "au" | "ink" | "clay" | "stone" | "sand";
+
+export type LegendItem = { label: string; color: SeriesColor; dash?: boolean };
+
+export type LineSpec = {
+  kind: "line";
+  unit: string;
+  fmt: ChartFmt;
+  // Time domain in fractional years. Every chart on the page passes the same
+  // domain, so a given horizontal position means the same date on every
+  // graph; series that begin later simply start partway in.
+  xDomain: [number, number];
+  // Tick labels for the left edge, middle, and right edge of the domain.
+  xLabels: [string, string, string];
+  // Optional explicit x-axis tick years (e.g. decade marks). When present they
+  // replace the start/mid/end labels and sit at their true date on the axis.
+  xTicks?: number[];
+  // When set, the y axis frames the data around this reference value instead
+  // of anchoring at zero, and a floating horizontal rule is drawn at it. Used
+  // by indexed series (e.g. 100 = base year) where zero carries no meaning.
+  baseline?: number;
+  legend?: LegendItem[];
+  // xs holds each point's fractional year, parallel to points.
+  series: {
+    color: SeriesColor;
+    dash?: boolean;
+    xs: number[];
+    points: number[];
+  }[];
+};
+
+export type BarSpec = {
+  kind: "bar";
+  unit: string;
+  fmt: ChartFmt;
+  bars: { label: string; value: number; accent?: boolean }[];
+};
+
+export type ChartSpec = LineSpec | BarSpec;
+
+const INK = "var(--color-dark)";
+const AU = "var(--color-auburn-800)";
+const GRID = "#E3D9CE";
+const GRAY = "#6f6a63";
+const MONO = "var(--font-label)";
+
+const SERIES_COLORS: Record<SeriesColor, string> = {
+  au: AU,
+  ink: INK,
+  clay: "#c2724d",
+  stone: "#8a8178",
+  sand: "#c7bdb2",
+};
+
+function fmt(v: number, f: ChartFmt): string {
+  if (f === "money") return "$" + Math.round(v).toLocaleString("en-CA");
+  if (f === "pct") return Math.round(v) + "%";
+  if (f === "pct1") return v.toFixed(1) + "%";
+  if (f === "x") return v.toFixed(1) + "×";
+  if (f === "index") return String(Math.round(v));
+  if (f === "num")
+    return v.toLocaleString("en-CA", { maximumFractionDigits: 1 });
+  return Math.round(v).toLocaleString("en-CA");
+}
+
+// A round-number step (1, 2, 2.5, 5, ×10ⁿ) closest to the raw interval, so
+// axis labels land on clean values.
+function niceStep(raw: number): number {
+  const mag = Math.pow(10, Math.floor(Math.log10(raw)));
+  const norm = raw / mag;
+  const nice = norm <= 1 ? 1 : norm <= 2 ? 2 : norm <= 2.5 ? 2.5 : norm <= 5 ? 5 : 10;
+  return nice * mag;
+}
+
+// Builds the tick array for a snapped [mn, mx] range. The 0.001·step slack
+// absorbs floating-point drift so the top tick isn't dropped or doubled.
+function buildTicks(mn: number, mx: number, step: number): number[] {
+  const ticks: number[] = [];
+  for (let v = mn; v <= mx + step * 0.001; v += step) {
+    ticks.push(Math.abs(v) < step * 1e-9 ? 0 : v);
+  }
+  return ticks;
+}
+
+// Chooses the y-axis range and round tick values.
+// - Default: anchored at zero, so every line reads as a magnitude from zero
+//   and the charts are comparable (extends below zero only for negative data).
+// - With a `baseline` (e.g. an index's 100): frames the data around that
+//   reference instead — zero carries no meaning for an indexed series — while
+//   guaranteeing the baseline itself stays on the chart.
+function niceAxis(
+  dataMin: number,
+  dataMax: number,
+  baseline?: number,
+): { mn: number; mx: number; ticks: number[] } {
+  if (baseline !== undefined) {
+    let lo = Math.min(dataMin, baseline);
+    let hi = Math.max(dataMax, baseline);
+    if (hi === lo) {
+      lo -= 1;
+      hi += 1;
+    }
+    const span = hi - lo;
+    lo -= span * 0.08;
+    hi += span * 0.08;
+    const step = niceStep((hi - lo) / 4);
+    const mn = Math.floor(lo / step) * step;
+    const mx = Math.ceil(hi / step) * step;
+    return { mn, mx, ticks: buildTicks(mn, mx, step) };
+  }
+  // Start from zero on both ends, then open whichever side the data occupies.
+  let lo = Math.min(0, dataMin);
+  let hi = Math.max(0, dataMax);
+  if (hi === lo) hi += 1;
+  const span = hi - lo;
+  // Pad only away from zero; the zero side stays pinned to the axis.
+  if (hi > 0) hi += span * 0.08;
+  if (lo < 0) lo -= span * 0.08;
+  const step = niceStep((hi - lo) / 4);
+  // Zero stays exactly on a gridline: the positive side ceils to a round tick,
+  // the negative side (if any) floors to one.
+  const mn = lo < 0 ? Math.floor(lo / step) * step : 0;
+  const mx = hi > 0 ? Math.ceil(hi / step) * step : 0;
+  return { mn, mx, ticks: buildTicks(mn, mx, step) };
+}
+
+function LineChart({ spec, wide }: { spec: LineSpec; wide?: boolean }) {
+  // Full-width (wide) charts get a panoramic viewBox so the SVG renders at
+  // roughly 1:1 scale instead of stretching the half-column geometry — which
+  // blew the type and strokes up ~2× on desktop.
+  const W = wide ? 1240 : 600,
+    H = wide ? 420 : 320,
+    L = 8,
+    R = 62,
+    T = 30,
+    B = 46;
+  const iw = W - L - R,
+    ih = H - T - B;
+  const all = spec.series.flatMap((s) => s.points);
+  const { mn, mx, ticks } = niceAxis(
+    Math.min(...all),
+    Math.max(...all),
+    spec.baseline,
+  );
+  const [d0, d1] = spec.xDomain;
+  const X = (x: number) => L + iw * ((x - d0) / (d1 - d0));
+  const Y = (v: number) => T + ih * (1 - (v - mn) / (mx - mn));
+  // The emphasized horizontal rule: the declared baseline (e.g. an index's
+  // 100) when present, otherwise the zero axis. Area fills close here.
+  const refVal = spec.baseline ?? 0;
+  const refOnAxis = refVal >= mn - 1e-9 && refVal <= mx + 1e-9;
+  // Drawn as a floating line only when it sits inside the range and isn't
+  // already one of the round ticks (which carry the ink weight themselves).
+  const refOnTick = ticks.some((t) => Math.abs(t - refVal) < 1e-9);
+  const showFloatingRef =
+    refOnAxis && !refOnTick && refVal > mn + 1e-9 && refVal < mx - 1e-9;
+  const baseY = Y(refOnAxis ? refVal : mn);
+  // Ticks sit at the domain edges and middle — identical across charts.
+  const tickX = [L, L + iw / 2, L + iw];
+
+  return (
+    <svg
+      viewBox={`0 0 ${W} ${H}`}
+      width="100%"
+      style={{ display: "block", overflow: "visible" }}
+      preserveAspectRatio="xMidYMid meet"
+    >
+      {ticks.map((tv) => {
+        const gy = Y(tv);
+        // The reference line (baseline, or zero by default) carries the ink
+        // weight; every other tick is a light gridline.
+        const isRef = Math.abs(tv - refVal) < 1e-9;
+        return (
+          <g key={tv}>
+            <line
+              x1={L}
+              y1={gy}
+              x2={L + iw}
+              y2={gy}
+              stroke={isRef ? INK : GRID}
+              strokeWidth={isRef ? 1.5 : 1}
+            />
+            <text
+              x={L + iw + 8}
+              y={gy + 4}
+              fontFamily={MONO}
+              fontSize={11}
+              fill={GRAY}
+            >
+              {fmt(tv, spec.fmt)}
+            </text>
+          </g>
+        );
+      })}
+      {showFloatingRef && (
+        <line
+          x1={L}
+          y1={Y(refVal)}
+          x2={L + iw}
+          y2={Y(refVal)}
+          stroke={INK}
+          strokeWidth={1}
+        />
+      )}
+      {spec.xTicks
+        ? spec.xTicks.map((t) => {
+            const [d0, d1] = spec.xDomain;
+            // Keep a tick that lands on the domain edge from spilling past it.
+            const anchor =
+              t <= d0 ? "start" : t >= d1 ? "end" : "middle";
+            return (
+              <text
+                key={t}
+                x={X(t)}
+                y={H - 16}
+                fontFamily={MONO}
+                fontSize={11}
+                fill={GRAY}
+                textAnchor={anchor}
+              >
+                {t}
+              </text>
+            );
+          })
+        : spec.xLabels.map((label, k) => (
+            <text
+              key={label + k}
+              x={tickX[k]}
+              y={H - 16}
+              fontFamily={MONO}
+              fontSize={11}
+              fill={GRAY}
+              textAnchor={k === 0 ? "start" : k === 2 ? "end" : "middle"}
+            >
+              {label}
+            </text>
+          ))}
+      {spec.series.map((s, si) => {
+        const col = SERIES_COLORS[s.color];
+        const end = s.points.length - 1;
+        const pts = s.points.map((v, i) => `${X(s.xs[i])},${Y(v)}`).join(" ");
+        // Fill only single-series trend charts. On multi-line comparisons the
+        // fill sits under whichever series happens to be first (often not the
+        // dominant line), which reads as arbitrary shading.
+        const area =
+          si === 0 && spec.series.length === 1
+            ? `M${X(s.xs[0])},${Y(s.points[0])} ` +
+              s.points.map((v, i) => `L${X(s.xs[i])},${Y(v)}`).join(" ") +
+              ` L${X(s.xs[end])},${baseY} L${X(s.xs[0])},${baseY} Z`
+            : null;
+        return (
+          <g key={si}>
+            {area && <path d={area} fill={col} opacity={0.06} />}
+            <polyline
+              points={pts}
+              fill="none"
+              stroke={col}
+              strokeWidth={2}
+              strokeDasharray={s.dash ? "6 5" : "none"}
+              strokeLinejoin="round"
+              strokeLinecap="round"
+            />
+            <circle cx={X(s.xs[end])} cy={Y(s.points[end])} r={3.5} fill={col} />
+          </g>
+        );
+      })}
+    </svg>
+  );
+}
+
+function BarChart({ spec }: { spec: BarSpec }) {
+  const W = 600,
+    H = 320,
+    L = 8,
+    R = 8,
+    T = 30,
+    B = 52;
+  const iw = W - L - R,
+    ih = H - T - B;
+  const bars = spec.bars;
+  const mx = Math.max(...bars.map((b) => b.value)) * 1.12;
+  const baseY = T + ih;
+  const slot = iw / bars.length;
+  const bw = Math.min(slot * 0.56, 64);
+
+  return (
+    <svg
+      viewBox={`0 0 ${W} ${H}`}
+      width="100%"
+      style={{ display: "block", overflow: "visible" }}
+      preserveAspectRatio="xMidYMid meet"
+    >
+      {[0, 1, 2, 3, 4].map((g) => (
+        <line
+          key={g}
+          x1={L}
+          y1={T + (ih * g) / 4}
+          x2={L + iw}
+          y2={T + (ih * g) / 4}
+          stroke={g === 4 ? INK : GRID}
+          strokeWidth={g === 4 ? 1.5 : 1}
+        />
+      ))}
+      {bars.map((b, i) => {
+        const cx = L + slot * (i + 0.5);
+        const bh = (b.value / mx) * ih;
+        return (
+          <g key={b.label}>
+            <rect
+              x={cx - bw / 2}
+              y={baseY - bh}
+              width={bw}
+              height={bh}
+              fill={b.accent ? AU : "#c7bdb2"}
+            />
+            <text
+              x={cx}
+              y={baseY - bh - 9}
+              fontFamily={MONO}
+              fontSize={12}
+              fill={b.accent ? AU : INK}
+              textAnchor="middle"
+              fontWeight={b.accent ? 500 : 400}
+            >
+              {fmt(b.value, spec.fmt)}
+            </text>
+            <text
+              x={cx}
+              y={H - 14}
+              fontFamily={MONO}
+              fontSize={10.5}
+              fill={b.accent ? INK : GRAY}
+              textAnchor="middle"
+            >
+              {b.label.toUpperCase()}
+            </text>
+          </g>
+        );
+      })}
+    </svg>
+  );
+}
+
+export default function StateChart({
+  spec,
+  wide,
+}: {
+  spec: ChartSpec;
+  wide?: boolean;
+}) {
+  return (
+    <div>
+      {/* Same treatment as the section headline on the left column. */}
+      <div className="mb-4 font-display font-medium text-[clamp(1.4rem,2.4vw,1.9rem)] leading-[1.12] tracking-[-0.01em] text-dark text-balance">
+        {spec.unit}
+      </div>
+      {spec.kind === "line" && spec.legend && (
+        <div className="flex gap-5 flex-wrap mb-3.5">
+          {spec.legend.map((lg) => (
+            <div key={lg.label} className="flex items-center gap-2">
+              <span
+                style={{
+                  width: 16,
+                  height: lg.dash ? 0 : 3,
+                  borderTop: lg.dash
+                    ? `2px dashed ${SERIES_COLORS[lg.color]}`
+                    : "none",
+                  background: lg.dash ? "none" : SERIES_COLORS[lg.color],
+                  display: "inline-block",
+                }}
+              />
+              <span
+                className="type-label-sm uppercase"
+                style={{ letterSpacing: "0.08em", color: GRAY }}
+              >
+                {lg.label}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
+      {spec.kind === "line" ? (
+        wide ? (
+          // The panoramic viewBox only reads at full-column width; phones
+          // get the standard geometry.
+          <>
+            <div className="hidden lg:block">
+              <LineChart spec={spec} wide />
+            </div>
+            <div className="lg:hidden">
+              <LineChart spec={spec} />
+            </div>
+          </>
+        ) : (
+          <LineChart spec={spec} />
+        )
+      ) : (
+        <BarChart spec={spec} />
+      )}
+    </div>
+  );
+}
diff --git a/src/app/prosperity-dashboard/[section]/opengraph-image.tsx b/src/app/state-of-the-nation/[section]/opengraph-image.tsx
similarity index 89%
rename from src/app/prosperity-dashboard/[section]/opengraph-image.tsx
rename to src/app/state-of-the-nation/[section]/opengraph-image.tsx
index 939faa6..f8504a7 100644
--- a/src/app/prosperity-dashboard/[section]/opengraph-image.tsx
+++ b/src/app/state-of-the-nation/[section]/opengraph-image.tsx
@@ -10,7 +10,7 @@ import {
 
 export const runtime = "nodejs";
 
-export const alt = "Build Canada — Prosperity Dashboard";
+export const alt = "Build Canada — State of the Nation";
 
 export const size = OG_SIZE;
 
@@ -26,7 +26,7 @@ export default async function OpengraphImage({
   const { section: sectionId } = await params;
   const section = SECTIONS.find((s) => s.id === sectionId);
 
-  const title = section?.title ?? "Prosperity Dashboard";
+  const title = section?.title ?? "State of the Nation";
   const description =
     section?.description ??
     "Are we moving in the right direction? Canadian prosperity, measured against the G7 and OECD.";
@@ -43,12 +43,12 @@ export default async function OpengraphImage({
   const footnote = source ? `Source: ${humanizeSourceName(source.name)}` : "";
 
   const fonts = await loadOgFonts(
-    `${title}${description}${chartHeading}${chart?.latestLabel ?? ""}${footnote}Prosperity Dashboard`,
+    `${title}${description}${chartHeading}${chart?.latestLabel ?? ""}${footnote}State of the Nation`,
   );
 
   return new ImageResponse(
     <IndicatorOgCard
-      label="Prosperity Dashboard"
+      label="State of the Nation"
       title={title}
       description={description}
       chartHeading={chartHeading}
diff --git a/src/app/prosperity-dashboard/[section]/page.tsx b/src/app/state-of-the-nation/[section]/page.tsx
similarity index 75%
rename from src/app/prosperity-dashboard/[section]/page.tsx
rename to src/app/state-of-the-nation/[section]/page.tsx
index 11295e2..af0969e 100644
--- a/src/app/prosperity-dashboard/[section]/page.tsx
+++ b/src/app/state-of-the-nation/[section]/page.tsx
@@ -4,12 +4,7 @@ import type { Metadata } from "next";
 import Link from "next/link";
 import { notFound } from "next/navigation";
 import { getSiteConfig } from "@/lib/api";
-import {
-  getEconomicSeries,
-  humanizeSourceName,
-  humanizeSourceUrl,
-  type EconomySeriesResponse,
-} from "@/lib/api/economy";
+import { getEconomicSeries } from "@/lib/api/economy";
 import { PageHeader } from "@/components/ui/page-header";
 import { buildGraph } from "@/lib/schemas/graph";
 import { generateOrganizationSchema } from "@/lib/schemas/generators/organization";
@@ -18,6 +13,7 @@ import { Signpost } from "@/components/custom/signpost";
 import CombinedSectionChartClient from "../CombinedSectionChartClient";
 import IndicatorChartClient from "../IndicatorChartClient";
 import SectionNav from "../SectionNav";
+import SourceLine from "../SourceLine";
 import { SECTIONS } from "../indicators";
 
 export const dynamicParams = false;
@@ -34,11 +30,11 @@ export async function generateMetadata({
   const { section: sectionId } = await params;
   const section = SECTIONS.find((s) => s.id === sectionId);
   if (!section) return {};
-  const title = `${section.title} — Prosperity Dashboard`;
+  const title = `${section.title} — State of the Nation`;
   return {
     title,
     description: section.description,
-    alternates: { canonical: `/prosperity-dashboard/${section.id}` },
+    alternates: { canonical: `/state-of-the-nation/${section.id}` },
     openGraph: {
       title,
       description: section.description,
@@ -51,40 +47,6 @@ export async function generateMetadata({
   };
 }
 
-function formatFetchedDate(iso: string): string {
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return "";
-  return new Intl.DateTimeFormat("en-CA", { dateStyle: "long" }).format(date);
-}
-
-function SourceLine({ response }: { response: EconomySeriesResponse }) {
-  const source = response.meta.source;
-  if (!source) return null;
-  const updated = source.last_fetched_at
-    ? formatFetchedDate(source.last_fetched_at)
-    : "";
-  const sourceName = humanizeSourceName(source.name);
-  const sourceUrl = humanizeSourceUrl(source.name, source.url);
-  return (
-    <p className="mt-3 type-label-sm text-dark/60">
-      Source:{" "}
-      {sourceUrl ? (
-        <a
-          href={sourceUrl}
-          target="_blank"
-          rel="noopener noreferrer"
-          className="underline hover:text-dark"
-        >
-          {sourceName}
-        </a>
-      ) : (
-        sourceName
-      )}
-      {updated && <> &middot; Updated {updated}</>}
-    </p>
-  );
-}
-
 // Deep-link targets must clear the sticky navbar + SectionNav stack, whose
 // height grows as the section links wrap on narrower screens.
 const SECTION_SCROLL_MT =
@@ -133,7 +95,7 @@ export default async function IndicatorSectionPage({ params }: PageProps) {
   const jsonLd = buildGraph(
     generateOrganizationSchema(configData),
     generateBreadcrumbSchema(
-      `/prosperity-dashboard/${section.id}`,
+      `/state-of-the-nation/${section.id}`,
       section.title,
       configData.siteUrl,
     ),
@@ -145,24 +107,34 @@ export default async function IndicatorSectionPage({ params }: PageProps) {
     ),
   );
 
-  const combinedItems = section.combined
-    ? section.indicators.flatMap((indicator, i) => {
-        const response = results[i];
-        return response
-          ? [{ label: indicator.chartLabel ?? indicator.heading, response }]
-          : [];
-      })
-    : [];
+  // Each combined chart overlays a subset of the section's indicators
+  // (defaulting to all of them), in the order its slugs list them.
+  const combinedCharts = (section.combined ?? []).flatMap((chart) => {
+    const slugs = chart.slugs ?? section.indicators.map((i) => i.slug);
+    const items = slugs.flatMap((slug) => {
+      const index = section.indicators.findIndex((i) => i.slug === slug);
+      const indicator = section.indicators[index];
+      const response = index >= 0 ? results[index] : null;
+      return indicator && response
+        ? [{ label: indicator.chartLabel ?? indicator.heading, response }]
+        : [];
+    });
+    return items.length > 0 ? [{ ...chart, items }] : [];
+  });
 
   const signpostHeadings = [
-    ...(section.combined && combinedItems.length > 0
-      ? [{ id: "combined", text: section.combined.heading, level: 2 as const }]
-      : []),
-    ...section.indicators.map((indicator) => ({
-      id: indicator.slug,
-      text: indicator.heading,
+    ...combinedCharts.map((chart) => ({
+      id: chart.id,
+      text: chart.heading,
       level: 2 as const,
     })),
+    ...section.indicators
+      .filter((indicator) => !indicator.combinedOnly)
+      .map((indicator) => ({
+        id: indicator.slug,
+        text: indicator.heading,
+        level: 2 as const,
+      })),
   ];
 
   return (
@@ -189,22 +161,23 @@ export default async function IndicatorSectionPage({ params }: PageProps) {
             showTopBorder={false}
           />
           <div className="max-w-[1080px] mx-auto 2xl-memo:mx-0 w-full min-w-0 space-y-16">
-            {section.combined && combinedItems.length > 0 && (
-              <section id="combined" className={SECTION_SCROLL_MT}>
-                <AnchoredHeading id="combined" text={section.combined.heading} />
+            {combinedCharts.map((chart) => (
+              <section key={chart.id} id={chart.id} className={SECTION_SCROLL_MT}>
+                <AnchoredHeading id={chart.id} text={chart.heading} />
                 <p className="mt-1 mb-6 type-body-sm text-dark/60 max-w-[720px]">
-                  {section.combined.blurb}
+                  {chart.blurb}
                 </p>
                 <CombinedSectionChartClient
-                  heading={section.combined.heading}
-                  items={combinedItems}
+                  heading={chart.heading}
+                  items={chart.items}
                   benchmark={section.benchmark}
                 />
-                <SourceLine response={combinedItems[0].response} />
+                <SourceLine response={chart.items[0].response} />
               </section>
-            )}
+            ))}
 
             {section.indicators.map((indicator, i) => {
+              if (indicator.combinedOnly) return null;
               const response = results[i];
               return (
                 <section
@@ -242,7 +215,7 @@ export default async function IndicatorSectionPage({ params }: PageProps) {
             >
               {prev ? (
                 <Link
-                  href={`/prosperity-dashboard/${prev.id}`}
+                  href={`/state-of-the-nation/${prev.id}`}
                   className="type-label text-dark/70 hover:text-dark underline-offset-4 hover:underline"
                 >
                   &larr; {prev.title}
@@ -252,7 +225,7 @@ export default async function IndicatorSectionPage({ params }: PageProps) {
               )}
               {next ? (
                 <Link
-                  href={`/prosperity-dashboard/${next.id}`}
+                  href={`/state-of-the-nation/${next.id}`}
                   className="type-label text-dark/70 hover:text-dark underline-offset-4 hover:underline text-right"
                 >
                   {next.title} &rarr;
diff --git a/src/app/prosperity-dashboard/canvas/CanvasClient.tsx b/src/app/state-of-the-nation/canvas/CanvasClient.tsx
similarity index 99%
rename from src/app/prosperity-dashboard/canvas/CanvasClient.tsx
rename to src/app/state-of-the-nation/canvas/CanvasClient.tsx
index c20ad5e..e8c7da0 100644
--- a/src/app/prosperity-dashboard/canvas/CanvasClient.tsx
+++ b/src/app/state-of-the-nation/canvas/CanvasClient.tsx
@@ -111,7 +111,7 @@ export default function CanvasClient() {
     const params = new URLSearchParams();
     params.set("f", serializeFeeds(resolvedFeeds));
     if (mode !== "indexed") params.set("mode", mode);
-    const next = `/prosperity-dashboard/canvas?${params.toString()}`;
+    const next = `/state-of-the-nation/canvas?${params.toString()}`;
     if (`${window.location.pathname}${window.location.search}` !== next) {
       window.history.replaceState(null, "", next);
     }
diff --git a/src/app/prosperity-dashboard/canvas/OverlayChart.tsx b/src/app/state-of-the-nation/canvas/OverlayChart.tsx
similarity index 100%
rename from src/app/prosperity-dashboard/canvas/OverlayChart.tsx
rename to src/app/state-of-the-nation/canvas/OverlayChart.tsx
diff --git a/src/app/prosperity-dashboard/canvas/opengraph-image.tsx b/src/app/state-of-the-nation/canvas/opengraph-image.tsx
similarity index 98%
rename from src/app/prosperity-dashboard/canvas/opengraph-image.tsx
rename to src/app/state-of-the-nation/canvas/opengraph-image.tsx
index f34c658..e02e26f 100644
--- a/src/app/prosperity-dashboard/canvas/opengraph-image.tsx
+++ b/src/app/state-of-the-nation/canvas/opengraph-image.tsx
@@ -52,7 +52,7 @@ export default async function OpengraphImage() {
 
   return new ImageResponse(
     <IndicatorOgCard
-      label="Prosperity Dashboard"
+      label="State of the Nation"
       title={TITLE}
       description={DESCRIPTION}
       chartHeading="Canada, three series overlaid"
diff --git a/src/app/prosperity-dashboard/canvas/overlay-types.ts b/src/app/state-of-the-nation/canvas/overlay-types.ts
similarity index 100%
rename from src/app/prosperity-dashboard/canvas/overlay-types.ts
rename to src/app/state-of-the-nation/canvas/overlay-types.ts
diff --git a/src/app/prosperity-dashboard/canvas/page.tsx b/src/app/state-of-the-nation/canvas/page.tsx
similarity index 90%
rename from src/app/prosperity-dashboard/canvas/page.tsx
rename to src/app/state-of-the-nation/canvas/page.tsx
index 81b2fda..71ec7a4 100644
--- a/src/app/prosperity-dashboard/canvas/page.tsx
+++ b/src/app/state-of-the-nation/canvas/page.tsx
@@ -10,7 +10,7 @@ const DESCRIPTION =
 export const metadata: Metadata = {
   title: "Indicator Canvas",
   description: DESCRIPTION,
-  alternates: { canonical: "/prosperity-dashboard/canvas" },
+  alternates: { canonical: "/state-of-the-nation/canvas" },
   openGraph: {
     title: "Indicator Canvas",
     description: DESCRIPTION,
@@ -33,10 +33,10 @@ export default function CanvasPage() {
       <nav className="border-b border-border-light px-5 py-3">
         <div className="max-w-[1080px] mx-auto">
           <Link
-            href="/prosperity-dashboard"
+            href="/state-of-the-nation"
             className="type-label text-dark/70 hover:text-dark underline-offset-4 hover:underline"
           >
-            &larr; Prosperity Dashboard
+            &larr; State of the Nation
           </Link>
         </div>
       </nav>
diff --git a/src/app/state-of-the-nation/dashboard.ts b/src/app/state-of-the-nation/dashboard.ts
new file mode 100644
index 0000000..5db778b
--- /dev/null
+++ b/src/app/state-of-the-nation/dashboard.ts
@@ -0,0 +1,254 @@
+// Layout of the single-page prosperity dashboard (modelled on
+// lookingforgrowth.uk's State of the Nation): a headline chart followed by
+// themed sections rendered as anchored blocks on one page. Measures must
+// exist in york_factory's /kpis/series endpoint; charts the API can't serve
+// yet are listed under `planned` so the section still shows its intent.
+// The per-section subpages keep using the older catalog in indicators.ts.
+
+import type { IndicatorBenchmark } from "./indicators";
+
+export type DashboardSeries = { slug: string; label: string };
+
+export type DashboardIndicator = {
+  // For single-measure charts this is the measure slug; for multi-series
+  // charts it is only the chart's #anchor id.
+  slug: string;
+  heading: string;
+  blurb: string;
+  benchmark?: IndicatorBenchmark;
+  // Overlay several measures as lines on one chart. All series must share
+  // the same unit and frequency; the first renders emphasized in brand red.
+  series?: DashboardSeries[];
+};
+
+export type PlannedIndicator = {
+  heading: string;
+  // The series the backend needs to ingest before this chart can ship.
+  needs: string;
+};
+
+export type DashboardSection = {
+  id: string;
+  title: string;
+  description?: string;
+  // Full-width hero treatment for every chart in the section.
+  hero?: boolean;
+  indicators: DashboardIndicator[];
+  planned?: PlannedIndicator[];
+};
+
+export const DASHBOARD_SECTIONS: DashboardSection[] = [
+  {
+    id: "headline",
+    title: "Headline",
+    hero: true,
+    indicators: [
+      {
+        slug: "gdp-per-capita-canada",
+        heading: "GDP per capita",
+        blurb:
+          "Real output per person, in chained 2017 dollars — the clearest single measure of whether living standards are rising. StatCan's quarterly series runs within about two months of the present, where the World Bank's international comparison lags by a year or more.",
+      },
+    ],
+  },
+  {
+    id: "economy",
+    title: "Economy",
+    description:
+      "Is Canada's economy growing, hiring, and investing enough to sustain rising living standards?",
+    indicators: [
+      {
+        slug: "employment-rate",
+        heading: "Employment",
+        blurb:
+          "Share of the population aged 15 and over that is employed. The broadest gauge of whether people who could work, do.",
+      },
+      {
+        slug: "employment-by-age",
+        heading: "Employment by age group",
+        blurb:
+          "Share of each age group that is employed, monthly and seasonally adjusted. The 25–54 core-working-age line is the cleanest read — it strips out students and retirees.",
+        series: [
+          { slug: "employment-rate-25-to-54", label: "25–54" },
+          { slug: "employment-rate-15-to-24", label: "15–24" },
+          { slug: "employment-rate-55-to-64", label: "55–64" },
+          { slug: "employment-rate-15-plus", label: "15+" },
+        ],
+      },
+      {
+        slug: "business-formation",
+        heading: "New business formation",
+        blurb:
+          "Businesses appearing for the first time versus permanently ceasing operations, monthly and seasonally adjusted — true births and deaths, not seasonal reopenings. Experimental estimates (Statistics Canada); exits are confirmed ~6 months behind entrants.",
+        series: [
+          { slug: "business-entrants", label: "Entrants" },
+          { slug: "business-exits", label: "Exits" },
+        ],
+      },
+      {
+        slug: "wages",
+        heading: "Average and median hourly wage",
+        blurb:
+          "Hourly wages for all employees, in current dollars (not adjusted for inflation). When the average pulls away from the median, gains are concentrating at the top — StatCan's public API carries no wage percentiles, so this gap is the closest available dispersion signal.",
+        series: [
+          { slug: "average-hourly-wage", label: "Average" },
+          { slug: "median-hourly-wage", label: "Median" },
+        ],
+      },
+      {
+        slug: "fdi-flows",
+        heading: "Investment inflows and outflows",
+        blurb:
+          "Quarterly foreign-direct-investment flows into Canada and Canadian direct investment abroad. Outflows are not a loss — they are Canadian firms investing elsewhere — but the gap shows where capital would rather be. Flows can turn negative when investment is withdrawn.",
+        series: [
+          { slug: "fdi-inflows", label: "Into Canada" },
+          { slug: "fdi-outflows", label: "Canadian investment abroad" },
+        ],
+      },
+      {
+        slug: "capital-formation-pct-gdp",
+        heading: "Capital formation",
+        blurb:
+          "Gross capital formation as a share of GDP — how much of the economy is devoted to building future capacity.",
+      },
+      {
+        slug: "capital-investment",
+        heading: "Capital investment (levels)",
+        blurb:
+          "Gross fixed capital formation in chained 2017 dollars at seasonally adjusted annual rates — the machinery, buildings, and infrastructure Canada adds each quarter, total and business-sector.",
+        series: [
+          { slug: "gross-fixed-capital-formation", label: "Total" },
+          {
+            slug: "business-gross-fixed-capital-formation",
+            label: "Business sector",
+          },
+        ],
+      },
+    ],
+  },
+  {
+    id: "government-sustainability",
+    title: "Government Sustainability",
+    description:
+      "Can Canadian governments keep their books balanced without crowding out the private economy?",
+    indicators: [
+      {
+        slug: "govt-debt-to-gdp",
+        heading: "Debt to GDP (all levels of government)",
+        blurb:
+          "Consolidated general government — federal, provincial, local, and CPP/QPP — on a national-balance-sheet basis. Net debt subtracts financial assets, including the pension plans' holdings, which is why it sits far below the federal-budget figures in the news. The two lines measure different things; don't split the difference.",
+        series: [
+          { slug: "govt-gross-debt-to-gdp", label: "Gross debt" },
+          { slug: "govt-net-debt-to-gdp", label: "Net liabilities" },
+        ],
+      },
+      {
+        slug: "employment-by-class",
+        heading: "Private vs public employment",
+        blurb:
+          "Employed Canadians by class of worker, monthly and seasonally adjusted. The three lines sum to total employment — watch the mix: a rising public line means government hiring is outpacing the market economy.",
+        series: [
+          { slug: "employment-private-sector", label: "Private sector" },
+          { slug: "employment-public-sector", label: "Public sector" },
+          { slug: "employment-self-employed", label: "Self-employed" },
+        ],
+      },
+    ],
+  },
+  {
+    id: "cost-of-living",
+    title: "Cost of Living",
+    description:
+      "What Canadians pay for the essentials — and whether a home is still within reach.",
+    indicators: [
+      {
+        slug: "cpi-all-items",
+        heading: "CPI",
+        blurb:
+          "The all-items Consumer Price Index, month by month (2002 = 100). The grey line is where prices would sit had they grown at the Bank of Canada's 2% inflation target.",
+        // Bank of Canada inflation-control target (2% midpoint), compounded
+        // through the CPI's 2002 = 100 index base.
+        benchmark: {
+          label: "2% target",
+          annualRatePct: 2,
+          anchorYear: 2002,
+          anchorValue: 100,
+        },
+      },
+      {
+        slug: "house-price-to-income",
+        heading: "Housing price to income ratio",
+        blurb:
+          "House prices relative to disposable income per person, shown against Canada's long-term average (100). The OECD's headline affordability indicator.",
+      },
+      {
+        slug: "housing-starts-canada",
+        heading: "Housing starts",
+        blurb:
+          "Dwelling units started per year across Canada, from CMHC's starts and completions survey. The supply side of the housing equation.",
+      },
+    ],
+  },
+  {
+    id: "immigration",
+    title: "Immigration",
+    description:
+      "How many people are coming, who they are, and how many are leaving.",
+    indicators: [
+      {
+        slug: "population-growth-components",
+        heading: "Components of population growth",
+        blurb:
+          "Annual movements of people in and out of Canada, on StatCan's July–June demographic years (the 2024 point covers July 2023 to June 2024). Net emigration is the gap between the emigrant and returning-emigrant lines; the net non-permanent-resident line swings negative when more temporary visas expire than are issued.",
+        series: [
+          { slug: "immigrants-annual", label: "Immigrants" },
+          {
+            slug: "net-non-permanent-residents-annual",
+            label: "Net non-permanent residents",
+          },
+          { slug: "emigrants-annual", label: "Emigrants" },
+          { slug: "returning-emigrants-annual", label: "Returning emigrants" },
+        ],
+      },
+      {
+        slug: "temporary-residents",
+        heading: "Temporary residents by type",
+        blurb:
+          "How many people hold temporary status in Canada on the first day of each quarter — stocks, not flows. Work-permit holders are the closest public measure of \"temporary foreign workers\"; no StatCan series exists under that name. The series only begins in mid-2021.",
+        series: [
+          { slug: "npr-total", label: "All non-permanent residents" },
+          { slug: "npr-work-permit-holders", label: "Work permits" },
+          { slug: "npr-study-permit-holders", label: "Study permits" },
+          { slug: "npr-asylum-claimants", label: "Asylum claimants" },
+          { slug: "npr-work-and-study-permit-holders", label: "Work + study" },
+        ],
+      },
+      {
+        slug: "pr-admissions-by-class",
+        heading: "Immigration by class",
+        blurb:
+          "Permanent residents admitted each month, by immigration class, from IRCC's monthly updates. IRCC rounds counts to the nearest 5 and suppresses small cells, so values are approximate and won't exactly match StatCan's July–June figures above. Students are not a PR class — they appear under study permits.",
+        series: [
+          { slug: "pr-admissions-total", label: "Total" },
+          { slug: "pr-admissions-economic", label: "Economic" },
+          { slug: "pr-admissions-family", label: "Family" },
+          { slug: "pr-admissions-refugee", label: "Refugee" },
+          { slug: "pr-admissions-other", label: "Other" },
+        ],
+      },
+    ],
+  },
+];
+
+export const DASHBOARD_INDICATORS: DashboardIndicator[] =
+  DASHBOARD_SECTIONS.flatMap((s) => s.indicators);
+
+// Every measure the dashboard fetches — one per single chart, several per
+// multi-series chart.
+export const DASHBOARD_MEASURE_SLUGS: string[] = Array.from(
+  new Set(
+    DASHBOARD_INDICATORS.flatMap(
+      (indicator) => indicator.series?.map((s) => s.slug) ?? [indicator.slug],
+    ),
+  ),
+);
diff --git a/src/app/prosperity-dashboard/indicators.ts b/src/app/state-of-the-nation/indicators.ts
similarity index 93%
rename from src/app/prosperity-dashboard/indicators.ts
rename to src/app/state-of-the-nation/indicators.ts
index 3cb95a0..4a45697 100644
--- a/src/app/prosperity-dashboard/indicators.ts
+++ b/src/app/state-of-the-nation/indicators.ts
@@ -1,5 +1,5 @@
 // Shared catalog of the economic indicator measures served by york_factory's
-// /kpis/series endpoint — each section gets its own /prosperity-dashboard/[section]
+// /kpis/series endpoint — each section gets its own /state-of-the-nation/[section]
 // page and the canvas page uses the flat list as the feed picker.
 
 export type Indicator = {
@@ -8,6 +8,19 @@ export type Indicator = {
   blurb: string;
   // Short line label used when the indicator appears in a combined chart.
   chartLabel?: string;
+  // Renders only as a line in one of the section's combined charts, with no
+  // standalone chart of its own (still fetched, and still a canvas feed).
+  combinedOnly?: boolean;
+};
+// An overlay chart of several of the section's indicators. Every slug listed
+// must share the same unit and frequency; the first slug renders emphasized
+// in brand red. Omit slugs to overlay the whole section.
+export type CombinedChart = {
+  // DOM id — the chart's #anchor on the section page.
+  id: string;
+  heading: string;
+  blurb: string;
+  slugs?: string[];
 };
 // Reference line drawn on every chart in a section (including the combined
 // chart): a value compounding at annualRatePct per year through
@@ -24,10 +37,8 @@ export type IndicatorSection = {
   description: string;
   // The section's most striking chart, previewed on the landing-page card.
   featuredSlug: string;
-  // Renders one overlay chart of every indicator in the section above the
-  // individual charts. Only for sections whose indicators all share the
-  // same unit and frequency.
-  combined?: { heading: string; blurb: string };
+  // Overlay charts rendered above the section's individual charts.
+  combined?: CombinedChart[];
   benchmark?: IndicatorBenchmark;
   indicators: Indicator[];
 };
@@ -92,11 +103,14 @@ export const SECTIONS: IndicatorSection[] = [
     description:
       "What Canadians actually pay for the essentials — monthly consumer prices for food, shelter, and getting around (2002 = 100).",
     featuredSlug: "cpi-all-items",
-    combined: {
-      heading: "The essentials, side by side",
-      blurb:
-        "Every cost-of-living component on one chart, indexed to 2002 = 100. The grey line is where prices would sit had they grown at the Bank of Canada's 2% inflation target — everything above it has outrun the target.",
-    },
+    combined: [
+      {
+        id: "combined",
+        heading: "The essentials, side by side",
+        blurb:
+          "Every cost-of-living component on one chart, indexed to 2002 = 100. The grey line is where prices would sit had they grown at the Bank of Canada's 2% inflation target — everything above it has outrun the target.",
+      },
+    ],
     // Bank of Canada inflation-control target (2% midpoint), compounded
     // through the CPI's 2002 = 100 index base.
     benchmark: {
diff --git a/src/app/prosperity-dashboard/og-card.tsx b/src/app/state-of-the-nation/og-card.tsx
similarity index 99%
rename from src/app/prosperity-dashboard/og-card.tsx
rename to src/app/state-of-the-nation/og-card.tsx
index 2769489..7e59607 100644
--- a/src/app/prosperity-dashboard/og-card.tsx
+++ b/src/app/state-of-the-nation/og-card.tsx
@@ -2,7 +2,7 @@ import type { EconomySeriesResponse } from "@/lib/api/economy";
 import { CANADA_COLOR } from "./indicators";
 import { formatValue } from "./units";
 
-// Shared plumbing for the /prosperity-dashboard opengraph images: one branded
+// Shared plumbing for the /state-of-the-nation opengraph images: one branded
 // card layout plus builders that bake a series into a data-URI SVG. Satori
 // lays out the text; the chart travels as an <img> so resvg rasterizes real
 // vector paths instead of satori's partial SVG support.
diff --git a/src/app/prosperity-dashboard/opengraph-image.tsx b/src/app/state-of-the-nation/opengraph-image.tsx
similarity index 71%
rename from src/app/prosperity-dashboard/opengraph-image.tsx
rename to src/app/state-of-the-nation/opengraph-image.tsx
index 1d3fbe1..0e0aca7 100644
--- a/src/app/prosperity-dashboard/opengraph-image.tsx
+++ b/src/app/state-of-the-nation/opengraph-image.tsx
@@ -1,6 +1,5 @@
 import { ImageResponse } from "next/og";
 import { getEconomicSeries, humanizeSourceName } from "@/lib/api/economy";
-import { indicatorHeading } from "./indicators";
 import {
   buildOgChart,
   IndicatorOgCard,
@@ -11,7 +10,7 @@ import {
 export const runtime = "nodejs";
 
 export const alt =
-  "Build Canada — Prosperity Dashboard: Canadian prosperity, measured against the G7 and OECD";
+  "Build Canada — State of the Nation: Canadian prosperity, measured";
 
 export const size = OG_SIZE;
 
@@ -19,17 +18,22 @@ export const contentType = "image/png";
 
 export const revalidate = 3600;
 
-// The landing card leads with the dashboard's clearest single chart.
-const FEATURED_SLUG = "gdp-per-capita-ppp";
+// The landing card leads with the dashboard's clearest single chart —
+// StatCan's quarterly real GDP per capita, matching the page's headline.
+const FEATURED_SLUG = "gdp-per-capita-canada";
+const CHART_HEADING = "GDP per capita";
 
-const TITLE = "Prosperity Dashboard";
+const TITLE = "State of the Nation";
 const DESCRIPTION =
-  "Are we moving in the right direction? Canadian prosperity, measured against the G7 and OECD.";
+  "Are we moving in the right direction? Canadian prosperity, measured.";
 
 export default async function OpengraphImage() {
-  const response = await getEconomicSeries(FEATURED_SLUG).catch(() => null);
+  // Canada only, matching the dashboard's charts.
+  const response = await getEconomicSeries(FEATURED_SLUG, {
+    jurisdictions: "ca",
+  }).catch(() => null);
   const chart = response ? buildOgChart(response) : null;
-  const chartHeading = indicatorHeading(FEATURED_SLUG);
+  const chartHeading = CHART_HEADING;
   const source = response?.meta.source;
   const footnote = source ? `Source: ${humanizeSourceName(source.name)}` : "";
 
diff --git a/src/app/state-of-the-nation/page.tsx b/src/app/state-of-the-nation/page.tsx
new file mode 100644
index 0000000..2f08672
--- /dev/null
+++ b/src/app/state-of-the-nation/page.tsx
@@ -0,0 +1,166 @@
+import type { Metadata } from "next";
+import { getSiteConfig } from "@/lib/api";
+import { getEconomicSeries } from "@/lib/api/economy";
+import { buildGraph } from "@/lib/schemas/graph";
+import { generateOrganizationSchema } from "@/lib/schemas/generators/organization";
+import { generateBreadcrumbSchema } from "@/lib/schemas/generators/breadcrumb";
+import StateChart from "./StateChart";
+import {
+  buildSections,
+  SOTN_MEASURE_SLUGS,
+  type SotnView,
+} from "./state-of-the-nation";
+
+const DESCRIPTION =
+  "Sixteen indicators, read honestly. Where Canada leads, where we lag, and where the picture is genuinely mixed — measured against our own record.";
+
+export const metadata: Metadata = {
+  title: "State of the Nation",
+  description: DESCRIPTION,
+  alternates: { canonical: "/state-of-the-nation" },
+  openGraph: {
+    title: "State of the Nation",
+    description: DESCRIPTION,
+    type: "website",
+  },
+  twitter: {
+    card: "summary_large_image",
+    title: "State of the Nation",
+  },
+};
+
+// Warm grey used by the design for secondary mono text; no site token.
+const GRAY = "#6f6a63";
+const BD = "#CDC4BD";
+
+// A chart card: meta row, chart title + chart, and the source attribution
+// the data licences require. Cards tile 2×2 on desktop within their section,
+// ruled by the design's warm hairlines; `wide` cards span both columns
+// (the headline chart).
+function IndicatorCard({
+  indicator,
+  wide,
+}: {
+  indicator: SotnView;
+  wide?: boolean;
+}) {
+  return (
+    <section
+      className={`flex flex-col border-[#CDC4BD] border-b px-[clamp(24px,5vw,88px)] pb-[clamp(32px,4vw,56px)] ${wide
+        ? "pt-[clamp(20px,2.5vw,32px)] lg:col-span-2"
+        : "pt-[clamp(32px,4vw,56px)] lg:[&:nth-child(odd):not(:last-child)]:border-r"
+        }`}
+    >
+      <StateChart spec={indicator.spec} wide={wide} />
+      <div
+        className="mt-5 pt-3.5 type-label-sm uppercase tracking-[0.08em]"
+        style={{ color: GRAY, borderTop: `1px solid ${BD}` }}
+      >
+        Source ·{" "}
+        {indicator.sourceUrl ? (
+          <a
+            href={indicator.sourceUrl}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="underline underline-offset-2 hover:text-dark"
+          >
+            {indicator.source}
+          </a>
+        ) : (
+          indicator.source
+        )}
+      </div>
+    </section>
+  );
+}
+
+export default async function StateOfTheNationPage() {
+  const configData = getSiteConfig();
+
+  // Canada only — this page reads Canada against its own record.
+  const results = await Promise.all(
+    SOTN_MEASURE_SLUGS.map((slug) =>
+      getEconomicSeries(slug, { jurisdictions: "ca" }).catch(() => null),
+    ),
+  );
+  const responseBySlug = new Map(
+    SOTN_MEASURE_SLUGS.map((slug, i) => [slug, results[i]]),
+  );
+
+  const sections = buildSections((slug) => responseBySlug.get(slug) ?? null);
+
+  const jsonLd = buildGraph(
+    generateOrganizationSchema(configData),
+    generateBreadcrumbSchema(
+      "/state-of-the-nation",
+      "State of the Nation",
+      configData.siteUrl,
+    ),
+  );
+
+  return (
+    <div className="mx-[10px] my-[10px] border border-border-light bg-bg overflow-x-clip">
+      <script
+        type="application/ld+json"
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
+      />
+
+      {/* Compact masthead — the first chart must land above the fold on
+          desktop. */}
+      <header className="max-w-[1180px] px-[clamp(24px,5vw,88px)] pt-[clamp(28px,3.5vw,48px)] pb-[clamp(16px,2vw,28px)]">
+        <div className="mb-4 type-label uppercase tracking-[0.16em] text-auburn-800">
+          State of the Nation · 2026
+        </div>
+        <h1 className="m-0 font-display font-medium text-[clamp(2.4rem,4.6vw,3.8rem)] leading-[0.99] tracking-[-0.03em] text-balance">
+          State of the Nation
+        </h1>
+      </header>
+
+      <div id="indicators">
+        {sections.map((section) => {
+          // Wide cards render full-width above the 2×2 grid, outside it so
+          // the grid's odd/even column rules stay aligned.
+          const wideIndicators = section.indicators.filter((i) => i.wide);
+          const gridIndicators = section.indicators.filter((i) => !i.wide);
+          return (
+            <section key={section.id} id={section.id}>
+              <div
+                className="px-[clamp(24px,5vw,88px)] pt-[clamp(24px,3vw,40px)] pb-[clamp(12px,1.5vw,20px)]"
+                style={{ borderBottom: `1px solid ${BD}` }}
+              >
+                <h2 className="m-0 font-display font-medium text-[clamp(1.7rem,2.6vw,2.3rem)] leading-[1.02] tracking-[-0.02em]">
+                  {section.title}
+                </h2>
+              </div>
+              {wideIndicators.map((indicator) => (
+                <IndicatorCard key={indicator.n} indicator={indicator} wide />
+              ))}
+              {gridIndicators.length > 0 && (
+                <div className="grid grid-cols-1 lg:grid-cols-2">
+                  {gridIndicators.map((indicator) => (
+                    <IndicatorCard key={indicator.n} indicator={indicator} />
+                  ))}
+                </div>
+              )}
+            </section>
+          );
+        })}
+      </div>
+
+      <section className="px-[clamp(24px,5vw,88px)] py-[clamp(48px,6vw,80px)] text-center">
+        <h2 className="type-h3 text-dark">Missing a measure that matters?</h2>
+        <p className="mt-2 type-body text-dark/70 max-w-[560px] mx-auto">
+          We&rsquo;re expanding this dashboard. If there&rsquo;s an indicator
+          that would sharpen the picture — for better or worse — tell us and
+          we&rsquo;ll track it.
+        </p>
+        <a
+          href="mailto:hi@buildcanada.com?subject=State%20of%20the%20Nation%20indicator%20request"
+          className="mt-6 inline-block border border-dark px-5 py-2.5 type-label text-dark hover:bg-dark hover:text-bg transition-colors"
+        >
+          Email us
+        </a>
+      </section>
+    </div>
+  );
+}
diff --git a/src/app/state-of-the-nation/state-of-the-nation.ts b/src/app/state-of-the-nation/state-of-the-nation.ts
new file mode 100644
index 0000000..a13553a
--- /dev/null
+++ b/src/app/state-of-the-nation/state-of-the-nation.ts
@@ -0,0 +1,924 @@
+// The State of the Nation indicators, in the design's layout with the
+// dashboard's real chart order and contents:
+//   Headline — GDP per capita
+//   Economy — employment by age, business formation, employment, wages,
+//             investment flows, capital formation
+//   Government Sustainability — debt to GDP, private vs public employment
+//   Cost of Living — CPI, house price to income, housing starts
+//   Immigration — net emigration, immigration, TFWs, immigration by class
+// Every chart derives its stat and series from york_factory at request time;
+// a chart whose data is unavailable is skipped rather than shown stale.
+
+import {
+  humanizeSourceName,
+  humanizeSourceUrl,
+  type EconomySeriesPoint,
+  type EconomySeriesResponse,
+} from "@/lib/api/economy";
+import type { ChartSpec, LineSpec } from "./StateChart";
+
+export type Verdict = "lead" | "lag" | "mixed";
+
+export type SotnView = {
+  n: string;
+  title: string;
+  verdict: Verdict;
+  stat: string;
+  statSub: string;
+  headline: string;
+  body: string;
+  source: string;
+  // Public landing page for the source (humanizeSourceUrl maps raw API
+  // endpoints to human pages); null when the API reports no URL.
+  sourceUrl: string | null;
+  spec: ChartSpec;
+  // Renders full-width above its section's card grid.
+  wide?: boolean;
+};
+
+type Getter = (slug: string) => EconomySeriesResponse | null;
+
+// All series are fetched Canada-only; the comparisons this page draws are
+// against Canada's own record.
+export const SOTN_MEASURE_SLUGS = [
+  "gdp-per-capita-canada",
+  "employment-rate-25-to-54",
+  "employment-rate-15-to-24",
+  "employment-rate-55-to-64",
+  "employment-rate-15-plus",
+  // Business entries chart: the discontinued quarterly series (2000-2019)
+  // chain-linked with the ongoing monthly openings series. "business-entrants"
+  // (the narrower 2015+ first-ever formation) is no longer charted.
+  "business-entries-historical",
+  "business-openings",
+  // "employment-rate" (annual 15+) removed with the "Employment" chart below —
+  // redundant with "Employment by age", which carries the 15+ line monthly.
+  // "employment-rate",
+  "average-hourly-wage",
+  "median-hourly-wage",
+  "fdi-position-in-canada",
+  "cdi-position-abroad",
+  "capital-formation-pct-gdp",
+  // Gross debt is deliberately not fetched or charted — it ignores the
+  // financial assets governments hold and overstates the burden. The debt
+  // chart shows net financial debt only (govt-net-debt-to-gdp).
+  "govt-net-debt-to-gdp",
+  "employment-all-classes",
+  "employment-private-sector",
+  "employment-public-sector",
+  "employment-self-employed",
+  "cpi-all-items",
+  "house-price-to-income",
+  "housing-starts-canada",
+  "population-canada",
+  "emigrants-annual",
+  "returning-emigrants-annual",
+  "pr-admissions-annual-historical",
+  // Temporarily disabled: the NPR-by-type series only start 2021 Q3, which was
+  // dragging the shared chart window forward to 2021. Commented out with the
+  // "Temporary foreign workers" indicator below so the window can reach back
+  // to 2015 (the next-shortest series: business formation and PR admissions).
+  // "npr-work-permit-holders",
+  // "npr-total",
+  "pr-admissions-total",
+  "pr-admissions-economic",
+  "pr-admissions-family",
+  "pr-admissions-refugee",
+  "pr-admissions-other",
+  "pr-admissions-economic-historical",
+  "pr-admissions-family-historical",
+  "pr-admissions-refugee-historical",
+  "pr-admissions-other-historical",
+];
+
+const MONTHS = [
+  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+];
+
+// The x window charts render in — a fixed 1980 start through the latest point
+// any series reports. Set at the top of buildIndicators.
+let sharedDomain: [number, number] = [1980, 1981];
+
+// Trims a series to a window start (default: the shared 1980 start). Series
+// with longer histories are cut back to it; series that begin later are left
+// untouched and simply render partway into the window. The optional `start`
+// lets a chart reach back further if ever needed.
+function clip(
+  ps: EconomySeriesPoint[] | null,
+  start = sharedDomain[0],
+): EconomySeriesPoint[] | null {
+  if (!ps) return null;
+  const kept = ps.filter((p) => p.year >= start - 1e-6);
+  return kept.length > 1 ? kept : null;
+}
+
+function points(
+  get: Getter,
+  slug: string,
+  start = sharedDomain[0],
+): EconomySeriesPoint[] | null {
+  const series = get(slug)?.data.series.find(
+    (s) => s.jurisdiction.slug === "ca",
+  );
+  return clip(series && series.points.length > 1 ? series.points : null, start);
+}
+
+const last = (ps: EconomySeriesPoint[]) => ps[ps.length - 1];
+
+// Converts nominal dollars to real dollars using the all-items CPI, expressed
+// in the latest CPI year's dollars. Values are deflated by each point's
+// calendar-year average CPI.
+function cpiDeflator(
+  get: Getter,
+): { toReal: (value: number, year: number) => number; baseYear: number } | null {
+  const cpi = points(get, "cpi-all-items");
+  if (!cpi) return null;
+  const sums = new Map<number, { sum: number; n: number }>();
+  for (const p of cpi) {
+    const year = Math.floor(p.year);
+    const entry = sums.get(year) ?? { sum: 0, n: 0 };
+    entry.sum += p.value;
+    entry.n += 1;
+    sums.set(year, entry);
+  }
+  const avg = new Map(
+    [...sums].map(([year, { sum, n }]) => [year, sum / n]),
+  );
+  const baseYear = Math.max(...avg.keys());
+  const base = avg.get(baseYear)!;
+  return {
+    baseYear,
+    toReal: (value, year) => value * (base / (avg.get(Math.floor(year)) ?? base)),
+  };
+}
+
+// Attribution name + public link for a chart, from its primary measure's
+// source record.
+function sourceLink(
+  get: Getter,
+  slug: string,
+): { source: string; sourceUrl: string | null } {
+  const source = get(slug)?.meta.source ?? null;
+  return {
+    source: source ? humanizeSourceName(source.name) : "",
+    sourceUrl: source ? humanizeSourceUrl(source.name, source.url) : null,
+  };
+}
+
+const int = (v: number) => Math.round(v).toLocaleString("en-CA");
+
+function monthLabel(p: EconomySeriesPoint): string {
+  if (!p.date) return String(p.year);
+  const [y, m] = p.date.split("-");
+  return `${MONTHS[Number(m) - 1]} ${y}`;
+}
+
+function quarterLabel(p: EconomySeriesPoint): string {
+  if (!p.date) return String(p.year);
+  const [y, m] = p.date.split("-");
+  return `Q${Math.floor((Number(m) - 1) / 3) + 1} ${y}`;
+}
+
+// Each chart spans exactly the years it has data for, so short series fill
+// their own panel and long ones show their whole history — the x axis is no
+// longer shared across graphs.
+function domainLabels(domain: [number, number]): [string, string, string] {
+  const [a, b] = domain;
+  return [
+    String(Math.floor(a)),
+    String(Math.round((a + b) / 2)),
+    String(Math.floor(b)),
+  ];
+}
+
+const xs = (ps: EconomySeriesPoint[]) => ps.map((p) => p.year);
+
+// Restrict several series to the time keys they all report, so every line in
+// a combined chart has the same length.
+function align(
+  seriesList: EconomySeriesPoint[][],
+): { base: EconomySeriesPoint[]; values: number[][] } | null {
+  const key = (p: EconomySeriesPoint) => p.date ?? p.year;
+  const maps = seriesList.map((ps) => new Map(ps.map((p) => [key(p), p.value])));
+  const base = seriesList[0].filter((p) => maps.every((m) => m.has(key(p))));
+  if (base.length < 2) return null;
+  return { base, values: maps.map((m) => base.map((p) => m.get(key(p))!)) };
+}
+
+type SotnIndicator = {
+  n: string;
+  title: string;
+  verdict: Verdict;
+  headline: string;
+  body: string;
+  wide?: boolean;
+  build: (
+    get: Getter,
+  ) =>
+    | (Pick<SotnView, "stat" | "statSub" | "source" | "sourceUrl"> & {
+        spec: ChartSpec;
+      })
+    | null;
+};
+
+// Charts render in the shared x window (see buildIndicators) so the timelines
+// line up. A chart may pass an earlier `start` to reach further back, though
+// none currently does — every chart uses the shared 1980 start.
+const line = (
+  spec: Omit<LineSpec, "kind" | "xDomain" | "xLabels">,
+  start = sharedDomain[0],
+): LineSpec => {
+  const domain: [number, number] = [start, sharedDomain[1]];
+  return {
+    kind: "line",
+    xDomain: domain,
+    xLabels: domainLabels(domain),
+    ...spec,
+  };
+};
+
+// Splices an IRCC permanent-resident series into one annual line: archived
+// annual values for years before the cutover, then the ongoing monthly series
+// summed to complete calendar years from the cutover on. Complete years only —
+// a partial current year would read as a false collapse. Both slugs are
+// clipped to the shared window start by points().
+function spliceIrccAdmissions(
+  get: Getter,
+  historicalSlug: string,
+  monthlySlug: string,
+  cutover = 2015,
+): { year: number; value: number }[] {
+  const historical = points(get, historicalSlug);
+  const monthly = points(get, monthlySlug);
+  const byYear = new Map<number, { sum: number; n: number }>();
+  for (const p of monthly ?? []) {
+    const y = Math.floor(p.year);
+    const e = byYear.get(y) ?? { sum: 0, n: 0 };
+    e.sum += p.value;
+    e.n += 1;
+    byYear.set(y, e);
+  }
+  const out: { year: number; value: number }[] = [];
+  for (const p of historical ?? []) {
+    if (Math.floor(p.year) < cutover) out.push({ year: p.year, value: p.value });
+  }
+  for (const [y, e] of [...byYear].sort((a, b) => a[0] - b[0])) {
+    if (y >= cutover && e.n === 12) out.push({ year: y, value: e.sum });
+  }
+  out.sort((a, b) => a.year - b.year);
+  return out;
+}
+
+const INDICATORS: SotnIndicator[] = [
+  {
+    n: "01",
+    title: "GDP per capita",
+    verdict: "lag",
+    wide: true,
+    headline: "Living standards have gone sideways since 2022.",
+    body: "Real output per person, in chained 2017 dollars — the clearest single measure of whether living standards are rising. StatCan's quarterly series runs within about two months of the present, and it shows a country producing no more per person than it did four years ago.",
+    build: (get) => {
+      const ps = points(get, "gdp-per-capita-canada");
+      if (!ps) return null;
+      const latest = last(ps);
+      // Index to the first point (= 100) so the chart reads as cumulative
+      // growth in living standards rather than an abstract dollar level: the
+      // long climb and the post-2022 plateau both show at a glance. The
+      // headline stat keeps the concrete dollar figure.
+      const baseYear = Math.floor(ps[0].year);
+      const indexed = ps.map((p) => (p.value / ps[0].value) * 100);
+      return {
+        stat: `$${int(latest.value)}`,
+        statSub: `Real GDP per capita, chained 2017 $ · ${quarterLabel(latest)}`,
+        ...sourceLink(get, "gdp-per-capita-canada"),
+        spec: line({
+          unit: `Real GDP per capita (index, ${baseYear} = 100)`,
+          fmt: "index",
+          // Indexed series: frame around 100 with a floating baseline there,
+          // rather than anchoring the axis at zero.
+          baseline: 100,
+          legend: [{ label: "Canada", color: "au" }],
+          series: [{ color: "au", xs: xs(ps), points: indexed }],
+        }),
+      };
+    },
+  },
+  {
+    n: "02",
+    title: "Employment by age",
+    verdict: "mixed",
+    headline: "Core-age employment is near record highs; the young trail behind.",
+    body: "Share of each age group that is employed, monthly and seasonally adjusted. The 25–54 core-working-age line is the cleanest read — it strips out students and retirees.",
+    build: (get) => {
+      const core = points(get, "employment-rate-25-to-54");
+      const youth = points(get, "employment-rate-15-to-24");
+      const older = points(get, "employment-rate-55-to-64");
+      const all = points(get, "employment-rate-15-plus");
+      if (!core || !youth || !older || !all) return null;
+      const aligned = align([core, youth, older, all]);
+      if (!aligned) return null;
+      const latest = last(core);
+      return {
+        stat: `${latest.value.toFixed(1)}%`,
+        statSub: `Employment rate, 25–54 · ${monthLabel(latest)}`,
+        ...sourceLink(get, "employment-rate-25-to-54"),
+        spec: line({
+          unit: "Employment rate by age group",
+          fmt: "pct",
+          legend: [
+            { label: "25–54", color: "au" },
+            { label: "15–24", color: "clay" },
+            { label: "55–64", color: "stone" },
+            { label: "15+", color: "ink", dash: true },
+          ],
+          series: [
+            { color: "au", xs: xs(aligned.base), points: aligned.values[0] },
+            { color: "clay", xs: xs(aligned.base), points: aligned.values[1] },
+            { color: "stone", xs: xs(aligned.base), points: aligned.values[2] },
+            { color: "ink", dash: true, xs: xs(aligned.base), points: aligned.values[3] },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "03",
+    title: "Business entries",
+    verdict: "mixed",
+    headline: "Business entry has held up since 2000, but much of it is churn.",
+    body: "New business entries per year — businesses gaining a paid employee, including seasonal reopenings, not only first-ever formation. Two StatCan sources are chain-linked: the discontinued quarterly entry series (2000–2019, private sector) rescaled to meet the ongoing monthly openings series (2015→present, business sector) at their overlap, so the trend is continuous across the 2015 join. Source tables 33-10-0165 and 33-10-0270.",
+    build: (get) => {
+      const histRaw = points(get, "business-entries-historical");
+      const openRaw = points(get, "business-openings");
+      if (!histRaw || !openRaw) return null;
+      // Sum sub-annual points into complete calendar years only.
+      const annualize = (
+        ps: EconomySeriesPoint[],
+        perYear: number,
+      ): Map<number, number> => {
+        const acc = new Map<number, { sum: number; n: number }>();
+        for (const p of ps) {
+          const y = Math.floor(p.year);
+          const e = acc.get(y) ?? { sum: 0, n: 0 };
+          e.sum += p.value;
+          e.n += 1;
+          acc.set(y, e);
+        }
+        const out = new Map<number, number>();
+        for (const [y, e] of acc) if (e.n === perYear) out.set(y, e.sum);
+        return out;
+      };
+      const hist = annualize(histRaw, 4); // quarterly
+      const open = annualize(openRaw, 12); // monthly
+      // Chain-link: the two tables differ in scope (~11% level), so rescale the
+      // ongoing openings series to the historical level over their overlap,
+      // preserving the trend across the join.
+      const overlap = [...hist.keys()].filter((y) => open.has(y));
+      if (overlap.length === 0) return null;
+      const factor =
+        overlap.reduce((a, y) => a + hist.get(y)! / open.get(y)!, 0) /
+        overlap.length;
+      // Historical before the cutover, rescaled openings from it on.
+      const CUTOVER = 2015;
+      const series: { year: number; value: number }[] = [];
+      for (const [y, v] of hist) if (y < CUTOVER) series.push({ year: y, value: v });
+      for (const [y, v] of open) if (y >= CUTOVER) series.push({ year: y, value: v * factor });
+      series.sort((a, b) => a.year - b.year);
+      if (series.length < 2) return null;
+      const latest = series[series.length - 1];
+      return {
+        stat: int(latest.value),
+        statSub: `Business entries per year · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "business-openings"),
+        spec: line({
+          unit: "Business entries per year",
+          fmt: "count",
+          legend: [{ label: "Business entries", color: "au" }],
+          series: [
+            {
+              color: "au",
+              xs: series.map((p) => p.year),
+              points: series.map((p) => p.value),
+            },
+          ],
+        }),
+      };
+    },
+  },
+  /* Removed — redundant with "Employment by age" (02), which already carries
+     the 15-and-over line monthly. Kept commented for easy restore.
+  {
+    n: "04",
+    title: "Employment",
+    verdict: "lag",
+    headline: "The share of Canadians working has slipped for two straight years.",
+    body: "Share of the population aged 15 and over that is employed. The broadest gauge of whether people who could work, do.",
+    build: (get) => {
+      const ps = points(get, "employment-rate");
+      if (!ps) return null;
+      const latest = last(ps);
+      return {
+        stat: `${latest.value.toFixed(1)}%`,
+        statSub: `Employment rate, 15+ · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "employment-rate"),
+        spec: line({
+          unit: "Employment rate, ages 15 and over",
+          fmt: "pct",
+          legend: [{ label: "Canada", color: "au" }],
+          series: [{ color: "au", xs: xs(ps), points: ps.map((p) => p.value) }],
+        }),
+      };
+    },
+  },
+  */
+  {
+    n: "05",
+    title: "Wage growth",
+    verdict: "mixed",
+    headline: "Average pay keeps pulling away from the median — gains tilt to the top.",
+    body: "Hourly wages for all employees, adjusted for inflation with the all-items CPI and expressed in the latest year's dollars. StatCan's public API carries no 10th or 90th percentile series, so average vs median is the closest available dispersion signal: when the average pulls away from the median, gains are concentrating at the top.",
+    build: (get) => {
+      const avg = points(get, "average-hourly-wage");
+      const med = points(get, "median-hourly-wage");
+      if (!avg || !med) return null;
+      const aligned = align([avg, med]);
+      if (!aligned) return null;
+      const deflator = cpiDeflator(get);
+      const real = (values: number[]) =>
+        deflator
+          ? values.map((v, i) => deflator.toReal(v, aligned.base[i].year))
+          : values;
+      const [realAvg, realMed] = [real(aligned.values[0]), real(aligned.values[1])];
+      const latest = last(aligned.base);
+      return {
+        stat: `$${realAvg[realAvg.length - 1].toFixed(2)}`,
+        statSub: `Average hourly wage${deflator ? `, ${deflator.baseYear} dollars` : ""} · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "average-hourly-wage"),
+        spec: line({
+          unit: deflator
+            ? `Real hourly wages, average vs median (${deflator.baseYear} dollars)`
+            : "Hourly wages, average vs median",
+          fmt: "money",
+          legend: [
+            { label: "Average", color: "au" },
+            { label: "Median", color: "ink", dash: true },
+          ],
+          series: [
+            { color: "au", xs: xs(aligned.base), points: realAvg },
+            { color: "ink", dash: true, xs: xs(aligned.base), points: realMed },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "06",
+    title: "Investment position",
+    verdict: "lag",
+    headline: "Canada now holds far more investment abroad than the world holds here.",
+    body: "The accumulated book value of direct investment — how much foreign capital is parked in Canada versus how much Canadian capital is parked abroad (StatCan table 36-10-0008, annual since 1987). In the late 1980s more foreign investment sat in Canada than Canadian investment sat abroad; the two crossed around 2000 and the gap has widened steadily since. Book value, not inflation-adjusted.",
+    build: (get) => {
+      const inCanada = points(get, "fdi-position-in-canada");
+      const abroad = points(get, "cdi-position-abroad");
+      if (!inCanada || !abroad) return null;
+      const aligned = align([inCanada, abroad]);
+      if (!aligned) return null;
+      // Plot in $ billions; the raw series are in $ millions.
+      const inB = aligned.values[0].map((v) => v / 1000);
+      const outB = aligned.values[1].map((v) => v / 1000);
+      // Net international direct-investment position: what sits in Canada minus
+      // what Canadians hold abroad. Negative = Canada is a net outward owner.
+      const net = inB[inB.length - 1] - outB[outB.length - 1];
+      const latest = last(aligned.base);
+      return {
+        stat: `${net < 0 ? "−" : "+"}$${int(Math.abs(net))}B`,
+        statSub: `Net direct investment position · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "fdi-position-in-canada"),
+        spec: line({
+          unit: "Direct investment position: in Canada vs abroad ($B)",
+          fmt: "count",
+          legend: [
+            { label: "Foreign-owned in Canada", color: "au" },
+            { label: "Canadian-owned abroad", color: "ink", dash: true },
+          ],
+          series: [
+            { color: "au", xs: xs(aligned.base), points: inB },
+            { color: "ink", dash: true, xs: xs(aligned.base), points: outB },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "07",
+    title: "Capital formation",
+    verdict: "mixed",
+    headline: "Investment holds near 23 per cent of GDP — enough to maintain, not to catch up.",
+    body: "Gross capital formation as a share of GDP — how much of the economy is devoted to building future capacity: machinery, technology, buildings, and infrastructure.",
+    build: (get) => {
+      const ps = points(get, "capital-formation-pct-gdp");
+      if (!ps) return null;
+      const latest = last(ps);
+      return {
+        stat: `${latest.value.toFixed(1)}%`,
+        statSub: `Gross capital formation, % of GDP · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "capital-formation-pct-gdp"),
+        spec: line({
+          unit: "Gross capital formation, share of GDP",
+          fmt: "pct",
+          legend: [{ label: "Canada", color: "au" }],
+          series: [{ color: "au", xs: xs(ps), points: ps.map((p) => p.value) }],
+        }),
+      };
+    },
+  },
+  {
+    n: "08",
+    title: "Net financial debt",
+    verdict: "lead",
+    headline: "Net financial debt sits near its lowest since 1990, far below the mid-1990s peak.",
+    body: "Every level of government — federal, provincial, local, CPP and QPP — on a national-balance-sheet basis. This is net financial debt: total liabilities minus financial assets (the pension plans' holdings included). It excludes tangible capital assets like roads and buildings, and it is the honest measure of the public sector's financial position. Gross debt ignores the assets held against those liabilities and overstates the burden; a net-worth measure would wrongly net out non-financial assets. This is neither — just liabilities net of financial assets.",
+    build: (get) => {
+      const net = points(get, "govt-net-debt-to-gdp");
+      if (!net) return null;
+      const latest = last(net);
+      return {
+        stat: `${Math.round(latest.value)}%`,
+        statSub: `General government net financial debt to GDP · ${quarterLabel(latest)}`,
+        ...sourceLink(get, "govt-net-debt-to-gdp"),
+        spec: line({
+          unit: "Government net financial debt, share of GDP",
+          fmt: "pct",
+          legend: [{ label: "Net financial debt", color: "au" }],
+          series: [{ color: "au", xs: xs(net), points: net.map((p) => p.value) }],
+        }),
+      };
+    },
+  },
+  {
+    n: "09",
+    title: "Public vs private jobs",
+    verdict: "lag",
+    headline: "Public-sector hiring has outpaced the private economy since the pandemic.",
+    body: "Each class of worker as a share of all employment, monthly and seasonally adjusted. Since early 2020 the public-sector headcount has grown roughly twice as fast as the private sector's — a mix shift the economy has to carry.",
+    build: (get) => {
+      const total = points(get, "employment-all-classes");
+      const priv = points(get, "employment-private-sector");
+      const pub = points(get, "employment-public-sector");
+      const self = points(get, "employment-self-employed");
+      if (!total || !priv || !pub || !self) return null;
+      const aligned = align([total, pub, priv, self]);
+      if (!aligned) return null;
+      const [totalV, pubV, privV, selfV] = aligned.values;
+      const share = (series: number[]) =>
+        series.map((v, i) => (v / totalV[i]) * 100);
+      const pubShare = share(pubV);
+      const latest = last(aligned.base);
+      return {
+        stat: `${pubShare[pubShare.length - 1].toFixed(1)}%`,
+        statSub: `Public share of employment · ${monthLabel(latest)}`,
+        ...sourceLink(get, "employment-all-classes"),
+        spec: line({
+          unit: "Employment share by class of worker",
+          fmt: "pct",
+          legend: [
+            { label: "Public sector", color: "au" },
+            { label: "Private sector", color: "ink", dash: true },
+            { label: "Self-employed", color: "stone" },
+          ],
+          series: [
+            { color: "au", xs: xs(aligned.base), points: pubShare },
+            { color: "ink", dash: true, xs: xs(aligned.base), points: share(privV) },
+            { color: "stone", xs: xs(aligned.base), points: share(selfV) },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "10",
+    title: "Consumer prices",
+    verdict: "lag",
+    headline: "Inflation broke above target in 2021–22 and is only now easing back toward 2%.",
+    body: "The 12-month change in the all-items Consumer Price Index — the headline inflation rate, month by month. The dashed line is the Bank of Canada's 2% target. After four decades of gradual disinflation from the double-digit early 1980s, inflation spiked above 8% in 2022 before easing back toward target.",
+    build: (get) => {
+      // Raw (unclipped) monthly CPI so the year-over-year rate is defined right
+      // at the 1980 window start — computing 1980's rate needs 1979's index.
+      const raw = get("cpi-all-items")?.data.series.find(
+        (s) => s.jurisdiction.slug === "ca",
+      )?.points;
+      if (!raw || raw.length < 13) return null;
+      const byMonth = new Map(
+        raw.filter((p) => p.date).map((p) => [p.date!, p.value]),
+      );
+      // 12-month percentage change for each month with a value a year earlier,
+      // kept from the shared window start on.
+      const rate = raw.flatMap((p) => {
+        if (!p.date) return [];
+        const prior = byMonth.get(
+          `${Number(p.date.slice(0, 4)) - 1}${p.date.slice(4)}`,
+        );
+        if (prior === undefined || p.year < sharedDomain[0]) return [];
+        return [{ year: p.year, value: (p.value / prior - 1) * 100 }];
+      });
+      if (rate.length < 2) return null;
+      const rateXs = rate.map((p) => p.year);
+      return {
+        stat: `${rate[rate.length - 1].value.toFixed(1)}%`,
+        statSub: `CPI inflation, 12-month change · ${monthLabel(raw[raw.length - 1])}`,
+        ...sourceLink(get, "cpi-all-items"),
+        spec: line({
+          unit: "Consumer price inflation vs the 2% target",
+          fmt: "pct1",
+          legend: [
+            { label: "Inflation (12-month)", color: "au" },
+            { label: "2% target", color: "ink", dash: true },
+          ],
+          series: [
+            { color: "au", xs: rateXs, points: rate.map((p) => p.value) },
+            { color: "ink", dash: true, xs: rateXs, points: rate.map(() => 2) },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "11",
+    title: "Housing affordability",
+    verdict: "lag",
+    headline: "House prices have swung from below their long-term norm to roughly 50% above it.",
+    body: "The OECD's headline affordability measure, indexed so 100 is the long-term average of Canada's house-price-to-income ratio. Below the line, homes are cheaper than the historical norm relative to incomes; above it, more stretched. Canada sat below through the 1990s and 2000s, crossed the norm around 2009, and now runs about fifty per cent above — among the most stretched in the developed world.",
+    build: (get) => {
+      const ps = points(get, "house-price-to-income");
+      if (!ps) return null;
+      const latest = last(ps);
+      return {
+        stat: `+${Math.round(latest.value - 100)}%`,
+        statSub: `Above the long-term price-to-income average · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "house-price-to-income"),
+        spec: line({
+          unit: "House-price-to-income ratio (100 = long-term average)",
+          fmt: "index",
+          // Index where 100 = the long-term norm: frame around it with a
+          // floating baseline instead of anchoring at zero.
+          baseline: 100,
+          legend: [{ label: "Canada", color: "au" }],
+          series: [{ color: "au", xs: xs(ps), points: ps.map((p) => p.value) }],
+        }),
+      };
+    },
+  },
+  {
+    n: "12",
+    title: "Housing starts",
+    verdict: "lag",
+    headline: "Per person, Canada builds barely half as many homes as it did in the 1970s.",
+    body: "Dwelling units started each year per 1,000 people, from CMHC's starts and completions survey against StatCan's population estimates. In absolute terms starts are back near their 1970s highs — but the population has more than doubled since then, so on a per-person basis homebuilding runs at roughly half the mid-1970s rate. This is the honest read on whether supply is keeping up with the people who need homes.",
+    build: (get) => {
+      const ps = points(get, "housing-starts-canada");
+      const pop = points(get, "population-canada");
+      if (!ps || !pop) return null;
+      // Population is quarterly; collapse it to a calendar-year average so it
+      // divides the annual starts flow cleanly. Then express starts per 1,000
+      // people — the only way to compare a period over which the population
+      // more than doubled.
+      const popByYear = new Map<number, { sum: number; n: number }>();
+      for (const p of pop) {
+        const y = Math.floor(p.year);
+        const e = popByYear.get(y) ?? { sum: 0, n: 0 };
+        e.sum += p.value;
+        e.n += 1;
+        popByYear.set(y, e);
+      }
+      const perCapita = ps.flatMap((p) => {
+        const e = popByYear.get(Math.floor(p.year));
+        return e ? [{ year: p.year, value: (p.value / (e.sum / e.n)) * 1000 }] : [];
+      });
+      if (perCapita.length < 2) return null;
+      const latest = perCapita[perCapita.length - 1];
+      return {
+        stat: latest.value.toFixed(1),
+        statSub: `Dwelling units started per 1,000 people · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "housing-starts-canada"),
+        spec: line({
+          unit: "Housing starts per 1,000 people",
+          fmt: "num",
+          legend: [{ label: "Starts per 1,000", color: "au" }],
+          series: [
+            {
+              color: "au",
+              xs: perCapita.map((p) => p.year),
+              points: perCapita.map((p) => p.value),
+            },
+          ],
+        }),
+      };
+    },
+  },
+  {
+    n: "13",
+    title: "Net emigration",
+    verdict: "mixed",
+    headline: "The counterflow is growing: more people leave than come back.",
+    body: "Emigrants minus returning emigrants, on StatCan's July–June demographic years (the 2024 point covers July 2023 to June 2024). StatCan stopped publishing its own net series after a 2016 methodology change, so this line is derived from the components.",
+    build: (get) => {
+      const emigrants = points(get, "emigrants-annual");
+      const returning = points(get, "returning-emigrants-annual");
+      if (!emigrants || !returning) return null;
+      const aligned = align([emigrants, returning]);
+      if (!aligned) return null;
+      const net = aligned.values[0].map((v, i) => v - aligned.values[1][i]);
+      const latest = last(aligned.base);
+      return {
+        stat: int(net[net.length - 1]),
+        statSub: `Net emigration · ${Math.floor(latest.year)} (July–June year)`,
+        ...sourceLink(get, "emigrants-annual"),
+        spec: line({
+          unit: "Emigrants, net of returning Canadians",
+          fmt: "count",
+          legend: [{ label: "Net emigration", color: "au" }],
+          series: [{ color: "au", xs: xs(aligned.base), points: net }],
+        }),
+      };
+    },
+  },
+  {
+    n: "14",
+    title: "Permanent residents",
+    verdict: "lead",
+    headline: "Still one of the world's great immigration destinations — intake is easing off record highs.",
+    body: "Permanent residents admitted per calendar year. Two IRCC sources are spliced into one continuous line: the archived by-category series (1980–2015) for the historical years, and IRCC's ongoing monthly admissions (summed to calendar years) from 2015 on. Handled well, this is an engine of growth; handled poorly, it strains the housing and services shown elsewhere on this page.",
+    build: (get) => {
+      const series = spliceIrccAdmissions(
+        get,
+        "pr-admissions-annual-historical",
+        "pr-admissions-total",
+      );
+      if (series.length < 2) return null;
+      const latest = series[series.length - 1];
+      return {
+        stat: int(latest.value),
+        statSub: `Permanent residents admitted · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "pr-admissions-total"),
+        spec: line({
+          unit: "Permanent residents admitted per year",
+          fmt: "count",
+          legend: [{ label: "PR admissions", color: "au" }],
+          series: [
+            {
+              color: "au",
+              xs: series.map((p) => p.year),
+              points: series.map((p) => p.value),
+            },
+          ],
+        }),
+      };
+    },
+  },
+  /* Temporarily disabled — the NPR-by-type series only start 2021 Q3, which
+     forced the shared chart window forward to 2021. Re-enable together with
+     the "npr-work-permit-holders" / "npr-total" slugs above; note that doing
+     so pulls every chart's window back to 2021.
+  {
+    n: "15",
+    title: "Temporary foreign workers",
+    verdict: "mixed",
+    headline: "After more than doubling in three years, the work-permit population is unwinding.",
+    body: "People holding a work permit on the first day of each quarter — a stock, not a flow, and the closest public measure of \"temporary foreign workers\" (no StatCan series exists under that name). The dashed line is all non-permanent residents. The series only begins in mid-2021.",
+    build: (get) => {
+      const permits = points(get, "npr-work-permit-holders");
+      const total = points(get, "npr-total");
+      if (!permits || !total) return null;
+      const aligned = align([permits, total]);
+      if (!aligned) return null;
+      const latest = last(aligned.base);
+      return {
+        stat: `${(last(permits).value / 1_000_000).toFixed(2)}M`,
+        statSub: `Work-permit holders · ${quarterLabel(latest)}`,
+        ...sourceLink(get, "npr-work-permit-holders"),
+        spec: line({
+          unit: "Work-permit holders vs all non-permanent residents",
+          fmt: "count",
+          legend: [
+            { label: "Work permits", color: "au" },
+            { label: "All non-permanent residents", color: "ink", dash: true },
+          ],
+          series: [
+            { color: "au", xs: xs(aligned.base), points: aligned.values[0] },
+            { color: "ink", dash: true, xs: xs(aligned.base), points: aligned.values[1] },
+          ],
+        }),
+      };
+    },
+  },
+  */
+  {
+    n: "16",
+    title: "By class",
+    verdict: "mixed",
+    headline: "A shrinking intake, still anchored by the economic class.",
+    body: "Permanent residents admitted per year by immigration class. Two IRCC sources are spliced per class: the archived by-category series through 2014, then the ongoing monthly admissions (summed to calendar years) from 2015 on. IRCC rounds counts and suppresses small cells, so values are approximate; the archived 'Other' bucket is narrower than today's, so that line's pre-2015 level isn't directly comparable. Students are not a PR class — they appear under work and study permits.",
+    build: (get) => {
+      const economic = spliceIrccAdmissions(get, "pr-admissions-economic-historical", "pr-admissions-economic");
+      const family = spliceIrccAdmissions(get, "pr-admissions-family-historical", "pr-admissions-family");
+      const refugee = spliceIrccAdmissions(get, "pr-admissions-refugee-historical", "pr-admissions-refugee");
+      const other = spliceIrccAdmissions(get, "pr-admissions-other-historical", "pr-admissions-other");
+      const total = spliceIrccAdmissions(get, "pr-admissions-annual-historical", "pr-admissions-total");
+      if (economic.length < 2 || total.length < 2) return null;
+      const latest = total[total.length - 1];
+      const pts = (s: { year: number; value: number }[]) => ({
+        xs: s.map((p) => p.year),
+        points: s.map((p) => p.value),
+      });
+      return {
+        stat: int(latest.value),
+        statSub: `Permanent residents admitted, by class · ${Math.floor(latest.year)}`,
+        ...sourceLink(get, "pr-admissions-total"),
+        spec: line({
+          unit: "Permanent-resident admissions by class",
+          fmt: "count",
+          legend: [
+            { label: "Economic", color: "au" },
+            { label: "Total", color: "ink", dash: true },
+            { label: "Family", color: "clay" },
+            { label: "Refugee", color: "stone" },
+            { label: "Other", color: "sand" },
+          ],
+          series: [
+            { color: "au", ...pts(economic) },
+            { color: "ink", dash: true, ...pts(total) },
+            { color: "clay", ...pts(family) },
+            { color: "stone", ...pts(refugee) },
+            { color: "sand", ...pts(other) },
+          ],
+        }),
+      };
+    },
+  },
+];
+
+export const SOTN_INDICATOR_COUNT = INDICATORS.length;
+
+// Section grouping for the page: charts keep their continuous 01–16
+// numbering; each section renders its own header and card grid.
+const SECTION_DEFS = [
+  {
+    id: "economy",
+    title: "Economy",
+    ns: ["01", "02", "03", "04", "05", "06", "07"],
+  },
+  {
+    id: "government-sustainability",
+    title: "Government Sustainability",
+    ns: ["08", "09"],
+  },
+  { id: "cost-of-living", title: "Cost of Living", ns: ["10", "11", "12"] },
+  { id: "immigration", title: "Immigration", ns: ["13", "14", "15", "16"] },
+];
+
+export type SotnSection = {
+  id: string;
+  title: string;
+  indicators: SotnView[];
+};
+
+export function buildSections(get: Getter): SotnSection[] {
+  const views = buildIndicators(get);
+  return SECTION_DEFS.map((def) => ({
+    id: def.id,
+    title: def.title,
+    indicators: views.filter((view) => def.ns.includes(view.n)),
+  })).filter((section) => section.indicators.length > 0);
+}
+
+export function buildIndicators(get: Getter): SotnView[] {
+  // Standardize charts on one x window: a fixed start of 1980 through the
+  // latest point any series reports. Series that don't reach back to 1980
+  // begin partway in, leaving their early years blank.
+  let maxEnd = -Infinity;
+  for (const slug of SOTN_MEASURE_SLUGS) {
+    const series = get(slug)?.data.series.find(
+      (s) => s.jurisdiction.slug === "ca",
+    );
+    if (!series || series.points.length < 2) continue;
+    maxEnd = Math.max(maxEnd, series.points[series.points.length - 1].year);
+  }
+  sharedDomain = [1980, Number.isFinite(maxEnd) ? maxEnd : 1981];
+
+  return INDICATORS.flatMap((indicator) => {
+    const built = indicator.build(get);
+    if (!built) return [];
+    return [
+      {
+        n: indicator.n,
+        title: indicator.title,
+        verdict: indicator.verdict,
+        headline: indicator.headline,
+        body: indicator.body,
+        wide: indicator.wide,
+        ...built,
+      },
+    ];
+  });
+}
diff --git a/src/app/prosperity-dashboard/units.ts b/src/app/state-of-the-nation/units.ts
similarity index 86%
rename from src/app/prosperity-dashboard/units.ts
rename to src/app/state-of-the-nation/units.ts
index 2d90acc..657ffe7 100644
--- a/src/app/prosperity-dashboard/units.ts
+++ b/src/app/state-of-the-nation/units.ts
@@ -51,6 +51,31 @@ const UNIT_DISPLAY: Record<string, UnitDisplay> = {
     axisLabel: "million $",
     formatValue: (v) => `$${int(v)}M`,
   },
+  // CAD levels (e.g. hourly wage rates in current dollars).
+  $: {
+    name: "CAD",
+    shortUnit: "$",
+    numDecimalPlaces: 2,
+    axisLabel: "$",
+    formatValue: (v) => `$${v.toFixed(2)}`,
+  },
+  count: {
+    name: "count",
+    shortUnit: "",
+    numDecimalPlaces: 0,
+    axisLabel: "count",
+    formatValue: int,
+  },
+  // Values arrive in thousands (e.g. LFS employment levels); convert to
+  // persons so Grapher's magnitude abbreviations ("20 million") come out true.
+  count_thousands: {
+    name: "persons",
+    shortUnit: "",
+    numDecimalPlaces: 0,
+    conversionFactor: 1_000,
+    axisLabel: "thousands",
+    formatValue: (v) => `${int(v)}k`,
+  },
   index: {
     name: "index",
     shortUnit: "",
diff --git a/src/app/prosperity-dashboard/useChartSize.ts b/src/app/state-of-the-nation/useChartSize.ts
similarity index 100%
rename from src/app/prosperity-dashboard/useChartSize.ts
rename to src/app/state-of-the-nation/useChartSize.ts
diff --git a/src/components/custom/signpost/config.ts b/src/components/custom/signpost/config.ts
index d739518..0736dde 100644
--- a/src/components/custom/signpost/config.ts
+++ b/src/components/custom/signpost/config.ts
@@ -14,7 +14,7 @@ export interface SignpostProps {
   shareTitle?: string;
   shareUrl?: string;
   // Pages with an extra sticky bar below the global navbar (e.g. the
-  // prosperity-dashboard section nav) push the rail and scroll target down,
+  // state-of-the-nation section nav) push the rail and scroll target down,
   // and may already have their own narrow-screen navigation.
   desktopTopClass?: string;
   scrollOffset?: number;
diff --git a/src/lib/api/economy.ts b/src/lib/api/economy.ts
index cc25adb..7651dc8 100644
--- a/src/lib/api/economy.ts
+++ b/src/lib/api/economy.ts
@@ -28,11 +28,12 @@ export interface EconomySeriesJurisdiction {
   level: string;
 }
 
-// The API serves annual points as { year, value } and monthly points
-// (measure.frequency === "monthly") as { date, value }. getEconomicSeries
-// normalizes both to a numeric `year` time axis — fractional for monthly
-// (year + monthIndex / 12) — so charts keep a single numeric x dimension,
-// with the ISO first-of-month date preserved for date formatting.
+// The API serves annual points as { year, value }; monthly and quarterly
+// points (per measure.frequency) both come as { date, value }, where a
+// quarterly date is the first day of the quarter. getEconomicSeries
+// normalizes all shapes to a numeric `year` time axis — fractional for dated
+// points (year + monthIndex / 12) — so charts keep a single numeric x
+// dimension, with the ISO date preserved for date formatting.
 export interface EconomySeriesPoint {
   year: number;
   date?: string;
@@ -91,6 +92,19 @@ const SOURCE_NAMES: Record<string, string> = {
   econ_owid_corruption_perceptions:
     "Transparency International via Our World in Data",
   econ_owid_co2_per_capita: "Global Carbon Budget via Our World in Data",
+  econ_statcan_gdp_per_capita: "Statistics Canada (table 36-10-0706)",
+  econ_statcan_employment_rate_by_age: "Statistics Canada (table 14-10-0287)",
+  econ_statcan_employment_by_class: "Statistics Canada (table 14-10-0288)",
+  econ_statcan_hourly_wages: "Statistics Canada (table 14-10-0064)",
+  econ_statcan_business_dynamics: "Statistics Canada (table 33-10-0270)",
+  econ_statcan_fdi_flows: "Statistics Canada (table 36-10-0025)",
+  econ_statcan_investment_position: "Statistics Canada (table 36-10-0008)",
+  econ_statcan_capital_formation: "Statistics Canada (table 36-10-0104)",
+  econ_statcan_govt_debt_to_gdp: "Statistics Canada (table 38-10-0237)",
+  econ_statcan_population_components: "Statistics Canada (table 17-10-0008)",
+  econ_statcan_population_total: "Statistics Canada (table 17-10-0009)",
+  econ_statcan_npr_by_type: "Statistics Canada (table 17-10-0121)",
+  econ_ircc_pr_admissions: "Immigration, Refugees and Citizenship Canada",
 };
 
 export function humanizeSourceName(name: string): string {
@@ -114,6 +128,18 @@ const STATCAN_TABLES: Record<string, string> = {
   econ_statcan_crime_rate: "35-10-0177",
   econ_statcan_cpi_essentials: "18-10-0004",
   econ_statcan_gdp_monthly: "36-10-0434",
+  econ_statcan_gdp_per_capita: "36-10-0706",
+  econ_statcan_employment_rate_by_age: "14-10-0287",
+  econ_statcan_employment_by_class: "14-10-0288",
+  econ_statcan_hourly_wages: "14-10-0064",
+  econ_statcan_business_dynamics: "33-10-0270",
+  econ_statcan_fdi_flows: "36-10-0025",
+  econ_statcan_investment_position: "36-10-0008",
+  econ_statcan_capital_formation: "36-10-0104",
+  econ_statcan_govt_debt_to_gdp: "38-10-0237",
+  econ_statcan_population_components: "17-10-0008",
+  econ_statcan_population_total: "17-10-0009",
+  econ_statcan_npr_by_type: "17-10-0121",
 };
 
 export function humanizeSourceUrl(
@@ -123,6 +149,10 @@ export function humanizeSourceUrl(
   const table = STATCAN_TABLES[name];
   if (table)
     return `https://www150.statcan.gc.ca/t1/tbl1/en/tv.action?pid=${table.replaceAll("-", "")}01`;
+  // IRCC's source URL is the raw open-data CSV; link to the dataset's
+  // public landing page instead.
+  if (name === "econ_ircc_pr_admissions")
+    return "https://open.canada.ca/data/en/dataset/f7e5498e-0ad8-4417-85c9-9b8aff9b9eda";
   // World Bank source URLs are raw API queries (JSON dumps); link to the
   // public indicator page instead. Worldwide Governance Indicators carry a
   // GOV_WGI_ prefix in the API's source=3 dataset that the public catalog
@@ -132,6 +162,13 @@ export function humanizeSourceUrl(
   );
   if (worldBank)
     return `https://data.worldbank.org/indicator/${worldBank[1].replace(/^GOV_WGI_/, "")}`;
+  // OECD source URLs are raw SDMX CSV queries; deep-link the OECD Data
+  // Explorer for the same agency + dataflow instead.
+  const oecd = url?.match(
+    /^https:\/\/sdmx\.oecd\.org\/public\/rest\/data\/([^,]+),([^,]+),/,
+  );
+  if (oecd)
+    return `https://data-explorer.oecd.org/vis?df[ds]=dsDisseminate&df[id]=${encodeURIComponent(oecd[2])}&df[ag]=${encodeURIComponent(oecd[1])}`;
   return url;
 }
 
@@ -148,10 +185,20 @@ function normalizePoint(point: RawSeriesPoint): EconomySeriesPoint {
 
 export async function getEconomicSeries(
   measure: string,
+  options?: {
+    // Comma-separated jurisdiction slugs (e.g. "ca") to fetch a subset of a
+    // measure's series; omit for all jurisdictions.
+    jurisdictions?: string;
+  },
 ): Promise<EconomySeriesResponse> {
   const response = await apiFetch<EconomySeriesResponse>("/kpis/series", {
     revalidate: REVALIDATE,
-    params: { measure },
+    params: {
+      measure,
+      ...(options?.jurisdictions
+        ? { jurisdictions: options.jurisdictions }
+        : {}),
+    },
   });
   return {
     ...response,
diff --git a/src/lib/schemas/generators/breadcrumb.ts b/src/lib/schemas/generators/breadcrumb.ts
index c0d855f..9c46564 100644
--- a/src/lib/schemas/generators/breadcrumb.ts
+++ b/src/lib/schemas/generators/breadcrumb.ts
@@ -3,7 +3,7 @@ const ROUTE_LABELS: Record<string, string> = {
   about: "About",
   projects: "Projects",
   content: "Content",
-  "prosperity-dashboard": "Prosperity Dashboard",
+  "state-of-the-nation": "State of the Nation",
 };
 
 export function generateBreadcrumbSchema(