Generic fallback: don't append a country to a street address that skipped the city

A schema.org PostalAddress that carries a streetAddress but leaves
addressLocality empty has a hole in its hierarchy, and the generic location
composer then jumped straight from the street to the country: "City Museum
Tel Aviv-Yafo, Bialik Street 27, Israel". That names no findable place — the
country adds nothing once you are at street level without a city — and it is
exactly what the dedicated source omits.

So append the country only when nothing finer already stands in for it: no
addressRegion (the existing rule), and either the address named its city or it
gave no street at all, leaving the country the most specific thing we have.
A complete street/city/country hierarchy (livenation.de's shape) and a bare
city/country address both keep the country, unchanged.

Generic: keys off the schema.org PostalAddress convention, not a host. The
city-skipping shape is what ASP.NET/SharePoint CMSes emit when the venue record
has no city field, so any such site benefits.

Lifts both visit.tel-aviv.gov.il fallback locations from a diff to an exact
match; no other corpus case changes and no field regresses.
Fallback-coverage: criticalFieldsPct 75.2->77.1, allFieldsPct 55.9->56.9
(location matches 22->24).

The #728 control-chars test asserted the same city-skipping page's composed
location; its expected value moves to the new composition. That assertion is a
proxy for "the tolerant parse succeeded" (a value assembled from separate
JSON-LD fields, so it cannot leak from the raw <script> text), and it stays an
exact multi-field equality assertion — just as strong.

Refs #366

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018975YrYb81uQmAvG315fTE

Author: claude

dev/requirements/extractor/fallback/fallback-coverage.GENERATED.md

@@ -12,8 +12,8 @@ Headline coverage over all 35 cases in the corpus:
 
 | Metric | Coverage | Hits / gradeable |
 | --- | --: | --: |
-| **Critical fields** (title + start + location) | **75.2%** | 79 / 105 |
-| **All fields** | **55.9%** | 114 / 204 |
+| **Critical fields** (title + start + location) | **77.1%** | 81 / 105 |
+| **All fields** | **56.9%** | 116 / 204 |
 | Event coverage *(informational)* | 25.3% | 41 / 162 |
 
 ### Gate
@@ -22,8 +22,8 @@ The gate (`dev/requirements/extractor/fallback/fallback-coverage.baseline.GENERA
 
 | Metric | Watermark | Current (shared) | |
 | --- | --: | --: | :-: |
-| Critical fields | 75.2% | 75.2% | ✓ |
-| All fields | 55.9% | 55.9% | ✓ |
+| Critical fields | 77.1% | 77.1% | ✓ |
+| All fields | 56.9% | 56.9% | ✓ |
 
 Gated over **35** shared case(s).
 
@@ -36,7 +36,7 @@ Event coverage is reported but **not gated** (a few listing pages the fallback c
 | `title` **(critical)** | 35 | 30 | 3 | 2 | 85.7% |
 | `start` **(critical)** | 35 | 27 | 6 | 2 | 77.1% |
 | `end` | 23 | 15 | 1 | 7 | 65.2% |
-| `location` **(critical)** | 35 | 22 | 6 | 7 | 62.9% |
+| `location` **(critical)** | 35 | 24 | 4 | 7 | 68.6% |
 | `ctz` | 32 | 12 | 0 | 20 | 37.5% |
 | `eventLengthInMinutes` | 11 | 0 | 0 | 11 | 0% |
 | `description` | 33 | 8 | 18 | 7 | 24.2% |
@@ -67,7 +67,7 @@ Event coverage is reported but **not gated** (a few listing pages the fallback c
 | `tel-aviv.gov.il` | 1 | 1/1 | 66.7% | 60% |
 | `thinkdrink.co.il` | 1 | 1/1 | 100% | 60% |
 | `ticketmaster.co.il` | 1 | 1/1 | 100% | 80% |
-| `visit.tel-aviv.gov.il` | 2 | 2/2 | 50% | 41.7% |
+| `visit.tel-aviv.gov.il` | 2 | 2/2 | 83.3% | 58.3% |
 
 ## By exemplar
 
@@ -108,5 +108,5 @@ Legend: ✓ match · ~ different value · ✗ missing (source had it, fallback d
 | `telavivcinematheque-taiwan-week` | 1/6 | ~ | ✓ | ✗ | ✓ | ✗ | ✗ | ~ |
 | `thinkdrink-quantum-lecture` | 1/1 | ✓ | ✓ | — | ✓ | ✗ | — | ~ |
 | `ticketmaster-ravid-plotnik` | 1/1 | ✓ | ✓ | — | ✓ | ✗ | — | ✓ |
-| `visit-tel-aviv-timed` | 1/1 | ✓ | ✓ | ✓ | ~ | ✗ | — | ✓ |
-| `visit-tel-aviv` | 1/1 | ✓ | ~ | ~ | ~ | ✗ | — | ~ |
+| `visit-tel-aviv-timed` | 1/1 | ✓ | ✓ | ✓ | ✓ | ✗ | — | ✓ |
+| `visit-tel-aviv` | 1/1 | ✓ | ~ | ~ | ✓ | ✗ | — | ~ |

dev/requirements/extractor/fallback/fallback-coverage.baseline.GENERATED.json

@@ -1,7 +1,7 @@
 {
   "_comment": "High-watermark gate for the generic fallback extractor's coverage, asserted by fallback-coverage.test.js and explained in dev/requirements/extractor/fallback/fallback-coverage.GENERATED.md. criticalFieldsPct/allFieldsPct are the best field-match percentages reached against the dedicated sources, and cases is the list they were computed over. The gate compares the current run to these over the SHARED cases, so adding a new case never fails it; the watermark ratchets up on an unchanged case set and re-anchors to the current aggregate when the set changes. Re-baseline by hand (lower a number) only for a deliberate, reviewed drop.",
-  "criticalFieldsPct": 75.2,
-  "allFieldsPct": 55.9,
+  "criticalFieldsPct": 77.1,
+  "allFieldsPct": 56.9,
   "cases": [
     "bandsintown-berry-sakharof",
     "barby",

extension-test/event-extractors/extraction.test.js

@@ -140,6 +140,48 @@ test("JSON-LD location: a Place name holding only the city (not the street) stil
   assert.equal(e.times[0].location, "Zappa Tel Aviv - Midtown, Menachem Begin Road 144, 6492102");
 });
 
+test("JSON-LD location: a country is not appended to a street address that skipped the city", () => {
+  // A PostalAddress that carries a street but leaves addressLocality EMPTY has a
+  // hole in its hierarchy, and the country then jumps a level: "Bialik Street 27,
+  // Israel" names no findable place, and a dedicated source writes the street
+  // without it. So the country is appended only when the address didn't skip the
+  // city (or when the country is all we have) — the same "don't tack on a part
+  // that adds nothing locatable" reasoning that drops a country code after a
+  // region. Mirrors visit.tel-aviv.gov.il's JSON-LD.
+  const html = `
+    <script type="application/ld+json">
+    { "@type": "Event", "name": "Savta Stories", "startDate": "2026-07-14T10:00:00",
+      "location": { "@type": "Place", "name": "City Museum Tel Aviv-Yafo",
+                    "address": { "@type": "PostalAddress", "streetAddress": "Bialik Street 27",
+                                 "addressLocality": "", "addressCountry": "Israel" } } }
+    </script>`;
+
+  const e = firstEvent(html, "https://www.somecity.example/events/savta-stories");
+  assert.equal(e.times[0].location, "City Museum Tel Aviv-Yafo, Bialik Street 27");
+});
+
+test("JSON-LD location: a country IS kept when the address names its city too", () => {
+  // The guard for the rule above: a complete street/city/country hierarchy is
+  // exactly the case the country belongs in (livenation.de's shape), and a
+  // city-and-country address with no street keeps it as well.
+  const withCity = `
+    <script type="application/ld+json">
+    { "@type": "Event", "name": "Harbour Show", "startDate": "2026-08-01T20:00:00",
+      "location": { "@type": "Place", "name": "Harbour Hall",
+                    "address": { "streetAddress": "12 Dock Rd", "addressLocality": "Cork",
+                                 "addressCountry": "Ireland" } } }
+    </script>`;
+  assert.equal(firstEvent(withCity, "https://www.x.example/a").times[0].location, "Harbour Hall, 12 Dock Rd, Cork, Ireland");
+
+  const cityOnly = `
+    <script type="application/ld+json">
+    { "@type": "Event", "name": "City Fest", "startDate": "2026-08-02T20:00:00",
+      "location": { "@type": "Place", "name": "Somewhere Central",
+                    "address": { "addressLocality": "Cork", "addressCountry": "Ireland" } } }
+    </script>`;
+  assert.equal(firstEvent(cityOnly, "https://www.x.example/b").times[0].location, "Somewhere Central, Cork, Ireland");
+});
+
 test("JSON-LD location: an addressCountry Country object (not a plain string) contributes its name, not '[object Object]'", () => {
   // schema.org allows addressCountry to be a Country object ({ "@type":
   // "Country", "name": "..." }) rather than a plain string — seen on
@@ -183,6 +225,11 @@ test("JSON-LD with raw (unescaped) control chars inside a string value is still
   // can never leak out of the raw <script> text as one contiguous string — is the
   // assertion that pins the parse actually succeeding. The literal newline below
   // is intentional (it is the defect being tolerated).
+  //
+  // This page's address is also the city-skipping shape (a streetAddress with no
+  // addressLocality), so the composed location stops at the street instead of
+  // tacking on the country — see the country/city tests above. Still two separate
+  // JSON-LD fields joined together, so it pins the parse just as tightly.
   const html = `
     <script type="application/ld+json">
     { "@context": "http://www.schema.org", "@type": "Event",
@@ -200,7 +247,7 @@ Second line, after a raw newline.",
   assert.equal(e.title, "Heritage Talk");
   assert.equal(e.times[0].start, "2026-07-05T18:00:00");
   assert.equal(e.times[0].end, "2026-07-05T20:00:00");
-  assert.equal(e.times[0].location, "City Museum, Bialik St 27, Israel");
+  assert.equal(e.times[0].location, "City Museum, Bialik St 27");
   assert.ok(
     e.description.includes("First line") && e.description.includes("Second line"),
     "both lines of the raw-newline description survive"

extension/event-extractors/helpers/embedded-events.js

@@ -160,9 +160,15 @@ globalThis.GCal = Object.assign(globalThis.GCal || {}, (() => {
       p.add(addr);
     } else if (addr && typeof addr === "object") {
       p.add(addr.streetAddress).add(addr.addressLocality).add(addr.addressRegion).add(addr.postalCode);
-      // A country code after a region is noise ("..., NY, us"); keep the
-      // country only when it's the most specific thing we have.
-      if (!addr.addressRegion) p.add(countryName(addr.addressCountry));
+      // A country code after a region is noise ("..., NY, us"), and so is a
+      // country bolted straight onto a street whose city the address left out:
+      // "Bialik Street 27, Israel" skips a level of the hierarchy and names no
+      // findable place, which is why a dedicated source writes the street alone.
+      // So append the country only when nothing finer already stands in for it —
+      // no region, and either the address named its city or it gave no street at
+      // all (leaving the country the most specific thing we have).
+      const skipsCity = GCal.clean(addr.streetAddress) && !GCal.clean(addr.addressLocality);
+      if (!addr.addressRegion && !skipsCity) p.add(countryName(addr.addressCountry));
     }
     return p.join();
   }