daily largest-events refresh

README.md

@@ -0,0 +1,126 @@
+---
+pretty_name: Largest US layoff events since 1988 - WARN Act notices clustered by employer
+license: cc-by-4.0
+language:
+  - en
+task_categories:
+  - tabular-classification
+tags:
+  - layoffs
+  - largest-layoffs
+  - biggest-layoffs
+  - layoff-events
+  - mass-layoffs
+  - warn-act
+  - warn-notices
+  - entity-resolution
+  - labor-market
+  - corporate-events
+  - public-records
+  - government-data
+  - alternative-data
+  - united-states
+  - daily-updated
+  - tabular
+size_categories:
+  - 1K<n<10K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/largest_layoff_events.csv
+---
+
+# The 1,000 largest US layoff events on record under the WARN Act, 1988-2026
+
+**Rebuilt 2026-09-12. Largest on file: United Airlines, 2020-07-01 to 2020-10-01 — 45,360
+workers across 25 notices in 14 state(s). The table's floor is
+835 workers; 558 of the 1,000 events span more than one notice and
+380 span more than one state.**
+
+A state WARN portal lists one row per site per notice. "What was the biggest layoff?" is an
+employer-level question, and answering it takes three steps no portal performs: 48 agencies'
+notices normalized into one schema daily, an employer's many spellings resolved to one name
+(Boeing files under 22 of them, typos included), and its rolling per-site notices clustered into
+one event. This dataset is the result, top 1,000 by reported workers, rebuilt daily.
+
+![Largest layoff events by reported workers](chart.svg)
+
+## Read this before quoting a rank
+
+* **Coverage is uneven before ~2020.** The archive reaches back to 1988 only for the states
+  whose portals kept history (Illinois and Oregon among them); most states begin between 2010
+  and 2023. `states_covered_in_year` says how many states the archive holds for the event's
+  year — an early-year rank is a rank among the states we hold, not the country.
+* **An event is one employer's notices with no gap longer than 45 days between consecutive
+  notice dates, and no longer than 183 days end to end.** A rolling programme is one event;
+  a later round, or the seventh month of a continuous programme, is a separate event.
+* **`workers_reported` can overstate a rolling programme.** Exact duplicate rows (same state,
+  location, count, notice date and effective date) are dropped (`duplicates_dropped`), but successive
+  notices for the same site are summed because a portal does not say whether the second is
+  cumulative. `sites` is the conservative companion figure.
+* **`single_notice=true` means the whole event is one portal row.** It is only as reliable as
+  that row; check it at the source before repeating it.
+* Employer names are resolved by [`alias_merge.py`](https://github.com/APVentureEngine/warn-act-notices/blob/main/product/alias_merge.py)
+  (token signature + purity-guarded prefix absorption); the resolver ships in this repo. It
+  merges spellings, not corporate parents: subsidiaries filing under their own names are their
+  own employers.
+* The current year is a running total; `event_open=true` marks events that may still grow.
+
+## Top 20 right now
+
+| # | employer | period | workers | notices | states |
+|---|---|---|---|---|---|
+| 1 | United Airlines | 2020-07-01 to 2020-10-01 | 45,360 | 25 | CA;CO;FL;HI;IL;IN;MN;NJ;NV;NY;OH;PA;VA;WA |
+| 2 | OS Restaurant | 2020-03-15 to 2020-05-15 | 38,688 | 128 | CA;FL;IN;KS;MD;MO;NC;NY;OH;PA;SC;TN |
+| 3 | Northwest Airlines | 1998-08-11 to 1998-08-11 | 27,500 | 1 | OR |
+| 4 | usi services group | 2020-03-01 to 2020-03-01 | 23,695 | 1 | NJ |
+| 5 | United Airlines | 2002-12-30 to 2002-12-30 | 18,636 | 2 | IL |
+| 6 | Walt Disney Parks and Resorts U.S | 2020-09-30 to 2020-11-18 | 17,780 | 19 | CA;FL |
+| 7 | Tend Exchange Subsidiary LLC and Delaware Tender Staffing | 2025-05-20 to 2025-05-20 | 16,132 | 1 | CA |
+| 8 | Delaware North | 2020-06-04 to 2020-07-28 | 14,210 | 32 | CA;CO;FL;MD;MI;MO;NY;OH;OK;SC;TN;VA;WI |
+| 9 | David's Bridal | 2023-04-14 to 2023-08-11 | 12,964 | 78 | AK;AL;CA;CO;CT;GA;MA;ME;MN;MO;NC;NE;NJ;NM;NV;NY;OH;OR;TN;TX;WA;WI |
+| 10 | Yellow | 2023-07-30 to 2023-08-18 | 12,146 | 73 | AL;AZ;CA;CO;DC;FL;ID;IL;IN;KS;ME;MI;MN;NC;ND;NM;NV;NY;OH;TX;VA;WA;WI |
+| 11 | HMSHost | 2020-03-20 to 2020-08-18 | 12,080 | 78 | AK;CA;CO;DE;FL;HI;IL;MI;MO;NC;NJ;NV;NY;OH;OR;TN;WA |
+| 12 | Ideal US Talent Systems Worker OpCo | 2026-05-04 to 2026-05-29 | 11,973 | 3 | GA;IL;RI |
+| 13 | Cinemark | 2020-03-26 to 2020-04-17 | 11,297 | 140 | AZ;CA;CT;ID;IL;IN;KS;MD;MI;MT;NC;NV;NY;OH;PA;SC;TN;TX;UT;VA;WA;WI |
+| 14 | Tesla | 2020-05-12 to 2020-05-12 | 11,239 | 2 | CA |
+| 15 | Marriott Hotel Services | 2020-03-13 to 2020-06-11 | 10,853 | 32 | CA;CT;FL;NY;PA;TN;VA;WA |
+| 16 | Great Atlantic and Pacific Tea | 2015-07-01 to 2015-11-12 | 10,039 | 102 | CT;NJ;PA |
+| 17 | American Airlines | 2020-07-15 to 2020-07-29 | 10,013 | 15 | CA;CO;IL;NC;NY;OK;WA |
+| 18 | Aramark | 2020-07-31 to 2020-11-18 | 9,977 | 50 | CA;CO;DC;DE;FL;IL;IN;MD;MI;MO;NJ;NV;NY;OH;OK;PA;TX;WA;WI |
+| 19 | Hyatt Regency | 2020-03-21 to 2020-07-08 | 9,477 | 49 | CA;CO;DC;FL;HI;IL;MD;MN;NY;OH;OR;TX;VA;WI |
+| 20 | Boeing | 2020-06-08 to 2020-10-19 | 8,783 | 12 | CA;WA |
+
+## Columns
+
+| column | meaning |
+|---|---|
+| `rank` | position by `workers_reported` (ties: earlier start first) |
+| `employer` | most frequent canonical spelling inside the event |
+| `event_start`, `event_end`, `year` | first and last notice date; `year` is the start year |
+| `workers_reported` | sum of `employees_affected` over the event's de-duplicated notices |
+| `notices`, `notices_with_worker_count` | notices in the event; how many carried a count |
+| `sites` | distinct state + location pairs |
+| `states`, `states_count` | semicolon-separated state codes |
+| `largest_single_notice`, `largest_notice_state`, `largest_notice_location` | the biggest single filing inside the event |
+| `notice_types` | distinct raw `notice_type` strings, as the portals wrote them |
+| `single_notice` | `true` when the event is a single filing |
+| `event_open` | `true` when the last notice is within 45 days of the rebuild date |
+| `duplicates_dropped` | exact duplicate portal rows removed before summing |
+| `states_covered_in_year` | states with any notice in the archive for `year` |
+| `employer_page` | the employer's history page on the site, when one exists |
+| `notice_ids` | semicolon-separated ids joining to the flagship notices CSV |
+
+## Where the rows come from
+
+The free, CC BY 4.0 [normalized WARN archive](https://huggingface.co/datasets/APProjects/us-warn-act-layoffs-notices-daily) rebuilt daily from 48 state portals
+([site](https://approjects-warn-act-notices.static.hf.space), [GitHub](https://github.com/APVentureEngine/warn-act-notices)). Related cuts of the same archive: [employers filing in
+several states](https://huggingface.co/datasets/APProjects/us-multi-state-layoffs-employers-warn-act) and [layoffs per capita by state](https://huggingface.co/datasets/APProjects/us-layoffs-per-capita-by-state-warn-act).
+
+Get told the day an employer on your list files, in any of the 48 states: [free 30-day
+watch](https://approj.gumroad.com/l/warn-free-watch) (no card) or [WARN Watch, $49/year](https://approj.gumroad.com/l/warn-watch) for a list of up to 500
+employers.
+
+*Automated publisher (APProjects). Not affiliated with any government agency. Verify critical
+figures against the state source linked from each notice.*

alias_merge.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""alias_merge.py — group fragmented employer spellings into one history key.
+
+WHY THIS EXISTS (c307, 2026-09-11). The paid product's headline feature is
+"hand us your list; day one every name is scored against the 1988-present
+archive". That report, the per-employer public pages, and the `history` line
+attached to every alert are all built by `warn_watch.dossier_index()`, which
+keys on the EXACT lowercased `company_canonical` string. The alert MATCHER,
+by contrast, uses token-subset matching (`warn_watch.notice_matches`).
+
+Those two disagree, and the disagreement is worst exactly where it hurts most:
+
+    Boeing files under 22 distinct spellings in the archive, including the
+    typos 'Boeing Compnay' and 'Thte Boeing Company'. A buyer watching
+    "Boeing" DOES get an alert when 'Boeing - El Paso' files (token subset),
+    but the history line on that alert looks up the key 'boeing - el paso'
+    and reports "2 prior notices" when the truth is 420 across 13 states.
+
+Measured on the 59,134-row archive (c307):
+  - 34,154 distinct canonical keys.
+  - Tier 1 (stopword/punctuation only): 415 groups, 467 keys, 663 notices.
+  - Tier 2 (prefix absorption, purity >= 0.90): 4,615 keys, 7,238 notices.
+  => ~7,900 notices (13% of the archive) gain a materially fuller history.
+
+THE OVER-MERGE HAZARD, AND THE GUARD. Naive prefix absorption folds
+'venture stores' into 'venture' and 'marriott international' into 'marriott',
+which would attribute unrelated companies to each other ON PUBLIC PAGES --
+strictly worse than under-counting, because it looks like evidence. The guard
+is token PURITY: for a single-token parent P, the share of distinct canonical
+keys containing token P that actually START with P.
+
+    boeing 0.93  verizon 0.94  ames 1.00      -> merged
+    meta 0.86  united 0.83  compass 0.78      -> blocked
+    sears 0.76  novartis 0.69  general 0.63   -> blocked
+    marriott 0.47  venture 0.21               -> blocked
+
+At PURITY_MIN = 0.90 the rule deliberately UNDER-merges (it blocks the
+genuinely-correct 'cvs health' -> 'cvs'). That asymmetry is intentional: a
+missed merge under-reports a history, a false merge publishes a lie.
+
+Multi-token parents ('thermo fisher', 'general dynamics', 'p f chang s') are
+not purity-gated -- two or more tokens matching in order is already strong
+evidence, and no false merge was found among them by inspection.
+
+USAGE
+    python3 alias_merge.py --selftest      # assert the known good/bad cases
+    python3 alias_merge.py --report        # impact summary + examples
+    from alias_merge import build_alias_map
+    amap = build_alias_map(rows)           # exact canonical (lower) -> group key
+
+NOT YET WIRED INTO publish.sh. See BACKLOG 0-ALIAS-MERGE.
+"""
+
+import collections
+import csv
+import re
+import sys
+
+FULL_CSV = "out/full/warn_notices.csv"
+
+STOP = {"inc", "llc", "corp", "corporation", "co", "company", "ltd", "the",
+        "of", "and", "incorporated", "lp", "llp", "plc"}
+
+PURITY_MIN = 0.90      # single-token parents below this are never used
+PARENT_MIN_NOTICES = 3  # a parent must itself be a real, repeatedly-filing employer
+
+
+def tokens(s):
+    """Same tokenizer as warn_watch.tokens -- keep these two in step."""
+    return [t for t in re.split(r"[^a-z0-9]+", str(s or "").lower()) if t]
+
+
+def norm_sig(s):
+    """Normalized token signature: lowercase, punctuation-free, stopwords dropped."""
+    return tuple(t for t in tokens(s) if t not in STOP)
+
+
+def canon_of(row):
+    return (row.get("company_canonical") or row.get("company") or "").strip().lower()
+
+
+def build_alias_map(rows, purity_min=PURITY_MIN, parent_min=PARENT_MIN_NOTICES):
+    """exact lowercased canonical -> group key (also a lowercased canonical).
+
+    Identity entries are omitted; callers should treat a missing key as
+    'maps to itself'. Deterministic: no dict-ordering dependence.
+    """
+    counts = collections.Counter()
+    for r in rows:
+        c = canon_of(r)
+        if c:
+            counts[c] += 1
+
+    # signature -> [canonical keys], and signature total notice count
+    by_sig = collections.defaultdict(list)
+    for k in counts:
+        by_sig[norm_sig(k)].append(k)
+    sig_total = {s: sum(counts[k] for k in ks) for s, ks in by_sig.items() if s}
+
+    # token -> distinct signatures containing it (for the purity guard)
+    tok2sigs = collections.defaultdict(set)
+    for s in sig_total:
+        for t in set(s):
+            tok2sigs[t].add(s)
+
+    parents = {s for s, n in sig_total.items() if n >= parent_min}
+
+    def purity(p):
+        if len(p) != 1:
+            return 1.0
+        sigs = tok2sigs.get(p[0]) or ()
+        if not sigs:
+            return 0.0
+        return sum(1 for s in sigs if s[:1] == p) / len(sigs)
+
+    # Tier 1: every key in a signature group collapses onto that group's
+    # highest-volume key (ties broken by the shorter, then lexically first name).
+    def rep_of(keys):
+        return sorted(keys, key=lambda k: (-counts[k], len(k), k))[0]
+
+    sig_rep = {s: rep_of(ks) for s, ks in by_sig.items() if s}
+
+    # Tier 2: a signature absorbs into its SHORTEST existing parent prefix.
+    absorb = {}
+    for s in sig_total:
+        for L in range(1, len(s)):
+            p = s[:L]
+            if p in parents and p != s and purity(p) >= purity_min:
+                absorb[s] = p
+                break
+
+    # Resolve prefix chains (a -> b -> c) to their terminal parent.
+    def resolve(s, _seen=None):
+        _seen = _seen or set()
+        while s in absorb and s not in _seen:
+            _seen.add(s)
+            s = absorb[s]
+        return s
+
+    amap = {}
+    for s, ks in by_sig.items():
+        if not s:
+            continue
+        target = sig_rep[resolve(s)]
+        for k in ks:
+            if k != target:
+                amap[k] = target
+    return amap
+
+
+def load_rows(path=FULL_CSV):
+    with open(path, newline="", encoding="utf-8", errors="replace") as f:
+        return list(csv.DictReader(f))
+
+
+# --------------------------------------------------------------------------
+# selftest: the cases that justified the design. If these ever flip, the
+# tokenizer, the purity guard or the archive changed -- investigate, do not
+# "fix" the assertion.
+# --------------------------------------------------------------------------
+MUST_MERGE = [                       # (child spelling, expected group token)
+    ("boeing - el paso", "boeing"),
+    ("boeing compnay", "boeing"),
+    ("boeing commercial airplane group", "boeing"),
+    ("boeing company - oregon location", "boeing"),
+]
+MUST_NOT_MERGE = [                   # over-merge hazards: must stay separate
+    ("venture stores", "venture"),
+    ("marriott international", "marriott"),
+    ("compass group", "compass"),
+    ("sears holdings", "sears"),
+]
+
+
+def selftest():
+    rows = load_rows()
+    amap = build_alias_map(rows)
+    ok = True
+
+    for child, parent_tok in MUST_MERGE:
+        got = amap.get(child, child)
+        if norm_sig(got) != (parent_tok,):
+            print("FAIL merge: %r -> %r (wanted group %r)" % (child, got, parent_tok))
+            ok = False
+
+    for child, parent_tok in MUST_NOT_MERGE:
+        got = amap.get(child, child)
+        if norm_sig(got) == (parent_tok,):
+            print("FAIL over-merge: %r was folded into %r" % (child, parent_tok))
+            ok = False
+
+    # No key may map to itself, and every target must be a real canonical.
+    canon = {canon_of(r) for r in rows}
+    for k, v in amap.items():
+        if k == v:
+            print("FAIL identity entry: %r" % k); ok = False; break
+        if v not in canon:
+            print("FAIL target not a real employer: %r -> %r" % (k, v)); ok = False; break
+
+    # Boeing's grouped history must beat the ungrouped one.
+    grouped = collections.Counter()
+    for r in rows:
+        c = canon_of(r)
+        if c:
+            grouped[amap.get(c, c)] += 1
+    before = sum(1 for r in rows if canon_of(r) == "boeing")
+    after = grouped.get("boeing", 0)
+    states = {r.get("state") for r in rows
+              if amap.get(canon_of(r), canon_of(r)) == "boeing"}
+    print("boeing notices: %d -> %d | states: %d" % (before, after, len(states)))
+    if after <= before:
+        print("FAIL: grouping did not improve Boeing"); ok = False
+
+    print("alias_merge selftest:", "PASS" if ok else "FAIL")
+    return 0 if ok else 1
+
+
+def report():
+    rows = load_rows()
+    amap = build_alias_map(rows)
+    canon = collections.Counter(canon_of(r) for r in rows if canon_of(r))
+    moved = sum(canon[k] for k in amap)
+    groups = collections.defaultdict(list)
+    for k, v in amap.items():
+        groups[v].append(k)
+    print("distinct canonical employers : %d" % len(canon))
+    print("keys folded into a group     : %d" % len(amap))
+    print("notices re-homed             : %d (%.1f%% of %d)"
+          % (moved, 100.0 * moved / max(1, len(rows)), len(rows)))
+    print("employers whose history grows: %d" % len(groups))
+    print("\nlargest regrouped employers:")
+    for tgt, ks in sorted(groups.items(),
+                          key=lambda kv: -sum(canon[k] for k in kv[1]))[:12]:
+        print("  %-42s +%4d notices from %d spellings"
+              % (tgt[:42], sum(canon[k] for k in ks), len(ks)))
+    return 0
+
+
+if __name__ == "__main__":
+    if "--selftest" in sys.argv:
+        sys.exit(selftest())
+    sys.exit(report())

dataviz.py

@@ -0,0 +1,270 @@
+"""Inline-SVG charts from real data, for a venture's static pages.
+
+Copy this file into ventures/<slug>/product/ and import it from your site
+generator. Standard library only, like gen_site.py.
+
+WHY INLINE SVG AND NOT A CHART LIBRARY. These pages are static files built by a
+Python pipeline and served from GitHub Pages. A CDN chart library would add a
+blocking third-party request, break the reviewer's no-unknown-script rule, show
+nothing until JS runs, and render an empty box for anyone whose script blocked.
+SVG generated at build time has the numbers baked in: it paints instantly, it
+works with JS off, it survives being screenshotted into a post, and the figure
+cannot silently disagree with the dataset because it IS the dataset.
+
+WHAT A CHART IS FOR HERE. Not a research paper. A stranger gives the page about
+two seconds. One number, large, that makes the scale of the thing land — then
+the shape of the data underneath it. Accurate AND arresting; the accuracy is
+what makes it arresting, because the numbers are real and specific.
+
+Rules baked in so they cannot be forgotten:
+  * every mark is DIRECTLY LABELLED — no hover, no legend to decode, and it
+    keeps the palette legal for colour-blind readers;
+  * one axis, never two scales on one chart;
+  * a single series uses the sequential blue ramp; multiple series use a
+    validated categorical order, never cycled;
+  * text is ink-coloured, never series-coloured — a mark beside it carries
+    identity;
+  * grid and axes recede;
+  * every figure carries a caption naming the source and the date, because an
+    unattributed number on a page selling data is worth nothing;
+  * dark mode is honoured via prefers-color-scheme.
+
+Palette validated with the dataviz palette checker (light and dark): lightness
+band, chroma floor, CVD separation, normal-vision floor, contrast.
+"""
+import html
+import math
+
+# Sequential blue, light -> dark. Single-series magnitude uses the 450 step.
+BLUE = {100: "#cde2fb", 200: "#9ec5f4", 300: "#6da7ec",
+        400: "#3987e5", 450: "#2a78d6", 550: "#1c5cab", 650: "#104281"}
+# Categorical, in FIXED order. Never cycle; a 4th series means rethink the chart.
+SERIES = ("#2a78d6", "#eb6834", "#1baf7a")
+INK = "#1a1a19"
+INK_DIM = "#5b5b57"
+GRID = "#e6e6e3"
+
+# Ink AND surface move together. Setting a dark text colour without a dark
+# ground is how you get invisible numbers on a light page — caught by rendering
+# this, not by reading it. The components carry their own surface so the library
+# is safe to drop into a host page whose background it does not control, and the
+# SVGs use currentColor so their text follows the same token.
+CSS = """
+.dv{
+  --dv-ink:%(ink)s; --dv-dim:%(dim)s; --dv-grid:%(grid)s;
+  --dv-surface:#fcfcfb; --dv-accent:%(accent)s;
+  --dv-line:%(line)s; --dv-area:%(area)s;
+  font:14px/1.4 -apple-system,system-ui,"Segoe UI",Roboto,sans-serif;
+  color:var(--dv-ink);
+}
+@media (prefers-color-scheme:dark){
+  .dv{--dv-ink:#f2f2f0; --dv-dim:#a9a9a4; --dv-grid:#333330;
+      --dv-surface:#1a1a19; --dv-accent:%(accent_dark)s;
+      /* dark takes its OWN steps from the same ramp, not a flipped light one */
+      --dv-line:%(line_dark)s; --dv-area:%(area_dark)s}
+}
+.dv figure{margin:0 0 28px}
+.dv figcaption{margin-top:8px;font-size:12px;color:var(--dv-dim)}
+.dv-kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:18px}
+.dv-kpi{
+  padding:16px 18px;border:1px solid var(--dv-grid);border-radius:12px;
+  background:var(--dv-surface);color:var(--dv-ink);
+}
+.dv-kpi b{display:block;font-size:clamp(1.9rem,5vw,2.9rem);font-weight:800;
+          letter-spacing:-.03em;line-height:1;font-variant-numeric:tabular-nums;
+          color:var(--dv-ink)}
+.dv-kpi span{display:block;margin-top:7px;font-size:12.5px;color:var(--dv-dim)}
+.dv-kpi i{font-style:normal;font-size:12px;font-weight:700;color:var(--dv-accent)}
+.dv-svg{display:block;max-width:100%%;height:auto;color:var(--dv-ink)}
+.dv table{border-collapse:collapse;font-size:13px;color:var(--dv-ink)}
+.dv th,.dv td{padding:5px 12px 5px 0;text-align:left;
+              border-bottom:1px solid var(--dv-grid)}
+""" % {"ink": INK, "dim": INK_DIM, "grid": GRID,
+       "accent": BLUE[550], "accent_dark": BLUE[300],
+       "line": BLUE[450], "area": BLUE[100],
+       "line_dark": BLUE[400], "area_dark": BLUE[650]}
+
+
+def _e(s) -> str:
+    return html.escape(str(s), quote=True)
+
+
+def _num(v) -> str:
+    """Thousands separators. A page selling 45,772 records must not print 45772."""
+    try:
+        f = float(v)
+    except (TypeError, ValueError):
+        return _e(v)
+    return f"{int(round(f)):,}" if abs(f - round(f)) < 1e-9 else f"{f:,.1f}"
+
+
+def _require(rows, what: str):
+    """Refuse to draw nothing. A chart of placeholder data is worse than no
+    chart: it looks like evidence and is not."""
+    if not rows:
+        raise ValueError(
+            f"{what}: no data. Do not publish an empty or invented chart — "
+            "either pass the real rows or leave the figure out.")
+
+
+def figure(svg: str, caption: str, source: str = "", asof: str = "") -> str:
+    bits = [caption]
+    if source:
+        bits.append(f"Source: {source}")
+    if asof:
+        bits.append(f"as of {asof}")
+    return (f'<figure>{svg}<figcaption>{_e(" · ".join(b for b in bits if b))}'
+            f"</figcaption></figure>")
+
+
+def kpi_row(items) -> str:
+    """The most important form on a landing page: a few real numbers, large.
+
+    items: [(value, label)] or [(value, label, note)] — note is a short delta
+    or qualifier ("last 90 days", "+12% vs Aug").
+    """
+    _require(items, "kpi_row")
+    out = ['<div class="dv-kpis">']
+    for it in items:
+        value, label = it[0], it[1]
+        note = it[2] if len(it) > 2 else ""
+        out.append('<div class="dv-kpi">')
+        out.append(f"<b>{_e(_num(value))}</b>")
+        out.append(f"<span>{_e(label)}</span>")
+        if note:
+            out.append(f'<i style="color:{BLUE[550]}">{_e(note)}</i>')
+        out.append("</div>")
+    out.append("</div>")
+    return "".join(out)
+
+
+def bar_chart(rows, unit: str = "", width: int = 680, bar_h: int = 26,
+              gap: int = 10, title: str = "") -> str:
+    """Horizontal bars, sorted, every bar directly labelled.
+
+    rows: [(label, value)]. Horizontal because real category names are words,
+    not three-letter codes, and rotated x-labels are unreadable.
+    """
+    _require(rows, "bar_chart")
+    rows = [(str(a), float(b)) for a, b in rows]
+    rows.sort(key=lambda r: -r[1])
+    top = max(v for _, v in rows) or 1.0
+    label_w = min(190, max(90, 8 * max(len(a) for a, _ in rows)))
+    # Size the value gutter from the widest label that will actually be drawn.
+    # A fixed gutter clipped "1,240 notices" to "1,240 notic" — the palette
+    # validator cannot see that; only rendering it can.
+    longest = max(len(_num(v) + unit) for _, v in rows)
+    val_w = max(46, int(longest * 7.1) + 14)
+    plot_w = max(80, width - label_w - val_w)
+    height = len(rows) * (bar_h + gap) + 8
+
+    p = [f'<svg class="dv-svg" viewBox="0 0 {width} {height}" width="100%" '
+         f'height="{height}" role="img" xmlns="http://www.w3.org/2000/svg" '
+         f'aria-label="{_e(title or "bar chart")}">']
+    if title:
+        p.append(f"<title>{_e(title)}</title>")
+    for i, (label, value) in enumerate(rows):
+        y = i * (bar_h + gap)
+        w = max(2.0, plot_w * (value / top))
+        p.append(f'<text x="0" y="{y + bar_h * 0.72:.0f}" font-size="13" '
+                 f'fill="currentColor">{_e(label)}</text>')
+        # 4px rounded data-end, anchored flat to the baseline at x=label_w
+        p.append(f'<rect x="{label_w}" y="{y}" width="{w:.1f}" height="{bar_h}" '
+                 f'rx="4" fill="var(--dv-line)"/>')
+        p.append(f'<text x="{label_w + w + 9:.1f}" y="{y + bar_h * 0.72:.0f}" '
+                 f'font-size="12.5" font-weight="700" fill="currentColor" '
+                 f'opacity=".72">'
+                 f'{_e(_num(value))}{_e(unit)}</text>')
+    p.append("</svg>")
+    return "".join(p)
+
+
+def trend(points, width: int = 680, height: int = 190, unit: str = "",
+          title: str = "") -> str:
+    """One series over time, with the latest value labelled at the end.
+
+    points: [(label, value)] in chronological order. One axis only — if you
+    have two measures, draw two charts.
+    """
+    _require(points, "trend")
+    vals = [float(v) for _, v in points]
+    if len(vals) < 2:
+        raise ValueError("trend: needs at least two points to show a trend")
+    lo, hi = min(vals), max(vals)
+    # c137 (partner report M007): this is a FILLED AREA chart, and a filled area
+    # implies magnitude measured from zero. Baselining at min(vals) made the fill
+    # lie: warn-feed's 412 -> 223 monthly series (a real but moderate ~46% decline)
+    # plunged from the top of the frame to the floor, reading as "layoffs stopped".
+    # Area and bar charts start at zero; only line-only charts may crop. If every
+    # value is non-negative we anchor at 0 and let the true proportion show.
+    base = 0.0 if lo >= 0 else lo
+    span = (hi - base) or 1.0
+    # Right pad sized from the end label, for the same reason bar_chart sizes
+    # its value gutter: a fixed 78 clipped "760 notices" to "760 notice".
+    end_label = _num(vals[-1]) + unit
+    pad_l, pad_t, pad_b = 8, 16, 26
+    pad_r = max(52, int(len(end_label) * 7.6) + 22)
+    pw = width - pad_l - pad_r
+    ph = height - pad_t - pad_b
+
+    def xy(i, v):
+        x = pad_l + pw * (i / (len(vals) - 1))
+        y = pad_t + ph * (1 - (v - base) / span)
+        return x, y
+
+    pts = [xy(i, v) for i, v in enumerate(vals)]
+    line = " ".join(f"{x:.1f},{y:.1f}" for x, y in pts)
+    area = (f"{pad_l},{pad_t + ph:.1f} " + line +
+            f" {pad_l + pw:.1f},{pad_t + ph:.1f}")
+
+    p = [f'<svg class="dv-svg" viewBox="0 0 {width} {height}" width="100%" '
+         f'height="{height}" role="img" xmlns="http://www.w3.org/2000/svg" '
+         f'aria-label="{_e(title or "trend")}">']
+    if title:
+        p.append(f"<title>{_e(title)}</title>")
+    p.append(f'<line x1="{pad_l}" y1="{pad_t + ph:.1f}" x2="{pad_l + pw:.1f}" '
+             f'y2="{pad_t + ph:.1f}" stroke="currentColor" stroke-opacity=".14" stroke-width="1"/>')
+    p.append(f'<polygon points="{area}" fill="var(--dv-area)" opacity="0.55"/>')
+    p.append(f'<polyline points="{line}" fill="none" stroke="var(--dv-line)" '
+             f'stroke-width="2" stroke-linejoin="round" stroke-linecap="round"/>')
+    lx, ly = pts[-1]
+    p.append(f'<circle cx="{lx:.1f}" cy="{ly:.1f}" r="4.5" fill="var(--dv-line)"/>')
+    p.append(f'<text x="{lx + 10:.1f}" y="{ly + 4:.0f}" font-size="13" '
+             f'font-weight="700" fill="currentColor">{_e(_num(vals[-1]))}{_e(unit)}</text>')
+    p.append(f'<text x="{pad_l}" y="{height - 6}" font-size="11.5" '
+             f'fill="currentColor" opacity=".72">{_e(points[0][0])}</text>')
+    p.append(f'<text x="{pad_l + pw:.1f}" y="{height - 6}" font-size="11.5" '
+             f'text-anchor="end" fill="currentColor" opacity=".72">{_e(points[-1][0])}</text>')
+    p.append("</svg>")
+    return "".join(p)
+
+
+def sparkline(values, width: int = 120, height: int = 30) -> str:
+    """A trend small enough to sit inside a sentence or a stat tile."""
+    _require(values, "sparkline")
+    vals = [float(v) for v in values]
+    if len(vals) < 2:
+        raise ValueError("sparkline: needs at least two values")
+    lo, hi = min(vals), max(vals)
+    span = (hi - lo) or 1.0
+    pts = " ".join(
+        f"{(width - 4) * i / (len(vals) - 1) + 2:.1f},"
+        f"{2 + (height - 4) * (1 - (v - lo) / span):.1f}"
+        for i, v in enumerate(vals))
+    return (f'<svg viewBox="0 0 {width} {height}" width="{width}" '
+            f'height="{height}" role="img" aria-label="trend" '
+            f'xmlns="http://www.w3.org/2000/svg">'
+            f'<polyline points="{pts}" fill="none" stroke="var(--dv-line)" '
+            f'stroke-width="2" stroke-linejoin="round"/></svg>')
+
+
+def table_fallback(rows, headers=("", "")) -> str:
+    """The same numbers as markup. Ship it beside any chart a screen reader or
+    a text-only client would otherwise get nothing from."""
+    _require(rows, "table_fallback")
+    head = "".join(f"<th>{_e(h)}</th>" for h in headers)
+    body = "".join(
+        "<tr>" + "".join(f"<td>{_e(_num(c) if i else c)}</td>"
+                         for i, c in enumerate(r)) + "</tr>"
+        for r in rows)
+    return f"<table><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table>"

hf_largest_events.py

@@ -0,0 +1,514 @@
+#!/usr/bin/env python3
+"""Publish the LARGEST US LAYOFF EVENTS (WARN Act, 1988-present) as its own HF
+dataset. (c334, 2026-09-12 — board c333 repair item R2.)
+
+WHY THIS EXISTS — the evidence, not a hunch:
+  * Standing rule from c319: a new HF dataset must be a COMPUTED CUT that owns a
+    query no existing artifact answers — never "the same rows, filtered".
+  * Checked on the Hub 2026-09-12 BEFORE publishing: `largest layoffs`,
+    `biggest layoffs` and `layoff events` each returned **0 datasets** hub-wide
+    (`mass layoffs` returned only our own closings-vs-layoffs set). Re-verify:
+      curl -s "https://huggingface.co/api/datasets?search=largest+layoffs"
+  * Why it cannot be copied from a portal scrape: a state portal lists one row
+    per SITE per NOTICE. "The largest layoff" is an EMPLOYER-level fact that
+    only exists after (1) 48 portals are in one schema, (2) the employer's 22
+    spellings are resolved to one group (alias_merge.py — the c309 join that is
+    this venture's actual moat), and (3) the rolling per-site notices are
+    clustered into one event. None of those three steps is on any portal.
+
+WHAT AN "EVENT" IS (say it on the card, keep it in the columns):
+  * One employer GROUP (alias-merged), its notices sorted by date, split into
+    events wherever the gap between consecutive notice dates exceeds
+    EVENT_GAP_DAYS. A rolling programme (Boeing filed monthly Jun-Nov 2020) is
+    ONE event; the same employer's 2023 cuts are a separate event.
+  * `workers_reported` sums `employees_affected` over the event's notices AFTER
+    dropping exact duplicate rows (same state + location + count + notice date +
+    effective date — some portals list the same site twice). Successive notices for the
+    same site are NOT collapsed: we cannot tell from a portal whether a second
+    notice is cumulative or incremental, so the sum can overstate a rolling
+    programme. `sites` (distinct state+location) is the conservative companion.
+
+HONESTY RAILS (read before editing):
+  1. Every event carries its `notice_ids` so any row can be re-derived from the
+     free flagship CSV; nothing here is hand-typed.
+  2. `single_notice=true` flags events built from ONE filing — those are only as
+     good as the one portal row (e.g. a 16,132-worker staffing-firm closure).
+  3. `states_covered_in_year` says how many states the archive holds any notice
+     for in the event's year. Pre-2020 the archive is thin (IL/OR go back to
+     1988; most states start 2010-2023), so an early-year ranking is a ranking
+     of the states we hold, not of the country. The card says so first.
+  4. The current year is a running total; events that started in the last
+     EVENT_GAP_DAYS days may still grow (`event_open=true`).
+  5. Every number is recounted from out/full/warn_notices.csv on every run; the
+     card, the chart and the CSV are written from ONE in-memory result.
+
+Reads : out/full/warn_notices.csv (this build), out/employer_slugs.json
+Writes: out/largest_events.csv, repo/data/largest_layoff_events.csv,
+        hf_largest_events_staging/ then uploads to <user>/DATASET_NAME
+Usage (cwd = product/):
+  python3 hf_largest_events.py --selftest
+  HF_STAGE_ONLY=1 python3 hf_largest_events.py
+  .venv-hf/bin/python3 hf_largest_events.py
+Env: HF_TOKEN. Non-fatal by convention in publish.sh.
+"""
+import collections
+import csv
+import datetime
+import json
+import os
+import re
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import alias_merge  # noqa: E402
+import dataviz  # noqa: E402
+
+DATASET_NAME = "us-largest-layoff-events-warn-act"
+STAGE = "hf_largest_events_staging"
+NOTICES = os.path.join(HERE, "out", "full", "warn_notices.csv")
+SLUGS = os.path.join(HERE, "out", "employer_slugs.json")
+OUT_CSV = os.path.join(HERE, "out", "largest_events.csv")
+REPO_CSV = os.path.join(HERE, "repo", "data", "largest_layoff_events.csv")
+SITE = "https://approjects-warn-act-notices.static.hf.space"
+REPO = "https://github.com/APVentureEngine/warn-act-notices"
+NOTICE_DS = "https://huggingface.co/datasets/APProjects/us-warn-act-layoffs-notices-daily"
+MULTI_DS = "https://huggingface.co/datasets/APProjects/us-multi-state-layoffs-employers-warn-act"
+RATES_DS = "https://huggingface.co/datasets/APProjects/us-layoffs-per-capita-by-state-warn-act"
+WATCH = "https://approj.gumroad.com/l/warn-watch"
+FREE_WATCH = "https://approj.gumroad.com/l/warn-free-watch"
+
+EVENT_GAP_DAYS = 45      # a gap longer than this between an employer's notices starts a new event
+MAX_EVENT_DAYS = 183     # ...and an event never spans more than ~6 months (Boeing files in WA every
+                         # few weeks for years; without this cap 2014-2018 chained into one "event")
+TOP_N = 1000             # rows published
+MIN_EVENTS = 200         # refuse to publish a table thinner than this
+MIN_WORKERS = 1          # an event with no reported worker count cannot be ranked by workers
+
+COLS = ["rank", "employer", "event_start", "event_end", "year", "workers_reported", "notices",
+        "notices_with_worker_count", "sites", "states", "states_count", "largest_single_notice",
+        "largest_notice_state", "largest_notice_location", "notice_types", "single_notice",
+        "event_open", "duplicates_dropped", "states_covered_in_year", "employer_page", "notice_ids"]
+
+
+def _date(r):
+    d = (r.get("notice_date") or r.get("effective_date") or "")[:10]
+    try:
+        return datetime.date.fromisoformat(d)
+    except ValueError:
+        return None
+
+
+def _int(v):
+    try:
+        n = int(float(str(v).replace(",", "")))
+    except (TypeError, ValueError):
+        return None
+    return n if n > 0 else None
+
+
+def _loc(r):
+    return re.sub(r"\s+", " ", (r.get("location") or "").strip().lower())
+
+
+def _display(rows_in_group, key, key_names):
+    """The group key's own spelling as it appears anywhere in the archive (so a 2020 event of
+    14 Hyatt Regency hotels reads 'Hyatt Regency', not 'Hyatt Regency - Portland'); otherwise
+    the most frequent spelling inside the event, shortest on ties."""
+    if key in key_names:
+        return key_names[key]
+    c = collections.Counter((r.get("company_canonical") or r.get("company") or "").strip()
+                            for r in rows_in_group)
+    return sorted(c.items(), key=lambda kv: (-kv[1], len(kv[0]), kv[0]))[0][0]
+
+
+def build(rows=None, today=None, slugs=None, gap_days=EVENT_GAP_DAYS, top_n=TOP_N):
+    rows = rows if rows is not None else list(csv.DictReader(open(NOTICES, encoding="utf-8")))
+    today = today or datetime.date.today()
+    if slugs is None:
+        try:
+            slugs = json.load(open(SLUGS, encoding="utf-8"))
+        except (OSError, ValueError):
+            slugs = {}
+    amap = alias_merge.build_alias_map(rows)
+    groups = collections.defaultdict(list)
+    covered = collections.defaultdict(set)
+    spell = collections.defaultdict(collections.Counter)   # lowercased canonical -> raw spellings
+    for r in rows:
+        c = alias_merge.canon_of(r)
+        raw = (r.get("company_canonical") or r.get("company") or "").strip()
+        if c and raw:
+            spell[c][raw] += 1
+    key_names = {k: sorted(v.items(), key=lambda kv: (-kv[1], kv[0]))[0][0] for k, v in spell.items()}
+    for r in rows:
+        d = _date(r)
+        if d is None or d > today + datetime.timedelta(days=730):
+            continue
+        st = (r.get("state") or "").upper()
+        covered[d.year].add(st)
+        c = alias_merge.canon_of(r)
+        if not c:
+            continue
+        groups[amap.get(c, c)].append((d, r))
+    gap = datetime.timedelta(days=gap_days)
+    events = []
+    for key, items in groups.items():
+        items.sort(key=lambda t: t[0])
+        cur = []
+        for d, r in items:
+            if cur and ((d - cur[-1][0]) > gap or (d - cur[0][0]).days > MAX_EVENT_DAYS):
+                events.append((key, cur))
+                cur = []
+            cur.append((d, r))
+        if cur:
+            events.append((key, cur))
+    out = []
+    for key, ev in events:
+        seen, kept, dups = set(), [], 0
+        for d, r in ev:
+            sig = ((r.get("state") or "").upper(), _loc(r), _int(r.get("employees_affected")),
+                   (r.get("notice_date") or "")[:10], (r.get("effective_date") or "")[:10])
+            if sig in seen:
+                dups += 1
+                continue
+            seen.add(sig)
+            kept.append((d, r))
+        counts = [(_int(r.get("employees_affected")) or 0, r) for _, r in kept]
+        workers = sum(n for n, _ in counts)
+        if workers < MIN_WORKERS:
+            continue
+        big_n, big_r = max(counts, key=lambda t: t[0])
+        states = sorted({(r.get("state") or "").upper() for _, r in kept if r.get("state")})
+        types = sorted({(r.get("notice_type") or "").strip() for _, r in kept} - {""})
+        start, end = kept[0][0], kept[-1][0]
+        out.append({
+            "rank": 0,
+            "employer": _display([r for _, r in kept], key, key_names),
+            "event_start": start.isoformat(), "event_end": end.isoformat(), "year": start.year,
+            "workers_reported": workers, "notices": len(kept),
+            "notices_with_worker_count": sum(1 for n, _ in counts if n),
+            "sites": len({((r.get("state") or "").upper(), _loc(r)) for _, r in kept}),
+            "states": ";".join(states), "states_count": len(states),
+            "largest_single_notice": big_n,
+            "largest_notice_state": (big_r.get("state") or "").upper(),
+            "largest_notice_location": (big_r.get("location") or "").strip(),
+            "notice_types": ";".join(types)[:200],
+            "single_notice": "true" if len(kept) == 1 else "false",
+            "event_open": "true" if (today - end) <= gap else "false",
+            "duplicates_dropped": dups,
+            "states_covered_in_year": len(covered.get(start.year, ())),
+            "employer_page": (SITE + "/" + slugs[key]) if key in slugs else "",
+            "notice_ids": ";".join(r.get("id") or "" for _, r in kept),
+        })
+    out.sort(key=lambda e: (-e["workers_reported"], e["event_start"], e["employer"]))
+    out = out[:top_n]
+    for i, e in enumerate(out, 1):
+        e["rank"] = i
+    stats = {
+        "events_total": len(events), "rows": len(out),
+        "workers_in_table": sum(e["workers_reported"] for e in out),
+        "notices_in_table": sum(e["notices"] for e in out),
+        "multi_notice_rows": sum(1 for e in out if e["single_notice"] == "false"),
+        "multi_state_rows": sum(1 for e in out if e["states_count"] > 1),
+        "dups_dropped": sum(e["duplicates_dropped"] for e in out),
+        "years": sorted({e["year"] for e in out}),
+        "asof": today.isoformat(), "cur_year": today.year, "gap_days": gap_days,
+        "states_covered_now": len(covered.get(today.year, ())),
+        "min_workers_in_table": out[-1]["workers_reported"] if out else 0,
+    }
+    return {"rows": out, "stats": stats}
+
+
+CARD = """---
+pretty_name: Largest US layoff events since 1988 - WARN Act notices clustered by employer
+license: cc-by-4.0
+language:
+  - en
+task_categories:
+  - tabular-classification
+tags:
+  - layoffs
+  - largest-layoffs
+  - biggest-layoffs
+  - layoff-events
+  - mass-layoffs
+  - warn-act
+  - warn-notices
+  - entity-resolution
+  - labor-market
+  - corporate-events
+  - public-records
+  - government-data
+  - alternative-data
+  - united-states
+  - daily-updated
+  - tabular
+size_categories:
+  - 1K<n<10K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/largest_layoff_events.csv
+---
+
+# The {rows:,} largest US layoff events on record under the WARN Act, {y0}-{y1}
+
+**Rebuilt {asof}. Largest on file: {top_employer}, {top_start} to {top_end} — {top_workers:,}
+workers across {top_notices} notices in {top_states} state(s). The table's floor is
+{min_workers:,} workers; {multi_notice:,} of the {rows:,} events span more than one notice and
+{multi_state:,} span more than one state.**
+
+A state WARN portal lists one row per site per notice. "What was the biggest layoff?" is an
+employer-level question, and answering it takes three steps no portal performs: 48 agencies'
+notices normalized into one schema daily, an employer's many spellings resolved to one name
+(Boeing files under 22 of them, typos included), and its rolling per-site notices clustered into
+one event. This dataset is the result, top {rows:,} by reported workers, rebuilt daily.
+
+![Largest layoff events by reported workers](chart.svg)
+
+## Read this before quoting a rank
+
+* **Coverage is uneven before ~2020.** The archive reaches back to 1988 only for the states
+  whose portals kept history (Illinois and Oregon among them); most states begin between 2010
+  and 2023. `states_covered_in_year` says how many states the archive holds for the event's
+  year — an early-year rank is a rank among the states we hold, not the country.
+* **An event is one employer's notices with no gap longer than {gap} days between consecutive
+  notice dates, and no longer than {maxdays} days end to end.** A rolling programme is one event;
+  a later round, or the seventh month of a continuous programme, is a separate event.
+* **`workers_reported` can overstate a rolling programme.** Exact duplicate rows (same state,
+  location, count, notice date and effective date) are dropped (`duplicates_dropped`), but successive
+  notices for the same site are summed because a portal does not say whether the second is
+  cumulative. `sites` is the conservative companion figure.
+* **`single_notice=true` means the whole event is one portal row.** It is only as reliable as
+  that row; check it at the source before repeating it.
+* Employer names are resolved by [`alias_merge.py`]({repo}/blob/main/product/alias_merge.py)
+  (token signature + purity-guarded prefix absorption); the resolver ships in this repo. It
+  merges spellings, not corporate parents: subsidiaries filing under their own names are their
+  own employers.
+* The current year is a running total; `event_open=true` marks events that may still grow.
+
+## Top 20 right now
+
+| # | employer | period | workers | notices | states |
+|---|---|---|---|---|---|
+{top20}
+
+## Columns
+
+| column | meaning |
+|---|---|
+| `rank` | position by `workers_reported` (ties: earlier start first) |
+| `employer` | most frequent canonical spelling inside the event |
+| `event_start`, `event_end`, `year` | first and last notice date; `year` is the start year |
+| `workers_reported` | sum of `employees_affected` over the event's de-duplicated notices |
+| `notices`, `notices_with_worker_count` | notices in the event; how many carried a count |
+| `sites` | distinct state + location pairs |
+| `states`, `states_count` | semicolon-separated state codes |
+| `largest_single_notice`, `largest_notice_state`, `largest_notice_location` | the biggest single filing inside the event |
+| `notice_types` | distinct raw `notice_type` strings, as the portals wrote them |
+| `single_notice` | `true` when the event is a single filing |
+| `event_open` | `true` when the last notice is within {gap} days of the rebuild date |
+| `duplicates_dropped` | exact duplicate portal rows removed before summing |
+| `states_covered_in_year` | states with any notice in the archive for `year` |
+| `employer_page` | the employer's history page on the site, when one exists |
+| `notice_ids` | semicolon-separated ids joining to the flagship notices CSV |
+
+## Where the rows come from
+
+The free, CC BY 4.0 [normalized WARN archive]({notice_ds}) rebuilt daily from 48 state portals
+([site]({site}), [GitHub]({repo})). Related cuts of the same archive: [employers filing in
+several states]({multi_ds}) and [layoffs per capita by state]({rates_ds}).
+
+Get told the day an employer on your list files, in any of the 48 states: [free 30-day
+watch]({free_watch}) (no card) or [WARN Watch, $49/year]({watch}) for a list of up to 500
+employers.
+
+*Automated publisher (APProjects). Not affiliated with any government agency. Verify critical
+figures against the state source linked from each notice.*
+"""
+
+
+def render(res):
+    rows, st = res["rows"], res["stats"]
+    if st["rows"] < MIN_EVENTS:
+        raise SystemExit(f"hf_largest_events: only {st['rows']} events; refusing to render")
+    top = rows[0]
+    top20 = "\n".join(
+        f"| {e['rank']} | {e['employer']} | {e['event_start']} to {e['event_end']} | "
+        f"{e['workers_reported']:,} | {e['notices']} | {e['states']} |"
+        for e in rows[:20])
+    svg = dataviz.bar_chart([(f"{e['employer'][:28]} ({e['year']})", e["workers_reported"])
+                             for e in rows[:15]], unit=" workers")
+    card = CARD.format(
+        rows=st["rows"], y0=min(st["years"]), y1=max(st["years"]), asof=st["asof"],
+        top_employer=top["employer"], top_start=top["event_start"], top_end=top["event_end"],
+        top_workers=top["workers_reported"], top_notices=top["notices"],
+        top_states=top["states_count"], min_workers=st["min_workers_in_table"],
+        multi_notice=st["multi_notice_rows"], multi_state=st["multi_state_rows"],
+        gap=st["gap_days"], maxdays=MAX_EVENT_DAYS, top20=top20, repo=REPO, notice_ds=NOTICE_DS, site=SITE,
+        multi_ds=MULTI_DS, rates_ds=RATES_DS, free_watch=FREE_WATCH, watch=WATCH,
+    )
+    return card, svg
+
+
+README_ANCHOR = "<!--largest-events-readme-->"
+README_PATH = os.path.join(HERE, "repo", "README.md")
+HF_URL = f"https://huggingface.co/datasets/APProjects/{DATASET_NAME}"
+
+
+def inject_readme(res, readme_path=README_PATH):
+    """One idempotent README line under the per-capita line (GitHub = the human channel)."""
+    st = res["stats"]
+    if not res["rows"]:
+        return False
+    top = res["rows"][0]
+    line = (f"{README_ANCHOR} \U0001F3ED **[The {st['rows']:,} largest US layoff events since "
+            f"{min(st['years'])}](data/largest_layoff_events.csv)** — notices clustered per resolved "
+            f"employer (rolling programmes = one event); #1 {top['employer']} {top['year']}, "
+            f"{top['workers_reported']:,} workers over {top['notices']} notices. "
+            f"[Card on Hugging Face]({HF_URL}).")
+    txt = open(readme_path, encoding="utf-8").read()
+    txt = "\n".join(ln for ln in txt.split("\n") if README_ANCHOR not in ln)
+    for key in ("<!--state-rates-readme-->", "<!--metro-readme-->", "<!--county-readme-->"):
+        i = txt.find(key)
+        if i >= 0:
+            j = txt.find("\n", i)
+            txt = txt[:j + 1] + line + "\n" + txt[j + 1:]
+            break
+    else:
+        k = txt.find("\n## ")
+        txt = (txt[:k] + "\n\n" + line + "\n" + txt[k:]) if k >= 0 else txt + "\n\n" + line + "\n"
+    assert txt.count(README_ANCHOR) == 1
+    open(readme_path, "w", encoding="utf-8").write(txt)
+    print("hf_largest_events: README line injected")
+    return True
+
+
+def write_csv(path, rows):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.DictWriter(f, fieldnames=COLS)
+        w.writeheader()
+        w.writerows(rows)
+
+
+def stage(res):
+    card, svg = render(res)
+    root = os.path.join(HERE, STAGE)
+    shutil.rmtree(root, ignore_errors=True)
+    os.makedirs(os.path.join(root, "data"), exist_ok=True)
+    open(os.path.join(root, "README.md"), "w", encoding="utf-8").write(card)
+    open(os.path.join(root, "chart.svg"), "w", encoding="utf-8").write(svg)
+    write_csv(os.path.join(root, "data", "largest_layoff_events.csv"), res["rows"])
+    for fn in ("hf_largest_events.py", "alias_merge.py", "dataviz.py"):
+        shutil.copy2(os.path.join(HERE, fn), os.path.join(root, fn))
+    print(f"hf_largest_events: staged {res['stats']['rows']} events "
+          f"(of {res['stats']['events_total']}) -> {STAGE}/")
+    return root
+
+
+def upload():
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("HF_TOKEN not set - staged only, nothing uploaded.")
+        return 0
+    from huggingface_hub import HfApi
+    api = HfApi(token=token)
+    user = api.whoami()["name"]
+    repo_id = f"{user}/{DATASET_NAME}"
+    api.create_repo(repo_id, repo_type="dataset", exist_ok=True)
+    api.upload_folder(folder_path=os.path.join(HERE, STAGE), repo_id=repo_id,
+                      repo_type="dataset", commit_message="daily largest-events refresh")
+    print(f"uploaded -> https://huggingface.co/datasets/{repo_id}")
+    return 0
+
+
+def selftest():
+    def n(i, st, comp, wc, nd, loc="Plant", ed="", nt="Layoff"):
+        return {"id": f"id{i}", "state": st, "company": comp, "company_canonical": comp,
+                "employees_affected": wc, "notice_date": nd, "effective_date": ed,
+                "location": loc, "notice_type": nt}
+    rows = [
+        # Boeing: 3 notices within 45d = one event, plus one 200 days later = second event
+        n(1, "WA", "Boeing", "500", "2020-06-01"),
+        n(2, "WA", "Boeing", "300", "2020-07-01"),               # (parent needs >= 3 exact rows)
+        n(3, "CA", "Boeing - El Paso", "50", "2020-08-10", loc="El Paso"),  # alias-merged spelling
+        n(4, "WA", "Boeing", "100", "2021-03-01"),
+        # Rolling filer: 8 notices 30 days apart = 210 days -> must split at the 183-day cap
+        *[n(20 + i, "KS", "Roller", "10", (datetime.date(2019, 1, 1) + datetime.timedelta(days=30 * i)).isoformat())
+          for i in range(8)],
+        # exact duplicate portal row must be dropped, not summed
+        n(5, "TX", "Acme", "400", "2022-01-05", ed="2022-03-01"),
+        n(6, "TX", "Acme", "400", "2022-01-05", ed="2022-03-01"),
+        # single notice giant; no worker count row must not rank
+        n(7, "NJ", "Giant Staffing", "9000", "2025-05-20"),
+        n(8, "NJ", "Ghost", "", "2025-05-20"),
+        n(9, "NJ", "Bad Date", "10", "not-a-date"),
+    ]
+    today = datetime.date(2026, 9, 12)
+    res = build(rows, today=today, slugs={"boeing": "employers/b/boeing.html"}, top_n=20)
+    by = {(e["employer"], e["event_start"]): e for e in res["rows"]}
+    b1 = by[("Boeing", "2020-06-01")]
+    assert b1["workers_reported"] == 850 and b1["notices"] == 3 and b1["states"] == "CA;WA", b1
+    assert b1["sites"] == 2 and b1["largest_single_notice"] == 500 and b1["largest_notice_state"] == "WA"
+    assert b1["employer_page"].endswith("employers/b/boeing.html")
+    assert ("Boeing", "2021-03-01") in by, "second round must be a separate event"
+    acme = by[("Acme", "2022-01-05")]
+    assert acme["workers_reported"] == 400 and acme["duplicates_dropped"] == 1 and acme["notices"] == 1
+    g = by[("Giant Staffing", "2025-05-20")]
+    assert g["single_notice"] == "true" and res["rows"][0] is g
+    assert not any(e["employer"] in ("Ghost", "Bad Date") for e in res["rows"])
+    assert all(e["event_open"] == "false" for e in res["rows"])
+    assert b1["states_covered_in_year"] == 2 and [e["rank"] for e in res["rows"]] == list(range(1, 7))
+    assert b1["notice_ids"] == "id1;id2;id3"
+    roll = [e for e in res["rows"] if e["employer"] == "Roller"]
+    assert len(roll) == 2 and sorted(e["notices"] for e in roll) == [1, 7], roll
+    # render must refuse a thin table, and must not leave placeholders when it renders
+    try:
+        render(res)
+    except SystemExit:
+        pass
+    else:
+        raise AssertionError("render must refuse < MIN_EVENTS events")
+    wide = [n(100 + i, "IL", f"Employer {i}", str(10 + i), f"2024-01-{1 + i % 28:02d}")
+            for i in range(MIN_EVENTS + 5)]
+    wide.append(n(999, "IL", "Employer 3", "5", "2026-09-01"))   # open event in the current year
+    res2 = build(wide, today=today, slugs={}, top_n=TOP_N)
+    assert any(e["event_open"] == "true" for e in res2["rows"])
+    card, svg = render(res2)
+    left = re.findall(r"\{[a-z_0-9]+\}", card)
+    assert not left, f"unformatted placeholder: {left}"
+    assert "<svg" in svg and "| 1 | Employer" in card and "45 days" in card
+    import tempfile
+    tmp = tempfile.NamedTemporaryFile("w", suffix=".md", delete=False, encoding="utf-8")
+    tmp.write("# T\n\n<!--metro-readme--> metro line\n<!--state-rates-readme--> rates line\n\n## Next\n")
+    tmp.close()
+    inject_readme(res2, tmp.name); inject_readme(res2, tmp.name)
+    t = open(tmp.name, encoding="utf-8").read()
+    assert t.count(README_ANCHOR) == 1 and t.index("rates line") < t.index(README_ANCHOR)
+    os.unlink(tmp.name)
+    print(f"hf_largest_events selftest: ok ({len(res['rows'])} events in fixture, card {len(card)} chars)")
+    return 0
+
+
+def main():
+    if "--selftest" in sys.argv:
+        return selftest()
+    res = build()
+    write_csv(OUT_CSV, res["rows"])
+    write_csv(REPO_CSV, res["rows"])
+    try:
+        inject_readme(res)
+    except Exception as e:  # noqa: BLE001 — a README line must never block the upload
+        print(f"hf_largest_events: WARN README injection failed ({e})")
+    stage(res)
+    if os.environ.get("HF_STAGE_ONLY"):
+        print("HF_STAGE_ONLY set - not uploading.")
+        return 0
+    return upload()
+
+
+if __name__ == "__main__":
+    sys.exit(main())