Datasets:
id stringlengths 13 13 | kind stringclasses 9
values | page stringclasses 2
values | source stringclasses 5
values | captured timestamp[s]date 2026-11-20 00:00:00 2026-11-20 00:00:00 | offer_name stringclasses 3
values | price stringclasses 5
values | currency stringclasses 1
value | credits int64 6 200 ⌀ | status stringclasses 8
values | notes stringlengths 39 157 | meme stringclasses 2
values | resolution stringclasses 2
values | extra unknown |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
hitt-pack-001 | canonical_price | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | 9.99 | USD | 6 | ok | This site's single-run 480p checkout: $9.99 / 6 credits | Hit the Road Dude | 480p | {
"price": 9.99,
"credits": 6,
"spend": 6
} |
hitt-pack-002 | canonical_price | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | 12.99 | USD | 14 | ok | This site's single-run 720p checkout: $12.99 / 14 credits | Hit the Road Dude | 720p | {
"price": 12.99,
"credits": 14,
"spend": 14
} |
hitt-pack-003 | pack_advertised | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | 27.99 | USD | 30 | info | Page copy: $27.99 / 30 credits, about 5 Hit the Road Dude runs, $5.60 per run, Save 44 % | Hit the Road Dude | null | {
"price": 27.99,
"credits": 30,
"page_about_runs": 5,
"page_per_run_usd": 5.6,
"page_save_pct": 44
} |
hitt-pack-004 | pack_advertised | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | 71.99 | USD | 100 | info | Page copy: $71.99 / 100 credits, about 16 Hit the Road Dude runs, $4.50 per run, Save 55 % | Hit the Road Dude | null | {
"price": 71.99,
"credits": 100,
"page_about_runs": 16,
"page_per_run_usd": 4.5,
"page_save_pct": 55
} |
hitt-pack-005 | pack_advertised | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | 129.99 | USD | 200 | info | Page copy: $129.99 / 200 credits, about 33 Hit the Road Dude runs, $3.94 per run, Save 61 % | Hit the Road Dude | null | {
"price": 129.99,
"credits": 200,
"page_about_runs": 33,
"page_per_run_usd": 3.94,
"page_save_pct": 61
} |
hitt-pack-006 | pack_math_480p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 27.99 | USD | 30 | ok | 30/6 = 5 runs with 0 leftover; exact $5.5980000000/run | Hit the Road Dude | 480p | {
"price": 27.99,
"credits": 30,
"spend": 6,
"runs": 5,
"leftover": 0,
"exact_per_run_usd": 5.598,
"exact_save_ratio": 0.4396396396,
"baseline_usd": 49.95,
"page_about_runs": 5
} |
hitt-pack-007 | pack_math_480p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 71.99 | USD | 100 | leftover | 100/6 = 16 runs with 4 leftover; exact $4.4993750000/run | Hit the Road Dude | 480p | {
"price": 71.99,
"credits": 100,
"spend": 6,
"runs": 16,
"leftover": 4,
"exact_per_run_usd": 4.499375,
"exact_save_ratio": 0.5496121121,
"baseline_usd": 159.84,
"page_about_runs": 16
} |
hitt-pack-008 | pack_math_480p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 129.99 | USD | 200 | leftover | 200/6 = 33 runs with 2 leftover; exact $3.9390909091/run | Hit the Road Dude | 480p | {
"price": 129.99,
"credits": 200,
"spend": 6,
"runs": 33,
"leftover": 2,
"exact_per_run_usd": 3.9390909091,
"exact_save_ratio": 0.6056966057000001,
"baseline_usd": 329.67,
"page_about_runs": 33
} |
hitt-pack-009 | pack_math_720p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 27.99 | USD | 30 | warning | Page does not print 720p run counts. 30/14 = 2 runs with 2 leftover; exact $13.9950000000/run. Page 'about 5' would overstate this. | Hit the Road Dude | 720p | {
"price": 27.99,
"credits": 30,
"spend": 14,
"runs": 2,
"leftover": 2,
"exact_per_run_usd": 13.995,
"page_about_runs": 5,
"overstates_if_applied_to_720p": true
} |
hitt-pack-010 | pack_math_720p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 71.99 | USD | 100 | warning | Page does not print 720p run counts. 100/14 = 7 runs with 2 leftover; exact $10.2842857143/run. Page 'about 16' would overstate this. | Hit the Road Dude | 720p | {
"price": 71.99,
"credits": 100,
"spend": 14,
"runs": 7,
"leftover": 2,
"exact_per_run_usd": 10.2842857143,
"page_about_runs": 16,
"overstates_if_applied_to_720p": true
} |
hitt-pack-011 | pack_math_720p | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 129.99 | USD | 200 | warning | Page does not print 720p run counts. 200/14 = 14 runs with 4 leftover; exact $9.2850000000/run. Page 'about 33' would overstate this. | Hit the Road Dude | 720p | {
"price": 129.99,
"credits": 200,
"spend": 14,
"runs": 14,
"leftover": 4,
"exact_per_run_usd": 9.285,
"page_about_runs": 33,
"overstates_if_applied_to_720p": true
} |
hitt-pack-012 | page_rounding | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 27.99 | USD | 30 | rounded | Exact $5.5980000000 rounds to page $5.60; exact save 0.439640 (43.96%) rounds to page 44 % | Hit the Road Dude | 480p | {
"price": 27.99,
"credits": 30,
"spend": 6,
"exact_per_run_usd": 5.598,
"page_per_run_usd": 5.6,
"exact_save_ratio": 0.4396396396,
"page_save_pct": 44,
"baseline_usd": 49.95
} |
hitt-pack-013 | page_rounding | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 71.99 | USD | 100 | rounded | Exact $4.4993750000 rounds to page $4.50; exact save 0.549612 (54.96%) rounds to page 55 % | Hit the Road Dude | 480p | {
"price": 71.99,
"credits": 100,
"spend": 6,
"exact_per_run_usd": 4.499375,
"page_per_run_usd": 4.5,
"exact_save_ratio": 0.5496121121,
"page_save_pct": 55,
"baseline_usd": 159.84
} |
hitt-pack-014 | page_rounding | /pricing/ | recomputed | 2026-11-20T00:00:00 | null | 129.99 | USD | 200 | rounded | Exact $3.9390909091 rounds to page $3.94; exact save 0.605697 (60.57%) rounds to page 61 % | Hit the Road Dude | 480p | {
"price": 129.99,
"credits": 200,
"spend": 6,
"exact_per_run_usd": 3.9390909091,
"page_per_run_usd": 3.94,
"exact_save_ratio": 0.6056966057000001,
"page_save_pct": 61,
"baseline_usd": 329.67
} |
hitt-pack-015 | wording | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | null | null | null | info | Run counts use each meme's default 480p setting. | Hit the Road Dude | null | {
"quote": "Run counts use each meme's default 480p setting."
} |
hitt-pack-016 | wording | /pricing/ | pricing_html | 2026-11-20T00:00:00 | null | null | null | null | info | Visible sentence: Credits never expire. | Hit the Road Dude | null | {
"quote": "Credits never expire"
} |
hitt-pack-017 | llms_wording | /llms.txt | llms_txt | 2026-11-20T00:00:00 | null | null | null | null | stale | Prices and required credits vary by model and settings; checkout refreshes the current quote. The live table is two fixed single-run prices plus three packs. | null | null | {
"quote": "Prices and required credits vary by model and settings; checkout refreshes the current quote.",
"live_table": "fixed 480p $9.99/6 and 720p $12.99/14 plus three packs"
} |
hitt-pack-018 | credit_mismatch | /pricing/ | pricing_html_table | 2026-11-20T00:00:00 | Tiny Desk Outstanding · 720p vs Hit the Road Dude · 720p | 12.99 | USD | 13 | oddity | Tiny Desk Outstanding 720p is $12.99 · 13 credits on this site's 'What each meme costs' table vs this site's own 720p $12.99 · 14 credits. | Tiny Desk Outstanding | 720p | {
"table_credits": 13,
"this_site_720p_credits": 14,
"cash_price": 12.99
} |
hitt-pack-019 | jsonld_summary | /pricing/ | jsonld | 2026-11-20T00:00:00 | null | null | null | null | info | JSON-LD on /pricing/ has 20 Offer objects, 15 unique (name+price+description). | null | null | {
"offer_count": 20,
"unique_name_price_description": 15
} |
hitt-pack-020 | jsonld_summary | /pricing/ | jsonld | 2026-11-20T00:00:00 | Seedance 2.0 · 480p | null | null | null | collision | Seedance 2.0 · 480p appears 6 times for 3 distinct (price, credits) pairs: $9.99/6, $6.99/2 (x3), $7.99/4, and again $9.99/6. | null | 480p | {
"name": "Seedance 2.0 · 480p",
"object_count": 6,
"distinct_pairs": 3
} |
hitt-pack-021 | jsonld_summary | /pricing/ | jsonld | 2026-11-20T00:00:00 | Seedance 2.0 · 720p | null | null | null | collision | Seedance 2.0 · 720p appears 6 times for 4 distinct (price, credits) pairs: $12.99/14, $8.99/5 (x3), $9.99/8, and $12.99/13. | null | 720p | {
"name": "Seedance 2.0 · 720p",
"object_count": 6,
"distinct_pairs": 4
} |
- Configs and files
- The task, and what leaks
- Validation (v15)
- Earlier card (v14): cross-source price and offer audit (Dataset Card v14, 2026-11-19)
- Configs and files
- The task, and what leaks
- Validation (v14)
- Earlier card (v13): HTML vs markdown-twin drift audit (Dataset Card v13, 2026-11-18)
- Files (v13)
- The task, and what leaks
- Validation (v13)
- Earlier card (v12): JSON-LD and visible-price consistency audit (Dataset Card v12, 2026-11-17)
- Files (v12)
- The task, and what leaks
- Validation (v12)
- Earlier card (v11): extractive QA spans with unanswerable questions (Dataset Card v11, 2026-11-16)
- Files (v11)
- The task, and what leaks
- Validation and baseline (v11)
- Using it
- Limits
- Licence
- Earlier card (v10): page freshness signals and stale-date detection (Dataset Card v10, 2026-11-15)
- Files (v10)
- The task, and what leaks
- Validation and baselines (v10)
- Using it
- Limits
- Licence
- Earlier card (v9): internal link graph and navigation audit (Dataset Card v9, 2026-11-13)
- Files (v9)
- The tasks, and what leaks
- Validation and baselines (v9)
- Using it
- Limits
- Licence
- Earlier card (v8): page change history and stale-answer detection (Dataset Card v8, 2026-11-12)
- Files (v8)
- The task, and what leaks
- Validation and baselines (v8)
- Using it
- Limits
- Licence
- Earlier card (v7): assistant-claim verification (Dataset Card v7, 2026-11-11)
- Files (v7)
- Validation and baseline (v7)
- Using it
- Limits
- Licence
- Earlier card (v6): price-quote extraction (Dataset Card v6, 2026-11-10)
- Files (v6)
- Validation and baseline (v6)
- Using it
- Limits
- Licence
- Earlier card (v5): entity-linking mentions (v5)
- Files (v5)
- Validation (v5)
- Baselines (v5)
- Uses (v5)
- Product facts, for context (checked 2026-11-09)
- v4 (2026-11-05): NLI claim pairs
- Out of scope
- Changes and known stale records
- Citation
Hit the Road Dude guides: pack-run-count and pack-marketing-math audit (Dataset Card v15, 2026-11-20)
What changed in v15 (2026-11-20): one new config, one data file, and two scripts. data/pack-run-count-audit-2026-11-20.jsonl is a pack-run-count and pack-marketing-math audit of the live Hit the Road Dude prices on the pricing page and /llms.txt, fetched 2026-11-20 09:17:32 CST (Asia/Shanghai). Each row is a canonical checkout price, a pack's advertised copy, a recomputed 480p or 720p floor-division, a documented rounding of per-run dollars or save percentages, a live wording quote, a recorded mismatch, or a JSON-LD summary. The point is not to invent a "correct" marketing sentence. It is to write down the arithmetic the live page is using — including leftover credits the page does not print — so an answer engine can be tested against a 720p spend the "about 5, 16 or 33" line was never computed for. pack_audit_lib.py holds the canonical figures and recomputes the floor division. validate_pack_audit.py checks the schema and fails any pack-math, advertised, or rounding row that disagrees with that arithmetic. Everything from v1 to v14 is unchanged and kept below.
Why this task: v14 asked whether the public price sources agree with each other. This file asks a narrower question about one source: if a model reads the pack marketing on /pricing/ and is then asked how many 720p Hit the Road Dude runs a pack buys, does it still say "about 5, 16 or 33"? The honest answer from today's arithmetic is that those counts are the 480p floor, that leftovers exist at both spends, and that applying the advertised counts to a 14-credit run would overstate what the pack can buy.
Headline findings (recomputed from the live figures, then checked by the validator):
- This studio's checkout prices are the divisors. Hit the Road Dude 480p is $9.99 / 6 credits. 720p is $12.99 / 14 credits. The three signed-in packs are $27.99 / 30, $71.99 / 100, and $129.99 / 200. Packs are one-time; there is no subscription. The page says "Credits never expire." and "Run counts use each meme's default 480p setting."
- The advertised 480p counts match the floor, leftovers included. 30 / 6 = 5 runs exactly. 100 / 6 = 16 runs with 4 credits leftover. 200 / 6 = 33 runs with 2 credits leftover. Exact per-run dollars are $5.598, $4.499375, and $3.939090…, which the page prints as $5.60, $4.50, and $3.94. Exact save ratios against 5 × $9.99, 16 × $9.99, and 33 × $9.99 are 0.439639… (43.96%), 0.549612… (54.96%), and 0.605696… (60.57%), which the page prints as 44 %, 55 %, and 61 %. The validator recomputes those ratios and fails a row that does not match this rounding.
- The same packs buy 2, 7, and 14 runs at 720p. 30 / 14 = 2 runs, 2 credits leftover, $13.995 per run. 100 / 14 = 7 runs, 2 credits leftover, $10.284285… per run. 200 / 14 = 14 runs, 4 credits leftover, $9.285 per run. The page does not print these 720p counts. "About 5 / 16 / 33" is larger than 2 / 7 / 14 in every pack. The 720p rows in this file are tagged
warningfor that reason. - 13 credits is still a real visible figure, but not this site's 720p cost. The "What each meme costs" table on this site lists Tiny Desk Outstanding 720p at $12.99 · 13 credits. This site's own Hit the Road Dude 720p is $12.99 · 14 credits. The cash prices match; the credit spends do not.
llms.txtis still stale on pricing. It still says "Prices and required credits vary by model and settings; checkout refreshes the current quote." The live Hit the Road Dude table is two fixed single-run prices plus three packs.- JSON-LD still has 20 Offer objects and colliding names. The name
Seedance 2.0 · 480pis reused for 6 objects and 3 distinct (price, credits) pairs. The nameSeedance 2.0 · 720pis reused for 6 objects and 4 distinct pairs, including both $12.99 / 14 and $12.99 / 13. These are today's catalog / graph figures, not a re-check of other domains.
Configs and files
pack_run_count_audit(default in v15):data/pack-run-count-audit-2026-11-20.jsonlpack_audit_lib.py,validate_pack_audit.py- All earlier configs and data files from v1–v14 remain in the card and in the repo. Do not delete them.
Each row has id, kind, page, source, captured, status, notes, plus offer_name, price, currency, credits, meme, resolution, and extra when they apply. Kinds in this file: canonical_price, pack_advertised, pack_math_480p, pack_math_720p, page_rounding, wording, llms_wording, credit_mismatch, jsonld_summary.
Example rows (shortened):
{"id": "hitt-pack-007", "kind": "pack_math_480p", "extra": {"credits": 100, "runs": 16, "leftover": 4, "exact_per_run_usd": 4.499375}}
{"id": "hitt-pack-010", "kind": "pack_math_720p", "extra": {"credits": 100, "runs": 7, "leftover": 2, "exact_per_run_usd": 10.284285714285714, "overstates_if_applied_to_720p": true}}
{"id": "hitt-pack-015", "kind": "wording", "notes": "Run counts use each meme's default 480p setting."}
{"id": "hitt-pack-017", "kind": "llms_wording", "status": "stale"}
{"id": "hitt-pack-018", "kind": "credit_mismatch", "extra": {"table_credits": 13, "this_site_720p_credits": 14}}
The task, and what leaks
Give a model only the pack marketing — "about 5, 16 or 33 Hit the Road Dude runs", "$5.60 / $4.50 / $3.94", "Save 44 / 55 / 61 %" — and ask how many 720p runs the $71.99 pack buys. The 480p floor is 16. The 720p floor is 7, with 2 credits leftover, at $10.284285… per run. Give it the wording row "Run counts use each meme's default 480p setting." and the same question becomes answerable without guessing. Give it only llms.txt and ask whether prices vary by model. The only honest answer from this file is that the wording is stale. Hide status and notes if you want the model to recompute the leftovers itself; the validator already does.
Validation (v15)
$ python3 validate_pack_audit.py data/pack-run-count-audit-2026-11-20.jsonl
21 rows; kinds={'canonical_price': 2, 'pack_advertised': 3, 'pack_math_480p': 3, 'pack_math_720p': 3,
'page_rounding': 3, 'wording': 2, 'llms_wording': 1, 'credit_mismatch': 1, 'jsonld_summary': 3}
status={'ok': 3, 'info': 6, 'leftover': 2, 'warning': 3, 'rounded': 3, 'stale': 1, 'oddity': 1, 'collision': 2}
schema: ok
arithmetic: ok (every pack_math / advertised / rounding row recomputed)
page-advertised about 5/16/33 and $5.60/$4.50/$3.94 and Save 44/55/61%: present
480p leftovers: 0 / 4 / 2 at 5 / 16 / 33 runs: ok
720p leftovers: 2 / 2 / 4 at 2 / 7 / 14 runs: ok
wording: Run counts use each meme's default 480p setting.: present
wording: Credits never expire: present
stale llms.txt vary-by-model wording row: present
Tiny Desk 13-vs-14 credit_mismatch row: present
JSON-LD 20 offers and two colliding names: present
recorded pack audits: 3 advertised + 3 x 480p + 3 x 720p + 3 rounding
Fetched 2026-11-20 09:17:32 CST (Asia/Shanghai). The run log is in files/hf_build/run_log.txt. The pack, leftover, and rounding figures in this file are from FACTS.md as recomputed today; they are not a new price list.
Earlier card (v14): cross-source price and offer audit (Dataset Card v14, 2026-11-19)
What changed in v14 (2026-11-19): one new config, one data file, and two scripts. data/price-source-offer-audit-2026-11-19.jsonl is a cross-source price and offer audit of the live Hit the Road Dude pages, fetched today (2026-11-19 09:23:47 CST, Asia/Shanghai). Each row is an offer, a date, a wording quote, or a recorded mismatch, taken from five sources: the visible /pricing/ HTML tables, the JSON-LD Offer graph on that same URL, /pricing.md, /llms.txt, and the /terms/ HTML. The point is not to invent a "correct" price in the dataset. It is to write down where today's sources agree and where they don't, so an answer engine can be tested against genuine inconsistencies instead of a cleaned table. offer_audit_lib.py parses those sources. validate_offer_audit.py checks the schema and re-parses today's capture to confirm the file still matches. Everything from v1 to v13 is unchanged and kept below.
Why this task: v12 asked whether JSON-LD and the visible table agree. v13 asked whether HTML policies and their markdown twins drift. This file asks a more awkward question: if a model is allowed to read all of the public price sources on this studio, does it still report one 720p credit spend, and does it still claim that prices vary by model? The honest answer from today's capture is no, and no.
Headline findings (re-parsed from today's capture, then checked by the validator against the same files):
- This studio's checkout prices are consistent where it counts. Hit the Road Dude 480p $9.99 / 6 credits and 720p $12.99 / 14 credits appear in the visible single-run table, the visible cross-site row for this meme,
pricing.md, the terms HTML, and JSON-LD Offers. The three signed-in packs — $27.99 / 30, $71.99 / 100, $129.99 / 200 — match acrosspricing.md, terms HTML, JSON-LD, and the pricing page. Packs are one-time; there is no subscription. - JSON-LD offer names still collide, and some offers are repeated. Today's graph has 20 Offer objects. The name
Seedance 2.0 · 480pis reused for 6 objects and 3 distinct (price, credits) pairs: $6.99 / 2, $7.99 / 4, and $9.99 / 6. The nameSeedance 2.0 · 720pis reused for 6 objects and 4 distinct pairs: $8.99 / 5, $9.99 / 8, $12.99 / 13, and $12.99 / 14. The exact tuple$6.99 / 2is repeated 3 times,$8.99 / 5is repeated 3 times, and$9.99 / 6is repeated 2 times. A crawler cannot tell which meme an offer belongs to from the colliding names, and it can also over-count the duplicates. Some other offers are named for a meme (Malfoid portrait · 1K,Check One Check Two · 480p/720p,Chipmunks Dance · 480p/720p, and the three pack names). These are today's counts, not yesterday's. - 13 credits is a real visible figure, but not this site's 720p cost. The "What each meme costs" table lists Tiny Desk Outstanding 720p at $12.99 · 13 credits. This site's own Hit the Road Dude 720p row lists $12.99 · 14 credits. The cash prices match; the credit spends do not. JSON-LD contains both pairs, both named
Seedance 2.0 · 720p. llms.txtis still stale on pricing. It still says "Prices and required credits vary by model and settings; checkout refreshes the current quote." The live Hit the Road Dude table is two fixed prices. There is no model picker on the studio.terms.mdis a stub. It is 345 bytes (Updated 2026-10-30) against 169,120 bytes of terms HTML (heading "Last updated 2026-10-26",dateModified2026-10-30). The stub does not list prices or the unused-credits-on-close sentence. The HTML does list the same dollars and credit spends as/pricing/.pricing.mdis price-accurate and still thinner than the HTML. It is 760 bytes, Updated 2026-10-31, and it matches the two single-run prices and the three packs. It does not contain "Credits never expire." The pricing HTML repeats that sentence 4 times. The terms HTML does not use that sentence; it says unused purchased credits are not automatically erased when an account closes.
Configs and files
price_source_offer_audit(default in v14):data/price-source-offer-audit-2026-11-19.jsonloffer_audit_lib.py,validate_offer_audit.py- All earlier configs and data files from v1–v13 remain in the card and in the repo. Do not delete them.
Each row has id, kind, page, source, captured, offer_name, price, currency, credits, status, notes, plus meme, resolution, and extra when they apply. Kinds in this file: jsonld_offer, visible_offer, markdown_quote, terms_html_offer, llms_wording, date_field, name_collision, credit_mismatch, source_disagreement, consistent_pair, stub_gap.
Example rows (shortened):
{"id": "hitt-offer-052", "kind": "name_collision", "offer_name": "Seedance 2.0 · 480p", "status": "collision", "notes": "reused for 6 offer object(s) and 3 distinct (price, credits) pair(s)"}
{"id": "hitt-offer-057", "kind": "credit_mismatch", "offer_name": "Tiny Desk Outstanding · 720p vs Hit the Road Dude · 720p", "price": "12.99", "credits": 13, "status": "oddity"}
{"id": "hitt-offer-046", "kind": "llms_wording", "page": "/llms.txt", "status": "stale", "notes": "Prices and required credits vary by model and settings"}
{"id": "hitt-offer-058", "kind": "stub_gap", "page": "/terms/", "status": "mismatch", "extra": {"md_bytes": 345, "html_bytes": 169120}}
The task, and what leaks
Give a model the JSON-LD graph alone and ask what a 720p Hit the Road Dude run costs in credits. The name Seedance 2.0 · 720p is attached to both 13 and 14. Give it only llms.txt and ask whether prices vary by model. The only honest answer from this file is that the wording is stale, and that the live table names 480p and 720p at fixed prices. Give it only terms.md and ask what a pack costs, or what happens to unused credits if an account closes. The stub cannot answer; the HTML can. Hide status and notes if you want the model to find the collisions itself.
Validation (v14)
$ python3 validate_offer_audit.py data/price-source-offer-audit-2026-11-19.jsonl --live-dir /path/to/live
65 rows; kinds={'jsonld_offer': 20, 'visible_offer': 15, 'markdown_quote': 5, 'terms_html_offer': 5,
'llms_wording': 1, 'date_field': 5, 'name_collision': 5, 'credit_mismatch': 1, 'stub_gap': 1,
'source_disagreement': 2, 'consistent_pair': 5}
status={'info': 40, 'ok': 10, 'stale': 2, 'collision': 5, 'oddity': 2, 'mismatch': 1, 'consistent': 5}
schema: ok
canonical 480p/720p consistent_pair rows: ok
stale llms.txt wording row: present
Tiny Desk 13-vs-14 credit_mismatch row: present
against live pricing.html JSON-LD: 20 offers match the file
against live visible table: 13 meme/resolution rows match the file
against live JSON-LD name collisions: 2 colliding names recorded
against live llms.txt: vary-by-model sentence still present
against live terms.html: 5 stated prices match the file
against live pricing.md: 5 quotes match the file
against live terms.md / terms.html: 345 vs 169120 bytes match the file
recorded issues (mismatch/stale/oddity/collision): 10
Fetched 2026-11-19 09:23:47 CST (Asia/Shanghai). The run log is in files/hf_build/run_log.txt.
Earlier card (v13): HTML vs markdown-twin drift audit (Dataset Card v13, 2026-11-18)
What changed in v13 (2026-11-18): one new config, one data file, and two scripts. data/markdown-twin-drift-2026-11-18.jsonl is an HTML vs markdown-twin (+ llms.txt) drift audit of the live Hit the Road Dude pages, captured today. Each row is a page pair, a date field, a section-presence check, a wording claim, or a recorded issue: byte sizes, Updated / Last updated / dateModified values, whether a policy section exists in the HTML and in the twin, and whether a claim appears in the twin, the HTML, or llms.txt. The point is not to invent a "correct" page. It is to write down where today's representations disagree, so an answer engine can be tested against genuine stubs and stale wording instead of a cleaned copy. drift_audit_lib.py parses markdown-twin metadata and HTML date fields. validate_drift_audit.py checks the schema and re-reads today's capture to confirm the file still matches. Everything from v1 to v12 is unchanged and kept below.
Why this task: v12 audited JSON-LD offers against visible prices. That work still stands, and it is not repeated here. The harder everyday failure is different: a crawler or an assistant loads /privacy.md (369 bytes) and answers as if it had read /privacy/ (173,964 bytes of HTML). Dates on the same URL disagree with each other. faq.md is a thin twin of a much longer FAQ. llms.txt still describes prices as if you picked a model. A model that trusts the markdown twin, or only llms.txt, will miss deletion, share links, and the actual price rule.
Headline findings (built from today's capture, then checked by the validator against the same files):
privacy.mdis a stub, not a policy. 369 bytes vs 173,964-byte HTML (471.4×). The twin has a short Photos heading and "The photo you upload is used to make the clip you asked for." The HTML policy includes Account and orders, Photos and finished files, Contact drafts, Payments, Media processing, Your work and share links, Deleting a creation, and Operational measurement. All eight of those section titles are present in the HTML and absent from the twin.- Dates disagree, including inside a single HTML page.
privacy.mdsaysUpdated: 2026-10-30. The privacy HTML heading says "Last updated 2026-10-26"; JSON-LDdateModifiedis 2026-10-30. The same last-updated vs dateModified split appears on/refunds/,/terms/, and/acceptable-use/./faq/and/pricing/are internally consistent on dates (2026-11-02 and 2026-10-31). - Other policy twins are thin.
/faq.mdis 1,244 bytes vs 206,306-byte HTML./pricing.mdis 760 vs 222,226./refunds.md741 vs 167,336./help.md619 vs 208,112./terms.mdis another stub: 345 vs 169,120./acceptable-use.mdis 677 vs 173,379. The twins are useful abstracts. They are not complete copies. llms.txtis still stale on pricing. It says "Prices and required credits vary by model and settings; checkout refreshes the current quote." The live FAQ says you do not pick a model or write a prompt; you choose 480p or 720p, and the listed prices are fixed. I did not repeat thellms.txtwording as a fact in any other article in this set.- The cash prices for this studio are consistent where they appear in both twins and HTML. "9.99 USD at 480p", "12.99 USD at 720p", and the three pack amounts 27.99 / 71.99 / 129.99 are in both
pricing.mdand the pricing HTML.
Current facts as checked on 2026-11-18 (09:22–09:26 Asia/Shanghai, plus a terms / acceptable-use fetch later this morning): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal, and credits never expire. There are no free clips or free credits, and no subscription. Guest checkout is available for a single clip; buying a pack requires an account (pricing, FAQ). Pack run counts on the visible badges, 480p-only, are about 5 / 16 / 33 Hit the Road Dude runs. This site sells only 480p and 720p.
What this is not: no images, videos, faces, voices, generated outputs or user data. Only first-party page text and rows written from today's captures. It is not a claim about how any assistant performs. It is also not a suggestion to answer a privacy question from the markdown twin alone.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v13)
data/markdown-twin-drift-2026-11-18.jsonl, one record per row (61 rows in this capture):
| Field | Meaning |
|---|---|
id |
hitt-drift-001 … hitt-drift-061 |
kind |
page_pair, date_field, size_drift, date_mismatch, section_presence, llms_wording, or claim |
page, source |
Canonical path and which representation the row was taken from |
md_bytes, html_bytes |
Sizes when the row is about a page pair or a size drift |
md_updated, html_last_updated, html_date_modified, html_updated |
Date fields, or null |
status |
ok, info, consistent, mismatch, stale, stub, thin, or oddity |
notes |
Human-readable context; this is where a mismatch is described |
quote, field |
Optional needle or claim id |
captured |
2026-11-18 |
Today's file has 20 page-pair rows, 7 date fields, 7 size-drift rows, 4 date-mismatch rows, 8 privacy section-presence rows, 1 stale llms.txt wording row, and 14 claim rows. Status counts: info 27, mismatch 12, consistent 7, ok 6, thin 5, stub 2, stale 2. The validator reprints the issue list (21 rows in mismatch/stale/stub/thin/oddity).
Example rows (shortened):
{"id": "hitt-drift-004", "kind": "size_drift", "page": "/privacy/", "status": "stub", "md_bytes": 369, "html_bytes": 173964, "notes": "markdown twin is 369 bytes vs HTML 173964 bytes"}
{"id": "hitt-drift-005", "kind": "date_mismatch", "page": "/privacy/", "status": "mismatch", "notes": "markdown Updated=2026-10-30, HTML Last updated=2026-10-26, dateModified=2026-10-30"}
{"id": "hitt-drift-047", "kind": "llms_wording", "page": "/llms.txt", "status": "stale", "quote": "Prices and required credits vary by model and settings"}
The task, and what leaks
Give a model only the markdown twin for /privacy/ and ask whether a customer can delete a creation, whether share links exist, or whether the photo is used to train a model. Score it against the HTML-backed rows, not against the stub. The honest answers from this file are: deleting a creation is described in the HTML and is absent from the twin; training is not described in either representation; dates on the same URL disagree. A second task: given llms.txt, should the model say that prices vary by model? The only honest answer from this file is that the wording is stale, and that the FAQ names 480p and 720p at fixed prices. Hide status and notes if you want the model to find the stub itself.
Validation (v13)
$ python3 validate_drift_audit.py data/markdown-twin-drift-2026-11-18.jsonl --live-dir /path/to/live
61 rows; kinds={'page_pair': 20, 'date_field': 7, 'size_drift': 7, 'date_mismatch': 4,
'section_presence': 8, 'llms_wording': 1, 'claim': 14}
status={'info': 27, 'stub': 2, 'mismatch': 12, 'thin': 5, 'stale': 2, 'consistent': 7, 'ok': 6}
schema: ok
against live privacy.md / privacy.html: 369 vs 173964 bytes match the file
privacy date mismatch row present: md=2026-10-30 last=2026-10-26 dateModified=2026-10-30
stale llms.txt wording row: present
recorded issues (mismatch/stale/stub/thin/oddity): 21
The validator and the parser:
#!/usr/bin/env python3
"""Validate a markdown-twin drift jsonl and re-check it against today's live files."""
from __future__ import annotations
import argparse
import json
import sys
from collections import Counter
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from drift_audit_lib import STALE_LLMS, html_meta, md_meta, read # noqa: E402
REQUIRED = {"id", "kind", "page", "source", "status", "notes", "captured"}
ALLOWED_KIND = {
"page_pair",
"date_field",
"llms_wording",
"claim",
"section_presence",
"size_drift",
"date_mismatch",
}
ALLOWED_STATUS = {
"ok",
"info",
"mismatch",
"stale",
"stub",
"thin",
"oddity",
"consistent",
}
def load_rows(path: Path) -> list[dict]:
rows = []
for i, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
if not line.strip():
continue
row = json.loads(line)
rows.append(row)
return rows
def main() -> int:
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument("jsonl", type=Path)
ap.add_argument("--live-dir", type=Path, required=True)
args = ap.parse_args()
rows = load_rows(args.jsonl)
kinds = Counter(r["kind"] for r in rows)
statuses = Counter(r["status"] for r in rows)
print(
f"{len(rows)} rows; kinds={dict(kinds)}\n status={dict(statuses)}"
)
missing = []
for r in rows:
miss = REQUIRED - set(r)
if miss:
missing.append((r.get("id"), miss))
if r.get("kind") not in ALLOWED_KIND:
missing.append((r.get("id"), {f"bad kind {r.get('kind')}"}))
if r.get("status") not in ALLOWED_STATUS:
missing.append((r.get("id"), {f"bad status {r.get('status')}"}))
if r.get("captured") != "2026-11-18":
missing.append((r.get("id"), {"captured != 2026-11-18"}))
ids = [r["id"] for r in rows]
if len(ids) != len(set(ids)):
print("schema: duplicate ids")
return 1
if missing:
print("schema: FAILED")
for i, m in missing[:12]:
print(f" {i}: {m}")
return 1
print("schema: ok")
live = args.live_dir
# Re-read privacy sizes and dates.
priv_md = live / "privacy.md"
priv_html = live / "html" / "privacy.html"
if not priv_md.is_file() or not priv_html.is_file():
print("against live privacy: missing files")
return 1
md = md_meta(read(priv_md))
ht = html_meta(read(priv_html))
size_rows = [
r
for r in rows
if r["page"] == "/privacy/" and r["kind"] == "size_drift"
]
date_rows = [
r
for r in rows
if r["page"] == "/privacy/" and r["kind"] == "date_mismatch"
]
if not size_rows:
print("against live privacy: missing size_drift row")
return 1
rec_md, rec_html = size_rows[0].get("md_bytes"), size_rows[0].get("html_bytes")
if rec_md != md["bytes"] or rec_html != ht["bytes"]:
print(
f"against live privacy: size mismatch file has md={rec_md} html={rec_html} "
f"live md={md['bytes']} html={ht['bytes']}"
)
return 1
print(f"against live privacy.md / privacy.html: {md['bytes']} vs {ht['bytes']} bytes match the file")
if date_rows:
print(
"privacy date mismatch row present: "
f"md={md['updated']} last={ht['last_updated']} dateModified={ht['date_modified']}"
)
llms = live / "llms.txt"
llms_text = read(llms) if llms.is_file() else ""
stale_rows = [r for r in rows if r["kind"] == "llms_wording"]
if not stale_rows:
print("stale llms.txt wording row: missing")
return 1
if STALE_LLMS.lower() in llms_text.lower():
if stale_rows[0]["status"] != "stale":
print("stale llms.txt wording row: live text is stale but row status is not")
return 1
print("stale llms.txt wording row: present")
else:
print("stale llms.txt wording row: wording no longer in live llms.txt")
return 1
issues = [r for r in rows if r["status"] in {"mismatch", "stale", "stub", "thin", "oddity"}]
print(f"recorded issues (mismatch/stale/stub/thin/oddity): {len(issues)}")
for r in issues:
print(f" {r['id']} {r['status']} {r['kind']} {r['page']}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Parse markdown twins, HTML captures, and llms.txt for a drift audit."""
from __future__ import annotations
import re
from pathlib import Path
DATE_RE = re.compile(r"2026-\d{2}-\d{2}")
MD_UPDATED_RE = re.compile(r"^Updated:\s*(2026-\d{2}-\d{2})\s*$", re.M)
HTML_LAST_RE = re.compile(r"Last updated\s*(2026-\d{2}-\d{2})", re.I)
HTML_FOOTER_RE = re.compile(r"Updated\s+(2026-\d{2}-\d{2})")
JSONLD_MOD_RE = re.compile(r'"dateModified"\s*:\s*"(2026-\d{2}-\d{2})"')
JSONLD_PUB_RE = re.compile(r'"datePublished"\s*:\s*"(2026-\d{2}-\d{2})"')
STALE_LLMS = "Prices and required credits vary by model and settings"
# Sections the HTML policy pages actually use (from today's captures).
PRIVACY_SECTIONS = [
"Account and orders",
"Photos and finished files",
"Contact drafts",
"Payments",
"Media processing",
"Your work and share links",
"Deleting a creation",
"Operational measurement",
]
# Claims we check across representations. Each is (id, page, needle, where_expected).
# where_expected is "html", "md", "llms", or "faq_html".
CLAIM_NEEDLES = [
("privacy_photo_used_for_clip", "/privacy/", "used to make the clip you asked for", "both"),
("privacy_photo_used_for_generation", "/privacy/", "used to make the generation you start", "html"),
("privacy_deleting_a_creation", "/privacy/", "Deleting a creation", "html"),
("privacy_train", "/privacy/", "train", "none"),
("privacy_delete_account", "/privacy/", "delete your account", "none"),
("faq_every_clip_is_15", "/faq/", "Every clip is 15 seconds", "both"),
("faq_no_model_picker", "/faq/", "You do not pick a model or write a prompt", "html"),
("pricing_480p", "/pricing/", "480p is 9.99 USD (6 credits)", "md"),
("llms_stale_model_wording", "/llms.txt", STALE_LLMS, "llms"),
]
def read(path: Path) -> str:
return path.read_text(encoding="utf-8", errors="replace")
def md_meta(text: str) -> dict:
updated = MD_UPDATED_RE.search(text)
canon = re.search(r"Canonical page:\s*(\S+)", text)
return {
"updated": updated.group(1) if updated else None,
"canonical": canon.group(1) if canon else None,
"bytes": len(text.encode("utf-8")),
"chars": len(text),
"headings": re.findall(r"^##\s+(.+)$", text, re.M),
}
def html_meta(text: str) -> dict:
last = HTML_LAST_RE.findall(text)
foot = HTML_FOOTER_RE.findall(text)
mod = JSONLD_MOD_RE.findall(text)
pub = JSONLD_PUB_RE.findall(text)
return {
"last_updated": last[0] if last else None,
"footer_updated": foot[-1] if foot else None,
"date_modified": mod[0] if mod else None,
"date_published": pub[0] if pub else None,
"bytes": len(text.encode("utf-8")),
"chars": len(text),
"all_last_updated": sorted(set(last)),
"all_date_modified": sorted(set(mod)),
}
def contains(text: str, needle: str) -> bool:
return needle.lower() in text.lower()
def pair_status(md_bytes: int, html_bytes: int, md_date, html_last, html_mod) -> list[dict]:
issues = []
if md_bytes < 2000 and html_bytes > 50_000:
kind = "stub" if md_bytes < 500 else "thin"
issues.append(
{
"kind": "size_drift",
"status": kind,
"notes": f"markdown twin is {md_bytes} bytes vs HTML {html_bytes} bytes",
}
)
dates = {d for d in (md_date, html_last, html_mod) if d}
if len(dates) > 1:
issues.append(
{
"kind": "date_mismatch",
"status": "mismatch",
"notes": (
f"dates disagree: markdown Updated={md_date}, "
f"HTML Last updated={html_last}, dateModified={html_mod}"
),
}
)
return issues
The build script that produced the jsonl from today's captures lives in files/hf_build/build_drift_audit.py. The run log is files/hf_build/run_log.txt. Pages were fetched 2026-11-18 in Asia/Shanghai; /pricing.md and /pricing/ were re-checked at 09:22–09:26; /terms/ and /acceptable-use/ were fetched later the same morning.
Earlier card (v12): JSON-LD and visible-price consistency audit (Dataset Card v12, 2026-11-17)
What changed in v12 (2026-11-17): one new config, one data file, and two scripts. data/jsonld-price-audit-2026-11-17.jsonl is a JSON-LD + visible-price consistency audit of the live Hit the Road Dude pages, captured today. Each row is an offer, a date, a wording quote, or a recorded mismatch: offer name, cash price, currency, and credits, taken from JSON-LD, from the visible HTML tables, from pricing.md, or from llms.txt. The point is not to invent a "correct" price in the dataset. It is to write down where today's sources agree and where they don't, so an answer engine can be tested against genuine inconsistencies instead of a cleaned table. price_audit_lib.py parses JSON-LD offers and the visible "What each meme costs" table. validate_price_audit.py checks the schema and re-parses today's capture to confirm the file still matches. Everything from v1 to v11 is unchanged and kept below.
Why this task: v6 extracted price quotes as spans, and v11 asked which exact words answer a question. Neither one tests the harder case an assistant now walks into: the visible table, the markdown twin, and the JSON-LD Offer graph on the same URL do not always say the same thing, and llms.txt can lag the studio. A model that trusts only JSON-LD, or only llms.txt, will report the wrong credits or invent a model picker this site does not have.
Headline findings (re-parsed from today's capture, then checked by the validator against the same files):
- The cash prices for this studio are consistent where it counts. Hit the Road Dude 480p $9.99 / 6 credits and 720p $12.99 / 14 credits appear in
pricing.md, in the visible single-run table, in the visible cross-site row for this meme, and in JSON-LD Offers. The three signed-in packs — $27.99 / 30, $71.99 / 100, $129.99 / 200 — match acrosspricing.mdand JSON-LD (and the visible pack cards). - JSON-LD offer names lose the meme and collide. Most single-run Offers are named
Seedance 2.0 · 480porSeedance 2.0 · 720p. The 480p name is reused for $6.99 / 2 credits, $7.99 / 4 credits, and $9.99 / 6 credits. The 720p name is reused for $8.99 / 5, $9.99 / 8, $12.99 / 13, and $12.99 / 14. A crawler cannot tell which meme an offer belongs to from the name alone. - 13 credits is a real visible figure, but not this site's 720p cost. The cross-site table lists Tiny Desk Outstanding 720p at $12.99 · 13 credits. JSON-LD has an Offer named
Seedance 2.0 · 720pat that same pair, sitting next to anotherSeedance 2.0 · 720pat $12.99 / 14 (this studio). 14 is the number on the Hit the Road Dude single-run table, the FAQ, andpricing.md. llms.txtis stale on pricing. It still says "Prices and required credits vary by model and settings; checkout refreshes the current quote." The live FAQ says you do not pick a model or write a prompt; you choose 480p or 720p, and the prices above are listed. I did not repeat thellms.txtwording as a fact in any other article in this set.- The privacy markdown twin is not a full copy of the policy.
privacy.mdis 369 bytes and stops after a short Photos section;privacy.htmlis 173,926 bytes and includes share links, deletion, the session cookie, and measurement.privacy.htmlsays "Last updated 2026-10-26";privacy.mdsays "Updated: 2026-10-30". The pricing page is internally consistent on dates: HTML "Updated 2026-10-31" and JSON-LDdateModified2026-10-31.
Current facts as checked on 2026-11-17 (09:25 Asia/Shanghai): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal, and credits never expire. There are no free clips or free credits, and no subscription. Guest checkout is available for a single clip; buying a pack requires an account (pricing, FAQ). Pack run counts on the visible badges, 480p-only, are about 5 / 16 / 33 Hit the Road Dude runs.
What this is not: no images, videos, faces, voices, generated outputs or user data. Only first-party page text, JSON-LD, and rows written by the site's builder. It is not a claim about how any assistant performs. It is also not a suggestion to quote another meme's price as this studio's price.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v12)
data/jsonld-price-audit-2026-11-17.jsonl, one record per row (56 rows in this capture):
| Field | Meaning |
|---|---|
id |
hitt-price-001 … hitt-price-056 |
kind |
jsonld_offer, visible_offer, markdown_quote, llms_wording, date_field, consistent_pair, or mismatch |
page, source |
Canonical path and which representation the row was taken from |
offer_name, price, currency, credits |
The four fields an Offer should make unambiguous; null when the row is about wording or a date |
meme, resolution |
Filled for visible table rows and for the consistent-pair checks |
status |
ok, info, consistent, mismatch, stale, or oddity |
notes |
Human-readable context; this is where a mismatch is described |
captured |
2026-11-17 |
Today's file has 20 JSON-LD offers, 15 visible offer rows, 5 markdown quotes, 1 stale llms.txt wording row, 5 date fields, 5 consistent pairs, and 5 mismatch records (3 mismatch, 2 oddity in status, plus the stale wording row). The validator reprints the issue list.
Example rows (shortened):
{"id": "hitt-price-048", "kind": "consistent_pair", "page": "/pricing/", "offer_name": "Hit the Road Dude · 480p", "price": "9.99", "currency": "USD", "credits": 6, "status": "consistent"}
{"id": "hitt-price-051", "kind": "mismatch", "page": "/pricing/", "offer_name": "Seedance 2.0 · 720p", "status": "mismatch", "notes": "JSON-LD repeats the offer name with (12.99, 13), (12.99, 14), (8.99, 5), (9.99, 8)"}
{"id": "hitt-price-041", "kind": "llms_wording", "page": "/llms.txt", "status": "stale", "notes": "Prices and required credits vary by model and settings..."}
The task, and what leaks
Give a model a page URL and ask for the studio's 480p price, 720p credits, or pack prices. Score it against the consistent_pair rows, not against a random JSON-LD Offer that happens to share a name. A second task: given a JSON-LD Offer named Seedance 2.0 · 720p, should the model report 13 credits or 14? The only honest answer from this file is that the name is ambiguous, and that 14 is this site's listed 720p cost. Hide status and notes if you want the model to find the collision itself.
Validation (v12)
$ python3 validate_price_audit.py data/jsonld-price-audit-2026-11-17.jsonl --live-dir /path/to/live
56 rows; kinds={jsonld_offer: 20, visible_offer: 15, markdown_quote: 5,
llms_wording: 1, date_field: 5, mismatch: 5, consistent_pair: 5}
status={info: 40, ok: 5, stale: 1, mismatch: 3, consistent: 5, oddity: 2}
schema: ok
canonical 480p/720p consistent_pair rows: ok
against live pricing.html JSON-LD: 20 offers match the file
against live visible table: 13 meme/resolution rows match the file
stale llms.txt wording row: present
recorded issues (mismatch/stale/oddity): 6
The validator and the parser:
#!/usr/bin/env python3
"""Validate the JSON-LD + visible-price audit jsonl, optionally re-checking captures.
Usage:
python3 validate_price_audit.py data/jsonld-price-audit-2026-11-17.jsonl
python3 validate_price_audit.py data/jsonld-price-audit-2026-11-17.jsonl --live-dir /path/to/live
"""
import argparse, os, sys
from collections import Counter
from price_audit_lib import (
load_jsonl, validate_row, extract_jsonld_blocks, walk_offers,
credits_from_text, visible_text, parse_visible_meme_table,
parse_this_site_single_run,
)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("jsonl")
ap.add_argument("--live-dir", help="re-parse pricing.html and compare offers")
args = ap.parse_args()
rows = load_jsonl(args.jsonl)
errors = []
ids = []
for i, row in enumerate(rows, 1):
err = validate_row(row, i)
if err:
errors.append(err)
ids.append(row.get("id"))
if len(ids) != len(set(ids)):
errors.append("duplicate ids")
print(f"{len(rows)} rows; kinds={dict(Counter(r['kind'] for r in rows))} "
f"status={dict(Counter(r['status'] for r in rows))}")
if errors:
print("SCHEMA ERRORS:")
for e in errors:
print(" ", e)
sys.exit(1)
print("schema: ok")
# Sanity: canonical Hit the Road Dude prices must appear as consistent_pair
need = {("480p", "9.99", 6), ("720p", "12.99", 14)}
have = set()
for r in rows:
if r["kind"] == "consistent_pair" and r.get("resolution"):
have.add((r["resolution"], r["price"], r["credits"]))
missing = need - have
if missing:
print("missing canonical consistent_pair rows:", missing)
sys.exit(1)
print("canonical 480p/720p consistent_pair rows: ok")
if args.live_dir:
html = open(os.path.join(args.live_dir, "html/hitt-pricing.html"),
encoding="utf-8", errors="replace").read()
offers = []
for b in extract_jsonld_blocks(html):
offers.extend(walk_offers(b))
live_pairs = []
for off in offers:
live_pairs.append((
off.get("name"),
str(off.get("price")) if off.get("price") is not None else None,
off.get("priceCurrency"),
credits_from_text(off.get("description") or "") or credits_from_text(off.get("name") or ""),
))
file_pairs = [
(r["offer_name"], r["price"], r["currency"], r["credits"])
for r in rows if r["kind"] == "jsonld_offer"
]
if live_pairs != file_pairs:
print(f"JSON-LD drift: live has {len(live_pairs)} offers, file has {len(file_pairs)}")
only_live = [p for p in live_pairs if p not in file_pairs]
only_file = [p for p in file_pairs if p not in live_pairs]
print(" only live:", only_live[:8], "..." if len(only_live) > 8 else "")
print(" only file:", only_file[:8], "..." if len(only_file) > 8 else "")
sys.exit(1)
print(f"against live pricing.html JSON-LD: {len(live_pairs)} offers match the file")
vtext = visible_text(html)
meme = parse_visible_meme_table(vtext)
file_vis = [
(r.get("meme"), r.get("resolution"), r["price"], r["credits"])
for r in rows if r["kind"] == "visible_offer" and r["source"] == "visible_cross_site_table"
]
live_vis = [(r["meme"], r["resolution"], r["price"], r["credits"]) for r in meme]
if live_vis != file_vis:
print("visible cross-site table drift:")
print(" live", live_vis)
print(" file", file_vis)
sys.exit(1)
print(f"against live visible table: {len(live_vis)} meme/resolution rows match the file")
# The stale llms sentence must still be recorded
stale = [r for r in rows if r["kind"] == "llms_wording" and r["status"] == "stale"]
if not stale:
print("missing llms_wording stale row")
sys.exit(1)
print("stale llms.txt wording row: present")
# Count useful mismatch/oddity rows for the card
bad = [r for r in rows if r["status"] in {"mismatch", "stale", "oddity"}]
print(f"recorded issues (mismatch/stale/oddity): {len(bad)}")
for r in bad:
print(f" {r['id']} [{r['status']}] {r['offer_name']}: {r['notes'][:120]}")
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""Helpers for the JSON-LD + visible-price consistency audit."""
import json, re, hashlib
from html import unescape
MONEY = re.compile(r"\$?\s*([0-9]+(?:\.[0-9]+)?)\s*(?:USD|usd)?")
CREDITS = re.compile(r"([0-9]+)\s*credits?", re.I)
def sha256_text(s: str) -> str:
return hashlib.sha256(s.encode("utf-8")).hexdigest()
def load_jsonl(path):
rows = []
with open(path, encoding="utf-8") as f:
for i, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
rows.append(json.loads(line))
return rows
def required_fields(row):
return [
"id", "kind", "page", "source", "captured",
"offer_name", "price", "currency", "credits",
"status", "notes",
]
def validate_row(row, idx):
missing = [k for k in required_fields(row) if k not in row]
if missing:
return f"row {idx} ({row.get('id')}) missing {missing}"
if row["kind"] not in {
"jsonld_offer", "visible_offer", "markdown_quote", "llms_wording",
"date_field", "mismatch", "consistent_pair",
}:
return f"row {idx} bad kind {row['kind']}"
if row["status"] not in {
"ok", "mismatch", "stale", "oddity", "info", "consistent",
}:
return f"row {idx} bad status {row['status']}"
if row["price"] not in (None, "") and row["kind"] != "llms_wording":
try:
float(row["price"])
except (TypeError, ValueError):
return f"row {idx} price not numeric: {row['price']!r}"
if row["credits"] not in (None, ""):
try:
int(row["credits"])
except (TypeError, ValueError):
return f"row {idx} credits not int: {row['credits']!r}"
return None
def extract_jsonld_blocks(html: str):
blocks = []
for m in re.finditer(
r'<script[^>]*type=["\']application/ld\+json["\'][^>]*>(.*?)</script>',
html, flags=re.S | re.I,
):
raw = unescape(m.group(1).strip())
try:
blocks.append(json.loads(raw))
except json.JSONDecodeError:
blocks.append({"_parse_error": True, "_raw": raw[:200]})
return blocks
def walk_offers(node, acc=None):
acc = acc if acc is not None else []
if isinstance(node, dict):
typ = node.get("@type")
types = typ if isinstance(typ, list) else [typ]
if "Offer" in types:
acc.append(node)
for v in node.values():
walk_offers(v, acc)
elif isinstance(node, list):
for v in node:
walk_offers(v, acc)
return acc
def credits_from_text(text):
if not text:
return None
m = CREDITS.search(str(text))
return int(m.group(1)) if m else None
def visible_text(html: str) -> str:
text = re.sub(r"(?is)<script[^>]*>.*?</script>", " ", html)
text = re.sub(r"(?is)<style[^>]*>.*?</style>", " ", text)
text = re.sub(r"(?is)</(h[1-6]|p|tr|li|div|td|th|section)>", "\n", text)
text = re.sub(r"(?is)<br[^>]*>", "\n", text)
text = re.sub(r"(?is)<[^>]+>", " ", text)
text = unescape(text)
for a, b in [(" ", " "), ("'", "'"), ("·", "·")]:
text = text.replace(a, b)
text = re.sub(r"[ \t]+", " ", text)
text = re.sub(r"\n[ \t]+", "\n", text)
text = re.sub(r"\n{3,}", "\n\n", text)
return text
def parse_visible_meme_table(text: str):
"""Parse the 'What each meme costs' table from visible pricing text.
Returns rows: {meme, resolution, price, credits}.
"""
# Block starts at the heading and ends at "Run counts use"
start = text.find("What each meme costs")
if start < 0:
return []
end = text.find("Run counts use", start)
block = text[start:end if end > start else start + 4000]
rows = []
current = None
for ln in block.splitlines():
s = ln.strip()
if not s:
continue
# A meme name line: no leading resolution / price
m_price = re.match(
r"^(480p|720p|1K)\s+\$([0-9.]+)\s*·\s*([0-9]+)\s*credits?\s*$", s, re.I
)
if m_price:
if current:
rows.append({
"meme": current,
"resolution": m_price.group(1),
"price": m_price.group(2),
"credits": int(m_price.group(3)),
"currency": "USD",
})
continue
if s in {"Meme", "One run", "30 credits", "100 credits", "200 credits",
"What each meme costs"}:
continue
if s.startswith("≈"):
continue
# otherwise treat as a meme name
if re.search(r"[A-Za-z]", s) and "$" not in s:
current = s.rstrip()
return rows
def parse_this_site_single_run(text: str):
"""The 'Single-run price list · Hit the Road Dude' block."""
start = text.find("Single-run price list")
if start < 0:
return []
end = text.find("Packs hold", start)
block = text[start:end if end > start else start + 1500]
rows = []
# "Resolution 480p" then "$9.99" then "6 credits"
parts = re.findall(
r"Resolution\s+(480p|720p)\s+\$([0-9.]+)\s+([0-9]+)\s+credits",
block, flags=re.S,
)
for res, price, cred in parts:
rows.append({
"meme": "Hit the Road Dude",
"resolution": res,
"price": price,
"credits": int(cred),
"currency": "USD",
})
return rows
def extract_date_mentions(html_or_md: str):
"""Find Updated / Last updated / dateModified values."""
found = []
for pat, label in (
(r'dateModified"\s*:\s*"([^"]+)"', "dateModified"),
(r"Last updated\s+([0-9]{4}-[0-9]{2}-[0-9]{2})", "Last updated"),
(r"Updated:\s*([0-9]{4}-[0-9]{2}-[0-9]{2})", "Updated"),
(r"Updated\s+([0-9]{4}-[0-9]{2}-[0-9]{2})", "Updated"),
):
for m in re.finditer(pat, html_or_md):
found.append((label, m.group(1)))
return found
The build script that produced the jsonl from today's captures lives in files/hf_build/build_price_audit.py. The run log is files/hf_build/run_log.txt. Pages were fetched 2026-11-17 in Asia/Shanghai; /pricing.md, /pricing/, and /faq/ were re-checked at 09:25.
Earlier card (v11): extractive QA spans with unanswerable questions (Dataset Card v11, 2026-11-16)
What changed in v11 (2026-11-16): one new file and two scripts. data/qa-spans-2026-11-16.jsonl has 41 questions of the kind people ask assistants about the Hit the Road Dude / State Property meme generator at hittheroaddude.app. Each question is paired with one paragraph from the site's own markdown twins (/pricing.md, /faq.md, /index.md and 11 more) and a character-exact answer span in that paragraph, in SQuAD 2.0 format. 6 questions are deliberately unanswerable from the site, for example "How long does it take for the video to be ready?", "Is there a discount code?", or "Where is the pond in the original video?". Their context is the paragraph an assistant would most likely, and wrongly, answer from. qa_spans_lib.py checks spans and holds a lexical baseline. validate_qa_spans.py validates the file, re-checks it against saved or live markdown, and scores the baseline. Everything from v1 to v10 is unchanged and kept below.
Why this task: v6 extracted price quotes, and v7 verified whole claims. This version asks the narrower question an answer engine actually faces: given the page, which exact words answer the question, and when should it say the page doesn't say? The unanswerable rows matter most here. Generation time, discounts and refund timing are things assistants confidently make up, and the site states none of them.
Headline findings:
- All 41 spans are byte-identical on the live site (re-fetched 2026-11-16 09:48 CST). All 14 markdown twins hash the same as the 09:24 capture.
- The same 41 rows checked against the 2026-11-02 capture: only 17 rows are byte-identical, and 24 drifted. 14 of those changed elsewhere in the document but kept their paragraph intact. 7 rows have an answer that isn't in the 2026-11-02 text at all. Four are price rows, because on 2026-11-02 the price was $4.99 / $6.99 (1 / 2 credits), not today's $9.99 / $12.99 (6 / 14 credits). Two are FAQ answers and one is an About sentence that were added after that date. A QA set built on the 2026-11-02 pages would have taught the old prices.
- A word-overlap baseline is weak in a useful way. Picking the context sentence that shares the most content words with the question gets exact match 0.34, containment 0.69 and token F1 0.54 on the 29 English answerable rows. It gets 0.00 EM on the 6 non-English questions (zh, es, pt, de, ja against English pages), and abstains correctly on only 3 of 6 unanswerable questions. The other three share a word with some sentence, so the baseline answers anyway, which is exactly the failure this set exists to catch.
Current facts as checked on 2026-11-16 (09:34 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal (pricing, FAQ). The markdown twins are byte-identical to 2026-11-15.
What this is not: no images, videos, faces, voices, generated outputs or user data. Only first-party page text and questions written by the site's builder. It isn't a claim about how any assistant performs.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v11)
data/qa-spans-2026-11-16.jsonl, one question per row:
| Field | Meaning |
|---|---|
id |
hitt-qa-001 … hitt-qa-041 |
page, md_url |
Canonical path and the markdown twin the context comes from |
lang |
Language of the question: en 35, zh 2, es 1, pt 1, de 1, ja 1 (contexts are always English) |
question |
The question as a user might type it to an assistant |
context |
One paragraph of the markdown twin, exactly as published (split on blank lines) |
paragraph_index |
Index of that paragraph in the twin, 0-based, headings included |
answers |
SQuAD format: {"text": [...], "answer_start": [...]}; empty lists for unanswerable rows |
is_impossible |
true for the 6 rows the site does not answer |
doc_sha256 |
SHA-256 of the whole markdown twin on 2026-11-16, so drift is detectable |
captured |
2026-11-16 |
Example rows (shortened):
{"id": "hitt-qa-003", "page": "/pricing/", "lang": "en", "question": "How many credits does a 720p clip use?", "context": "480p is 9.99 USD (6 credits). 720p is 12.99 USD (14 credits).", "answers": {"text": ["720p is 12.99 USD (14 credits)"], "answer_start": [30]}, "is_impossible": false}
{"id": "hitt-qa-014", "page": "/faq/", "lang": "en", "question": "How long does it take for the video to be ready?", "context": "The studio makes one 15-second vertical clip ... You pick 480p or 720p, see the total and pay before it starts.", "answers": {"text": [], "answer_start": []}, "is_impossible": true}
The task, and what leaks
Give a model question and context and ask for the shortest exact span that answers it, or "no answer". Score with SQuAD 2.0 EM/F1, and score unanswerable rows separately: a model that always answers gets them all wrong. Hide answers and is_impossible. page gives a hint for the unanswerable rows only in the sense that some pages have more of them. For a retrieval variant, hide context too and let the model fetch md_url.
Validation and baseline (v11)
$ python3 validate_qa_spans.py data/qa-spans-2026-11-16.jsonl --live
41 rows, 6 unanswerable, 14 pages, langs {'en': 35, 'zh': 2, 'es': 1, 'pt': 1, 'de': 1, 'ja': 1}; spans: ok
against live: 14 docs, 41 rows byte-identical, 0 drifted
lexical baseline (best-overlap sentence, abstain below 1 shared content word):
slice n EM contains F1
en 29 0.34 0.69 0.54
non-en 6 0.00 0.17 0.10
unanswerable 6 0.50 0.50 0.50
all 41 0.32 0.59 0.47
$ python3 validate_qa_spans.py data/qa-spans-2026-11-16.jsonl --md-dir md-2026-11-02/
against md-2026-11-02/: 14 docs, 17 rows byte-identical, 24 drifted
14 doc changed, paragraph intact
7 ANSWER GONE
2 context rewritten (unanswerable row: re-check it is still unanswerable)
1 paragraph rewritten, answer text still present
hitt-qa-001 /pricing/ answer gone
hitt-qa-002 /pricing/ answer gone
hitt-qa-003 /pricing/ answer gone
hitt-qa-007 /pricing/ answer gone
hitt-qa-009 /faq/ answer gone
hitt-qa-010 /faq/ answer gone
hitt-qa-040 /about/ answer gone
(md-2026-11-02/ is the builder's own capture of the twins from that day. It isn't included in this repo. The drift check works on any directory of saved twins named like pricing.md, guides_480p-or-720p.md.)
"Contains" counts a prediction as right if the gold span is inside the predicted sentence, which is the fairer score for a sentence-level baseline. For unanswerable rows every column means "abstained".
#!/usr/bin/env python3
"""Validate data/qa-spans-*.jsonl and run the lexical baseline.
usage: validate_qa_spans.py data/qa-spans-2026-11-16.jsonl [--md-dir DIR | --live]
--md-dir compare against saved markdown twins (file names like pricing.md, guides_480p-or-720p.md)
--live re-fetch every md twin and report rows whose answer is gone or moved
"""
import argparse, collections, sys, urllib.request
import qa_spans_lib as L
def fetch(url):
req = urllib.request.Request(url, headers={"User-Agent": "qa-spans-validator/1.0"})
with urllib.request.urlopen(req, timeout=60) as r:
return r.read().decode("utf-8")
def md_name(url):
p = url.split("hittheroaddude.app/", 1)[1]
return p.replace("/", "_")
ap = argparse.ArgumentParser()
ap.add_argument("path")
g = ap.add_mutually_exclusive_group()
g.add_argument("--md-dir"); g.add_argument("--live", action="store_true")
a = ap.parse_args()
rows = L.load(a.path)
problems = {r["id"]: L.check_row(r) for r in rows}
bad = {k: v for k, v in problems.items() if v}
langs = collections.Counter(r["lang"] for r in rows)
print(f"{len(rows)} rows, {sum(r['is_impossible'] for r in rows)} unanswerable, "
f"{len({r['page'] for r in rows})} pages, langs {dict(langs)}; spans: {'ok' if not bad else bad}")
if a.md_dir or a.live:
docs, drift = {}, []
for r in rows:
u = r["md_url"]
if u not in docs:
docs[u] = fetch(u) if a.live else open(f"{a.md_dir}/{md_name(u)}", encoding="utf-8").read()
text = docs[u]
if L.sha(text) == r["doc_sha256"]:
continue
paras = L.paragraphs(text)
if r["context"] in paras:
status = "doc changed, paragraph intact"
elif r["is_impossible"]:
status = "context rewritten (unanswerable row: re-check it is still unanswerable)"
elif any(r["answers"]["text"][0] in p for p in paras):
status = "paragraph rewritten, answer text still present"
else:
status = "ANSWER GONE"
drift.append((r["id"], r["page"], status))
src = "live" if a.live else a.md_dir
print(f"against {src}: {len(docs)} docs, {len(rows) - len(drift)} rows byte-identical, {len(drift)} drifted")
for k, v in collections.Counter(d[2] for d in drift).most_common():
print(f" {v:>3} {k}")
for d in drift:
if d[2] == "ANSWER GONE":
print(" ", d[0], d[1], "answer gone")
print("\nlexical baseline (best-overlap sentence, abstain below 1 shared content word):")
by = collections.defaultdict(list)
for r in rows:
pred = L.baseline(r["question"], r["context"])
em, contains, f1 = L.score(r, pred)
key = "unanswerable" if r["is_impossible"] else ("en" if r["lang"] == "en" else "non-en")
by[key].append((em, contains, f1)); by["all"].append((em, contains, f1))
print(f" {'slice':<13}{'n':>4}{'EM':>7}{'contains':>10}{'F1':>7}")
for k in ("en", "non-en", "unanswerable", "all"):
v = by[k]
print(f" {k:<13}{len(v):>4}" + "".join(f"{sum(x[i] for x in v) / len(v):>{w}.2f}" for i, w in ((0, 7), (1, 10), (2, 7))))
sys.exit(1 if bad else 0)
Using it
from datasets import load_dataset
qa = load_dataset("conan123/hittheroaddude-guides", "qa_spans", split="train")
row = qa[0]
s = row["answers"]["answer_start"][0]
assert row["context"][s:s + len(row["answers"]["text"][0])] == row["answers"]["text"][0]
Re-check against the live site at any time with python3 validate_qa_spans.py data/qa-spans-2026-11-16.jsonl --live. Rows marked ANSWER GONE mean the page no longer says it. An assistant that still gives that answer is quoting an old page.
Limits
41 questions, all written by one person, about one small site, so it's an evaluation set, not training data. Contexts are single paragraphs, so the multi-paragraph reasoning a real page sometimes needs isn't tested. The non-English questions are short and have English contexts. They test cross-lingual matching, not multilingual pages. "Unanswerable" means unanswerable from this site on 2026-11-16. It doesn't mean the fact is unknowable.
Licence
CC BY 4.0. Page text quoted from hittheroaddude.app by its builder.
Earlier card (v10): page freshness signals and stale-date detection (Dataset Card v10, 2026-11-15)
What changed in v10 (2026-11-15): one new file and two scripts. data/freshness-2026-11-15.jsonl has 40 pages of hittheroaddude.app, each with every date signal the page (or the sitemap) publishes about itself: sitemap <lastmod>, JSON-LD dateModified and datePublished, every <time datetime> on the HTML, the Updated: / Published: lines of the markdown twin, and the HTTP Last-Modified header (as GMT and as Asia/Shanghai). Beside those sit the text changes actually observed in daily captures (from the v8 page history, 2026-11-02 to 2026-11-12, plus an md comparison against 2026-11-15). freshness_lib.py parses the signals and scores four flags. validate_freshness.py recomputes the flags, scores each signal as a change detector on the one window where text actually changed, and (with --live) re-fetches every page to see whether a signal has moved. Everything from v1 to v9 is unchanged and kept below.
The question behind it: v8 asked which lines of a page changed. This version asks a narrower, more practical question an assistant or a crawler actually has to answer: if I only look at the dates the page publishes, would I have known it changed? And would I have known when?
The headline findings:
- Declared dates missed the three most important changes. Of 26 pages captured on both 2026-11-02 and 2026-11-03, 10 changed in that window (the price rewrite and a handful of rewrites the same day). Sitemap
lastmod, JSON-LDdateModifiedand the markdownUpdated:line all have precision 1.00 and recall 0.70: they flagged 7 of the 10 correctly and produced no false positives. They missed/,/pricing/and/guides/480p-or-720p/. Those three still declare 2026-10-31 or 2026-10-30, even though their text changed on 2026-11-03, when the 480p / 720p prices moved from $4.99 / $6.99 to $9.99 / $12.99. A crawler that only trustslastmodordateModifiedwould still treat the old prices as current. - HTTP
Last-Modifiedcaught all 10, and also 16 that didn't change. Every page on the site returnsLast-Modified: Tue, 03 Nov 2026 02:44:5x GMT(10:44 on 2026-11-03, Asia/Shanghai), within a few seconds of each other. That's a deployment timestamp, not a content date, so it has recall 1.00 and precision 0.38. Of the 28 pages that declare any date, all 28 have an HTTP date later than that declared date. - 12 of 40 pages declare no last-modified date at all:
/explore/,/templates/,/templates/pet-driver/,/templates/pickup-window/,/changelog/,/dmca/, and the six/memes/*showcase pages. They have no<lastmod>in the sitemap and no JSON-LDdateModified. - Nothing in the markdown twins changed between 2026-11-12 and 2026-11-15. The 11-03 rewrite is still the last observed text change.
Current facts as checked on 2026-11-15 (09:33 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal (pricing, FAQ). Prices have been unchanged, on every page that states them, since 2026-11-03. An answer that still says $4.99 is quoting a page from 2026-11-02, or a freshness signal that was never updated.
What this is not: no images, videos, faces, voices, generated outputs or user data. Date metadata and a first-party change log. It is not a crawl of the web, and it is not a claim about how any search engine treats these dates.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v10)
data/freshness-2026-11-15.jsonl, one page per row:
| Field | Meaning |
|---|---|
id |
hitt-fr-001 … hitt-fr-040 |
page, url, md_url |
Canonical path, HTML URL, and the markdown twin if one exists (28 of 40) |
http_status |
HEAD status on 2026-11-15 (always 200) |
sitemap_lastmod |
<lastmod> from sitemap-pages.xml or sitemap-memes.xml, or null |
jsonld_date_modified, jsonld_date_published |
From JSON-LD on the HTML page, or null |
html_time_dates |
Every distinct datetime on a <time> element |
md_updated, md_published |
The Updated: / Published: lines of the markdown twin, or null |
http_last_modified |
The Last-Modified header as returned (GMT) |
http_last_modified_cst |
The same instant as ISO-8601 in Asia/Shanghai |
text_changed |
Observed changes: {after, by, source}. source is page-history-2026-11-12 or md-diff |
observed_captures |
Days this page was captured (v8 plus 2026-11-15 when an md twin exists) |
flags |
no_sitemap_lastmod, no_jsonld_date_modified, declared_dates_disagree, declared_date_before_observed_change, http_last_modified_after_declared |
captured |
2026-11-15 |
"Declared" dates are sitemap_lastmod, jsonld_date_modified and md_updated. Example rows (shortened):
{"id": "hitt-fr-001", "page": "/", "sitemap_lastmod": "2026-10-31", "jsonld_date_modified": "2026-10-31", "md_updated": "2026-10-31", "http_last_modified_cst": "2026-11-03T10:44:56+08:00", "text_changed": [{"after": "2026-11-02", "by": "2026-11-03", "source": "page-history-2026-11-12"}], "flags": ["declared_date_before_observed_change", "http_last_modified_after_declared"]}
{"id": "hitt-fr-003", "page": "/pricing/", "sitemap_lastmod": "2026-10-31", "jsonld_date_modified": "2026-10-31", "md_updated": "2026-10-31", "text_changed": [{"after": "2026-11-02", "by": "2026-11-03", "source": "page-history-2026-11-12"}], "flags": ["declared_date_before_observed_change", "http_last_modified_after_declared"]}
The task, and what leaks
Give a model the date fields (sitemap_lastmod, jsonld_date_modified, md_updated, http_last_modified_cst) and ask: did this page's text change after 2026-11-02? The gold answer is whether text_changed contains a change with after = 2026-11-02. Hide text_changed, flags and observed_captures. A retrieval variant hides the date fields too and asks the model to fetch the live page.
Validation and baselines (v10)
$ python3 validate_freshness.py data/freshness-2026-11-15.jsonl
40 pages; shape and flags: ok
flags: {'declared_date_before_observed_change': 3, 'http_last_modified_after_declared': 28, 'no_sitemap_lastmod': 12, 'no_jsonld_date_modified': 12}
change detection on 26 pages seen on both 2026-11-02 and 2026-11-03; 10 changed in that window
signal TP FP FN precision recall
sitemap lastmod >= 2026-11-02 7 0 3 1.00 0.70
JSON-LD dateModified >= 2026-11-02 7 0 3 1.00 0.70
md Updated >= 2026-11-02 7 0 3 1.00 0.70
HTTP Last-Modified after the 11-02 capture 10 16 0 0.38 1.00
changed pages every declared date misses: /, /pricing/, /guides/480p-or-720p/
$ python3 validate_freshness.py --live # same output, then:
live re-check:
40/40 pages unchanged since capture
The detector for the declared dates is "is the declared date on or after the earlier capture". That's the rule a crawler would use: anything dated 2026-11-02 or later could have changed after that morning's snapshot. HTTP Last-Modified is compared with the capture's clock time (09:00 CST on 2026-11-02), because a header is a timestamp, not a calendar day.
#!/usr/bin/env python3
"""Validate data/freshness-*.jsonl, score date signals as change detectors, optionally re-check live.
1. Shape: fields, unique ids, flags recomputed from the row's own fields.
2. Change detection: for pages captured both on 2026-11-02 and 2026-11-03 (the one window in
which text changed), would each date signal have told a crawler "this page changed after
the 2026-11-02 capture"? Precision and recall per signal.
3. --live: re-fetch the sitemaps, each HTML page and .md twin, and HEAD each page; report any
signal that differs from the file (a newer declared date means the file is out of date).
usage: validate_freshness.py [data/freshness-2026-11-15.jsonl] [--live]
"""
import json, sys, urllib.request
from freshness_lib import html_signals, md_signals, sitemap_lastmods, http_date_cst, flags
FIELDS = {"id", "page", "url", "md_url", "http_status", "sitemap_lastmod", "jsonld_date_modified",
"jsonld_date_published", "html_time_dates", "md_updated", "md_published", "http_last_modified",
"http_last_modified_cst", "text_changed", "observed_captures", "flags", "captured"}
WINDOW = ("2026-11-02", "2026-11-03") # captures at about 09:00 CST on both days
CAPTURE_TIME = "2026-11-02T09:00:00+08:00"
def get(url, method="GET"):
req = urllib.request.Request(url, method=method, headers={"User-Agent": "freshness-validator/1.0"})
for attempt in range(3):
try:
r = urllib.request.urlopen(req, timeout=60)
return r.status, r.headers, (r.read().decode("utf-8") if method == "GET" else "")
except Exception:
if attempt == 2: raise
def main():
args = [a for a in sys.argv[1:] if not a.startswith("--")]
path = args[0] if args else "data/freshness-2026-11-15.jsonl"
rows = [json.loads(l) for l in open(path, encoding="utf-8")]
errors = []
if len({r["id"] for r in rows}) != len(rows): errors.append("duplicate ids")
for r in rows:
if set(r) != FIELDS: errors.append(f"{r['id']}: fields {sorted(set(r) ^ FIELDS)}")
if flags(r) != r["flags"]: errors.append(f"{r['id']}: flags {r['flags']} != {flags(r)}")
print(f"{len(rows)} pages; shape and flags:", "ok" if not errors else f"{len(errors)} problem(s)")
for e in errors: print(" -", e)
count = {}
for r in rows:
for f in r["flags"]: count[f] = count.get(f, 0) + 1
print("flags:", count)
ev = [r for r in rows if set(WINDOW) <= set(r["observed_captures"])]
truth = {r["page"]: any(c["after"] == WINDOW[0] and c["by"] == WINDOW[1] for c in r["text_changed"]) for r in ev}
print(f"\nchange detection on {len(ev)} pages seen on both {WINDOW[0]} and {WINDOW[1]}; "
f"{sum(truth.values())} changed in that window")
signals = {
"sitemap lastmod >= 2026-11-02": lambda r: (r["sitemap_lastmod"] or "") >= WINDOW[0],
"JSON-LD dateModified >= 2026-11-02": lambda r: (r["jsonld_date_modified"] or "") >= WINDOW[0],
"md Updated >= 2026-11-02": lambda r: (r["md_updated"] or "") >= WINDOW[0],
"HTTP Last-Modified after the 11-02 capture": lambda r: (r["http_last_modified_cst"] or "") > CAPTURE_TIME,
}
print(f" {'signal':44s} {'TP':>3s} {'FP':>3s} {'FN':>3s} precision recall")
for name, pred in signals.items():
tp = sum(1 for r in ev if pred(r) and truth[r["page"]])
fp = sum(1 for r in ev if pred(r) and not truth[r["page"]])
fn = sum(1 for r in ev if not pred(r) and truth[r["page"]])
p = tp / (tp + fp) if tp + fp else 0; rc = tp / (tp + fn) if tp + fn else 0
print(f" {name:44s} {tp:3d} {fp:3d} {fn:3d} {p:9.2f} {rc:6.2f}")
missed = [r["page"] for r in ev if truth[r["page"]] and not signals["sitemap lastmod >= 2026-11-02"](r)]
print(" changed pages every declared date misses:", ", ".join(missed) or "none")
if "--live" in sys.argv:
print("\nlive re-check:")
origin = rows[0]["url"].split("/", 3)[:3]; origin = "/".join(origin)
lm = {}
for sm in ("sitemap-pages.xml", "sitemap-memes.xml"):
lm.update(sitemap_lastmods(get(f"{origin}/{sm}")[2]))
drift = 0
for r in rows:
now = {"sitemap_lastmod": lm.get(r["url"])}
st, _, html = get(r["url"]); now.update(html_signals(html)); now["http_status"] = st
if r["md_url"]: now.update(md_signals(get(r["md_url"])[2]))
_, h, _ = get(r["url"], "HEAD"); now["http_last_modified_cst"] = http_date_cst(h.get("Last-Modified"))[1]
diff = {k: (r[k], v) for k, v in now.items() if k in r and r[k] != v}
if diff:
drift += 1; print(f" {r['page']}: " + "; ".join(f"{k} {a} -> {b}" for k, (a, b) in diff.items()))
print(f" {len(rows) - drift}/{len(rows)} pages unchanged since capture")
return 1 if errors else 0
if __name__ == "__main__":
sys.exit(main())
The parser it shares with the build step:
"""Date signals a page publishes about itself (hittheroaddude.app, captured 2026-11-15).
Shared by the build step and validate_freshness.py. Standard library only.
"""
import re
from email.utils import parsedate_to_datetime
from datetime import timedelta, timezone
CST = timezone(timedelta(hours=8))
def html_signals(html):
"""dateModified / datePublished from JSON-LD, and every <time datetime> on the page."""
ld = dict()
for k, v in re.findall(r'"(dateModified|datePublished)"\s*:\s*"([^"]+)"', html):
ld.setdefault(k, set()).add(v[:10])
times = sorted({t[:10] for t in re.findall(r'<time[^>]*\bdatetime="([^"]+)"', html)})
one = lambda k: max(ld[k]) if k in ld else None
return {"jsonld_date_modified": one("dateModified"), "jsonld_date_published": one("datePublished"),
"html_time_dates": times}
def md_signals(md):
up = re.search(r"^Updated: (\d{4}-\d{2}-\d{2})", md, flags=re.M)
pub = re.search(r"^Published: (\d{4}-\d{2}-\d{2})", md, flags=re.M)
return {"md_updated": up.group(1) if up else None, "md_published": pub.group(1) if pub else None}
def sitemap_lastmods(xml):
out = {}
for block in re.findall(r"<url>(.*?)</url>", xml, flags=re.S):
loc = re.search(r"<loc>([^<]+)</loc>", block).group(1)
lm = re.search(r"<lastmod>([^<]+)</lastmod>", block)
out[loc] = lm.group(1)[:10] if lm else None
return out
def http_date_cst(value):
"""'Tue, 03 Nov 2026 02:44:56 GMT' -> ('2026-11-03', '2026-11-03T10:44:56+08:00')."""
if not value: return None, None
dt = parsedate_to_datetime(value).astimezone(CST)
return dt.date().isoformat(), dt.isoformat()
def declared(row):
"""Every date the page (or the sitemap) declares as its last modification."""
return {k: row[k] for k in ("sitemap_lastmod", "jsonld_date_modified", "md_updated") if row.get(k)}
def flags(row):
f = []
d = declared(row)
if not row.get("sitemap_lastmod"): f.append("no_sitemap_lastmod")
if not row.get("jsonld_date_modified"): f.append("no_jsonld_date_modified")
if len(set(d.values())) > 1: f.append("declared_dates_disagree")
latest = max(d.values()) if d else None
for ch in row.get("text_changed", []):
# the change happened after the previous capture; a declared date before that is stale
if latest is None or latest < ch["after"]:
f.append("declared_date_before_observed_change"); break
if row.get("http_last_modified_cst") and latest and row["http_last_modified_cst"][:10] > latest:
f.append("http_last_modified_after_declared")
return f
Using it
import json
rows = [json.loads(l) for l in open("data/freshness-2026-11-15.jsonl", encoding="utf-8")]
stale = [r["page"] for r in rows if "declared_date_before_observed_change" in r["flags"]]
print("pages whose declared dates predate an observed change:", stale)
Suggested uses: testing whether a freshness or recency ranker trusts lastmod / dateModified on a site where those fields can lag a price change; teaching an assistant to treat HTTP Last-Modified as a deploy time when every page shares one; and regression-testing a sitemap (if --live reports a new lastmod, the file is out of date).
Limits
- One site, and only one window in which text actually changed (the morning of 2026-11-03). Precision and recall are computed on that window, not over a year of edits.
- Captures are first-party and taken around 09:00 Asia/Shanghai. A change made and reverted between two captures is invisible.
html_time_datescan include dates that appear in prose or in a changelog, not only the page's own modified date. Don't treat the list as a single "updated on" value.- HTTP
Last-Modifiedwas read from one network on one day. A CDN in front of the site could serve a different value.
Licence
CC BY 4.0. Page text, URLs and dates belong to hittheroaddude.app, which is where they are published.
Earlier card (v9): internal link graph and navigation audit (Dataset Card v9, 2026-11-13)
What changed in v9 (2026-11-13): one new file and two scripts. data/link-graph-2026-11-13.jsonl has 2,190 links from 40 pages of hittheroaddude.app, each with the part of the page it sits in (header, nav, main or footer), its anchor text, where it points and the HTTP status of that target. validate_links.py checks the file shape, re-fetches the 40 pages to see whether any link changed, re-checks the targets, prints graph statistics and scores three link-prediction baselines. link_graph_lib.py is the parser it shares with the build step. Everything from v1 to v8 is unchanged and kept below.
The question behind it: earlier versions of this card looked at what the pages say. An assistant or crawler also has to find the page that says it. Which pages does a visitor reach from the home page by following links inside the article text, and which only through the header and footer? And how well does a link's anchor text predict where it goes?
The headline findings:
- Almost all links are template links. 1,645 of 2,190 (75%) are in the header, nav or footer. Only 545 (25%) sit in the
maincontent, and 496 of those point to another page on the site. The rest are 38 links to other sites and 11 e-mail links (mailto:or Cloudflare-obfuscated). - 8 of the 40 pages have no inbound link from article text:
/about/,/changelog/,/compare/,/dmca/,/explore/,/private-property-meme/,/state-property-meme/and/this-is-private-property/. They are reachable (every page is within 2 clicks of the home page when you count header and footer links), but following only in-content links, none of the eight can be reached from/at all. - 1,631 internal links are written without a trailing slash (for example
/pricing). Of the 46 distinct slash-less hrefs, 44 answer with a 301 to the slash form and 2 (/memesand/memes/hit-the-road-dude) answer 200 directly. It works, but it spends a redirect on most clicks and means two URL forms circulate for some pages. Every internal link target returns 200 once normalised. - Anchor text is a strong predictor. Predicting a link's target from its anchor text alone with a plain token-overlap rule is right 75.8% of the time over 48 candidates, against 2.0% for random and 14.3% for "always the home page".
Current facts as checked on 2026-11-13 (09:02 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits), with packs for signed-in accounts at $27.99/30, $71.99/100 and $129.99/200, one-time, no renewal (pricing). Prices are unchanged since 2026-11-03.
What this is not: no images, videos, faces, voices, generated outputs or user data. Link metadata only, from the site's own public HTML. One capture, taken by the builder of the site on 2026-11-13. It is not a crawl of the web, and it does not claim anything about how any search engine or assistant treats these links.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v9)
data/link-graph-2026-11-13.jsonl, one link per row:
| Field | Meaning |
|---|---|
id |
hitt-lk-0001 … hitt-lk-2190 |
src |
Page the link is on, as a canonical path (/guides/driver-photo/) |
region |
Innermost of main, footer, header, nav around the <a>. nav here means a navigation block that is not inside the header |
anchor |
Visible link text, whitespace collapsed (falls back to aria-label) |
href |
The href as written in the HTML |
dst |
Normalised target: internal paths end in /, query and fragment removed. External links are scheme://host/path |
dst_kind |
internal (2,141), external (38), other (11: mailto: and Cloudflare-obfuscated e-mail links) |
in_content |
true when region is main (545 rows) |
dst_status |
HTTP status of an internal target on 2026-11-13 (always 200); null for external and other |
dst_redirect |
Redirect target of the normalised dst, if any (always null here, because dst is already the slash form) |
captured |
2026-11-13 |
Same-page jumps (#faq) and self-links are dropped, and a link to /#how-it-works counts as a link to /. Example rows:
{"id": "hitt-lk-0002", "src": "/about/", "region": "header", "anchor": "Memes", "href": "/memes", "dst": "/memes/", "dst_kind": "internal", "in_content": false, "dst_status": 200, "dst_redirect": null, "captured": "2026-11-13"}
{"id": "hitt-lk-0016", "src": "/about/", "region": "main", "anchor": "Creator guides", "href": "/guides", "dst": "/guides/", "dst_kind": "internal", "in_content": true, "dst_status": 200, "dst_redirect": null, "captured": "2026-11-13"}
The tasks, and what leaks
- Link prediction. Given
srcandanchor(and optionally the list of candidate targets), predictdstfor the 496 in-content internal rows.dst,dst_statusandhrefgive the answer away; hide them. - Reachability. Which pages can be reached from
/using only in-content links? The answer (all but 8 of 40, which take up to 3 clicks, and 8 not at all) is computed from the file. - Template-link filtering. Separate editorial links from template links using
regionalone, then ask whether an anchor-only classifier can do it without the region.
Validation and baselines (v9)
$ python3 validate_links.py
shape OK: 2190 rows
edges 2190 | internal 2141 | in-content (main) 545 | pages 40
by region: {'header': 547, 'main': 545, 'nav': 118, 'footer': 980}
pages with no in-content inbound link (8): /about/, /changelog/, /compare/, /dmca/, /explore/, /private-property-meme/, /state-property-meme/, /this-is-private-property/
depth from / via all links: max 2, unreached 0
depth from / via in-content links only: max 3, unreached 8 (/about/, /changelog/, /compare/, /dmca/, /explore/, /private-property-meme/, /state-property-meme/, /this-is-private-property/)
internal links written without a trailing slash: 1631 (e.g. /about, /acceptable-use, /account, /billing, /blog); ...
link prediction on 496 in-content internal edges (predict dst from anchor text), 48 candidate targets:
random target accuracy 0.020
always / accuracy 0.143
anchor/slug token overlap accuracy 0.758
live links vs file: 0 new, 0 gone across 40 pages
internal targets not returning 200 now: none
status of the slash-less hrefs as written (distinct hrefs by status): {301: 44, 200: 2}
How to read the baselines:
- "Always the home page" is the most-linked target in content (71 links), and still only 14.3%. The links are spread across 48 targets.
- Token overlap compares the words in the anchor ("Creator guides", "Help center", "Contact support") with the words in each candidate's path. It works because the site's anchors are plain descriptions. It fails when the anchor is a verb phrase ("Open the studio", "Read acceptable use") or a sentence fragment. Those are the interesting rows for a better model.
- A model that also sees the target page's title or summary, which this file doesn't include, should do much better. Fetching titles is an obvious extension.
#!/usr/bin/env python3
"""Validate data/link-graph-2026-11-13.jsonl, optionally re-fetch the live pages, and score link baselines.
usage: python3 validate_links.py [--offline]
default re-fetch every source page and compare its links with the file (needs network, ~40 requests),
then re-check the status of every internal target
--offline only check the file's shape and recompute the graph statistics and baselines
Standard library only. Needs link_graph_lib.py next to it.
"""
import argparse, collections, json, os, random, re, sys, urllib.request
from concurrent.futures import ThreadPoolExecutor
from link_graph_lib import extract_edges, probe, ORIGIN
HERE = os.path.dirname(os.path.abspath(__file__))
PATH = os.path.join(HERE, "data", "link-graph-2026-11-13.jsonl")
FIELDS = {"id", "src", "region", "anchor", "href", "dst", "dst_kind", "in_content", "dst_status", "dst_redirect", "captured"}
def load():
rows = [json.loads(l) for l in open(PATH, encoding="utf-8")]
ids = set()
for r in rows:
assert set(r) == FIELDS, (r["id"], set(r) ^ FIELDS)
assert r["id"] not in ids; ids.add(r["id"])
assert r["region"] in ("header", "nav", "main", "footer", "other")
assert r["dst_kind"] in ("internal", "external", "asset", "other")
assert r["in_content"] == (r["region"] == "main")
assert (r["dst_status"] is not None) == (r["dst_kind"] == "internal")
if r["dst_kind"] == "internal": assert r["dst"].startswith("/") and r["dst"].endswith("/") or "." in r["dst"]
return rows
def graph_stats(rows):
internal = [r for r in rows if r["dst_kind"] == "internal"]
pages = sorted({r["src"] for r in rows})
inb_all = collections.Counter(r["dst"] for r in internal)
inb_content = collections.Counter(r["dst"] for r in internal if r["in_content"])
print(f"edges {len(rows)} | internal {len(internal)} | in-content (main) {sum(r['in_content'] for r in rows)} | pages {len(pages)}")
print("by region:", dict(collections.Counter(r["region"] for r in rows)))
no_content_in = [p for p in pages if inb_content[p] == 0]
print(f"pages with no in-content inbound link ({len(no_content_in)}):", ", ".join(no_content_in))
# click depth from "/" using every link, and using in-content links only
for label, edges in (("all links", internal), ("in-content links only", [r for r in internal if r["in_content"]])):
adj = collections.defaultdict(set)
for r in edges: adj[r["src"]].add(r["dst"])
depth, q = {"/": 0}, ["/"]
for u in q:
for v in adj[u]:
if v not in depth: depth[v] = depth[u] + 1; q.append(v)
unreached = [p for p in pages if p not in depth]
print(f"depth from / via {label}: max {max(depth.values())}, unreached {len(unreached)}" + (f" ({', '.join(unreached[:8])})" if unreached else ""))
noslash = [r for r in internal if r["href"].split("#")[0].split("?")[0] not in ("", "/") and not r["href"].split("#")[0].endswith("/")]
print(f"internal links written without a trailing slash: {len(noslash)} (e.g. {', '.join(sorted({r['href'] for r in noslash})[:5])}); "
"whether such a URL answers 200 or redirects to the slash form is checked live below")
return internal
def slug_tokens(s):
return set(t for t in re.split(r"[^a-z0-9]+", s.lower()) if len(t) > 2)
def baselines(rows):
ex = [r for r in rows if r["in_content"] and r["dst_kind"] == "internal"]
targets = sorted({r["dst"] for r in rows if r["dst_kind"] == "internal"})
top = collections.Counter(r["dst"] for r in ex).most_common(1)[0][0]
rng = random.Random(0)
def overlap(r):
a = slug_tokens(r["anchor"])
best = max(targets, key=lambda t: (len(a & slug_tokens(t)), t == top))
return best
res = {"random target": sum(rng.choice(targets) == r["dst"] for r in ex) / len(ex),
f"always {top}": sum(top == r["dst"] for r in ex) / len(ex),
"anchor/slug token overlap": sum(overlap(r) == r["dst"] for r in ex) / len(ex)}
print(f"link prediction on {len(ex)} in-content internal edges (predict dst from anchor text), {len(targets)} candidate targets:")
for k, v in res.items(): print(f" {k:32} accuracy {v:.3f}")
def get(url, tries=5):
for i in range(tries):
try:
return urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": "link-graph/1.0"}), timeout=20).read().decode("utf-8", "replace")
except OSError:
if i == tries - 1: raise
def live_compare(rows):
by_src = collections.defaultdict(list)
for r in rows: by_src[r["src"]].append(r)
key = lambda e: (e["region"], e["href"], e["anchor"])
srcs = sorted(by_src)
with ThreadPoolExecutor(8) as ex: # new connections can be slow; fetch in parallel
pages = dict(zip(srcs, ex.map(lambda s: get(ORIGIN + s), srcs)))
added = removed = 0
for src in srcs:
# 'other' = mailto / obfuscated e-mail links, whose href changes per request
new = collections.Counter(key(e) for e in extract_edges(src, pages[src]) if e["dst_kind"] != "other")
was = collections.Counter(key(e) for e in by_src[src] if e["dst_kind"] != "other")
a, d = sum((new - was).values()), sum((was - new).values())
added += a; removed += d
if a or d: print(f" {src}: +{a} -{d}")
print(f"live links vs file: {added} new, {removed} gone across {len(by_src)} pages")
targets = sorted({r["dst"] for r in rows if r["dst_kind"] == "internal"})
bad = [(t, st) for t, (st, _) in zip(targets, ex.map(probe, targets)) if st != 200]
print("internal targets not returning 200 now:", bad or "none")
hrefs = sorted({r["href"].split("#")[0] for r in rows if r["dst_kind"] == "internal" and r["href"].startswith("/")
and not r["href"].split("#")[0].endswith("/")})
codes = collections.Counter(st for st, _ in ex.map(probe, hrefs))
print("status of the slash-less hrefs as written (distinct hrefs by status):", dict(codes))
if __name__ == "__main__":
ap = argparse.ArgumentParser(); ap.add_argument("--offline", action="store_true"); a = ap.parse_args()
rows = load(); print("shape OK:", len(rows), "rows")
graph_stats(rows); baselines(rows)
if not a.offline: live_compare(rows)
Using it
import json, collections
rows = [json.loads(l) for l in open("data/link-graph-2026-11-13.jsonl", encoding="utf-8")]
content_in = collections.Counter(r["dst"] for r in rows if r["in_content"] and r["dst_kind"] == "internal")
pages = {r["src"] for r in rows}
print("pages with no in-content inbound link:", sorted(p for p in pages if content_in[p] == 0))
Suggested uses: testing whether a retrieval pipeline that follows only in-content links can reach an answer page, auditing template-heavy small sites for orphaned pages, and training or evaluating anchor-text-to-URL models on a graph where every target is known to be live.
Limits
- One capture, one site, one day. A link graph from a different day, or a bigger site, may look different.
mainis the HTML element. It includes lists of cards and calls to action as well as prose, so "in-content" is not the same as "editorial".- The 38 external links go to 9 hosts: knowyourmeme.com (8), the four similarly named Hit the Road Dude sites the compare and journal pages discuss (5 each) and four other sites run by the builder (10 in total). They are in the file because the pages contain them; they are not an endorsement or a claim about those sites.
navrows, 118, are navigation blocks outside the header, such as footer-adjacent menus. If you want only top navigation, useheader.- Link status is a plain GET without following redirects, from one network at one time.
Licence
CC BY 4.0. Page text and URLs belong to hittheroaddude.app, which is where they are published.
Earlier card (v8): page change history and stale-answer detection (Dataset Card v8, 2026-11-12)
What changed in v8 (2026-11-12): one new file and one script. data/page-history-2026-11-12.jsonl has 378 lines of text from 28 pages of hittheroaddude.app, each with the dates it was seen across 8 daily captures between 2026-11-02 and 2026-11-12, and a status: stable, added or removed. validate_history.py checks the file shape, re-fetches the pages' .md twins to confirm today's statuses still hold, and scores three simple baselines. Everything from v1 to v7 is unchanged and kept below. This upload also restores the v5 files (data/mentions-2026-11-09.jsonl, data/entities-2026-11-09.jsonl, link_baseline.py, validate_mentions.py) that the card has listed since 2026-11-09 but that were missing from the repo.
The question behind it: an assistant that read the site once and answers from memory will be confidently out of date when the site changes. Which lines of a small product site actually changed in ten days, and could you have predicted which ones would? v6 extracted prices from today's pages, and v7 checked third-party claims against them. v8 adds the time axis.
The headline finding: almost nothing changed, and what did change is exactly what an answer is most likely to quote. All 35 removed lines were last seen on 2026-11-02 and all 73 added lines were first seen on 2026-11-03. On 2026-11-02 the site disagreed with itself: the summary lines and the pricing page said 4.99 USD (480p, 1 credit) and 6.99 USD (720p, 2 credits), while the price table in the free-generator article and the body of the 480p-or-720p guide already said $9.99 and $12.99 (6 and 14 credits). From 2026-11-03 every page says $9.99 and $12.99. Pack prices ($27.99 for 30 credits, $71.99 for 100, $129.99 for 200) never changed. Several pages (about, blog index, guides index, compare) were rewritten the same day. Nothing in the 8 captures changed after 2026-11-03.
Current facts as checked on 2026-11-12 (08:57 CST): one clip is 15 seconds, vertical 9:16, $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits), with packs for signed-in accounts at $27.99/30, $71.99/100 and $129.99/200, one-time, no renewal (pricing). An answer that still says $4.99 is quoting the 2026-11-02 page.
What this is not: no images, videos, faces, voices, generated outputs or user data. Text only, from the site's own public .md pages. The captures are mine, taken once a day by the builder of the site. They are not a crawl of the web, and they are not a log of what any assistant said.
Who wrote it: the builder of hittheroaddude.app. Treat it as first-party.
Files (v8)
data/page-history-2026-11-12.jsonl, one line of page text per row:
| Field | Meaning |
|---|---|
id |
hitt-ph-001 … hitt-ph-378 |
page |
Canonical path, e.g. /pricing/ |
md_url |
The page's plain-text twin, used by the validator |
text |
One paragraph, heading, list item or table row, markdown markers stripped, 20+ characters. Canonical page:, Updated: and Published: lines are left out |
status |
stable (270): on every capture of that page. added (73): absent from the first capture, present on the latest. removed (35): absent from the latest capture |
first_seen, last_seen |
First and last capture dates containing the line |
seen_on |
Every capture date containing the line |
page_captures |
Every date that page was captured (5 to 8. Not every page was saved every day, and two pages were first captured on 2026-11-03) |
has_price |
The line contains a USD amount or a credit count |
replaced_by |
For 12 removed lines, the most similar added line on the same page (difflib ratio at least 0.6), else null |
Example lines:
{"id": "hitt-ph-341", "page": "/pricing/", "md_url": "https://hittheroaddude.app/pricing.md", "text": "One clip is 4.99 USD at 480p or 6.99 USD at 720p. Credit packs require an account and start at 27.99 USD. There is no subscription.", "status": "removed", "first_seen": "2026-11-02", "last_seen": "2026-11-02", "seen_on": ["2026-11-02"], "page_captures": ["2026-11-02", "2026-11-03", "2026-11-04", "2026-11-05", "2026-11-09", "2026-11-10", "2026-11-11", "2026-11-12"], "has_price": true, "replaced_by": "One clip is 9.99 USD at 480p or 12.99 USD at 720p. Credit packs require an account and start at 27.99 USD. There is no subscription."}
{"id": "hitt-ph-343", "page": "/pricing/", "text": "Signed-in accounts can buy 27.99 USD for 30 credits, 71.99 USD for 100 credits, or 129.99 USD for 200 credits. Packs do not renew.", "status": "stable", "has_price": true, "...": "..."}
(The second line is shortened here; every row in the file has all 11 fields.)
The task, and what leaks
Task: given page, text and first_seen (the day an answer quoted the line), predict whether the line is still current on the latest capture (status != "removed").
seen_on, last_seen, status and replaced_by give the answer away. Hide them from a model under test. page_captures is safe.
Validation and baselines (v8)
$ python3 validate_history.py
378 rows, 28 pages, {'stable': 270, 'removed': 35, 'added': 73}
live check: 378/378 rows match the site today
baseline A: everything is still current accuracy 343/378 = 90.7% stale found 0/35, false alarms 0
baseline B: priced line first seen earliest accuracy 345/378 = 91.3% stale found 11/35, false alarms 9
baseline C: any line first seen earliest accuracy 164/378 = 43.4% stale found 35/35, false alarms 214
Read these carefully:
- A is the "trust your memory" assistant. 90.7% accurate, and it gets every price wrong. Accuracy is the wrong metric here. Count stale lines found.
- B ("prices from the first day are stale") catches all 11 removed price lines, but also flags 9 lines that were right all along: pack prices, and the lines that already showed $9.99/$12.99 on 2026-11-02. Prices are volatile, but not all of them moved. When a page contradicts itself, a model has to pick the right half.
- C ("anything old is stale") catches everything by flagging 57% of the site.
- The 24 removed lines without a price are wording rewrites (the about page, the blog and guides indexes, the compare table). Their meaning is mostly unchanged, so missing them costs little. This set doesn't label meaning-level change. That's a good extension.
#!/usr/bin/env python3
"""Check data/page-history-2026-11-12.jsonl against the live site, then score two baselines.
python3 validate_history.py # fetches the .md twins (about 25 requests)
python3 validate_history.py --offline # schema and baselines only
Standard library only.
"""
import collections, json, re, sys, urllib.request
FILE = "data/page-history-2026-11-12.jsonl"
STATUSES = {"stable", "added", "removed"}
KEYS = {"id", "page", "md_url", "text", "status", "first_seen", "last_seen", "seen_on",
"page_captures", "has_price", "replaced_by"}
norm = lambda s: re.sub(r"\s+", " ", s).strip()
rows = [json.loads(l) for l in open(FILE, encoding="utf-8")]
for r in rows:
assert set(r) == KEYS, (r["id"], set(r) ^ KEYS)
assert r["status"] in STATUSES, r["id"]
assert r["seen_on"] == sorted(r["seen_on"]) and r["first_seen"] == r["seen_on"][0] and r["last_seen"] == r["seen_on"][-1], r["id"]
assert set(r["seen_on"]) <= set(r["page_captures"]), r["id"]
current = r["page_captures"][-1] in r["seen_on"]
assert current == (r["status"] != "removed"), r["id"]
assert r["replaced_by"] is None or r["status"] == "removed", r["id"]
print(f"{len(rows)} rows, {len({r['page'] for r in rows})} pages,", dict(collections.Counter(r["status"] for r in rows)))
if "--offline" not in sys.argv:
live, bad = {}, []
for url in sorted({r["md_url"] for r in rows}):
with urllib.request.urlopen(urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}), timeout=30) as resp:
live[url] = norm(resp.read().decode("utf-8"))
for r in rows:
on_page = norm(r["text"]) in live[r["md_url"]]
if on_page != (r["status"] != "removed"):
bad.append((r["id"], r["status"], "now on page" if on_page else "gone from page", r["text"][:70]))
for b in bad:
print("DRIFT", *b)
print(f"live check: {len(rows) - len(bad)}/{len(rows)} rows match the site today")
# Task: given page, text and first_seen (the day an answer quoted it), is the line still current?
gold = [r["status"] != "removed" for r in rows]
def score(name, pred):
ok = sum(p == g for p, g in zip(pred, gold))
tp = sum((not p) and (not g) for p, g in zip(pred, gold)); fn = sum(p and (not g) for p, g in zip(pred, gold))
fp = sum((not p) and g for p, g in zip(pred, gold))
print(f"{name:44} accuracy {ok}/{len(rows)} = {ok / len(rows):.1%} stale found {tp}/{tp + fn}, false alarms {fp}")
score("baseline A: everything is still current", [True] * len(rows))
earliest = min(r["first_seen"] for r in rows)
score("baseline B: priced line first seen earliest", [not (r["has_price"] and r["first_seen"] == earliest) for r in rows])
score("baseline C: any line first seen earliest", [r["first_seen"] != earliest for r in rows])
# seen_on, last_seen, status and replaced_by give the answer away: hide them from a model under test.
Using it
import json
rows = [json.loads(l) for l in open("data/page-history-2026-11-12.jsonl", encoding="utf-8")]
stale_prices = [r for r in rows if r["status"] == "removed" and r["has_price"]]
for r in stale_prices:
print(r["page"], "|", r["text"][:60], "->", (r["replaced_by"] or "(rewritten)")[:60])
Suggested uses: testing whether a retrieval-augmented assistant prefers the current line over a cached one, building "this may be out of date" warnings for price answers, and checking diff-and-recrawl heuristics on a small site where every change is known.
Limits
- 8 captures and one real change event. It's a probe, not a benchmark. Splits are not provided.
- Line-level matching is exact after whitespace collapse. A one-word edit makes one
removedand oneaddedrow.replaced_bylinks 12 of those pairs. - Captures are daily at most and have gaps (no captures on 2026-11-06 to 11-08, and some pages missing on 2026-11-10). A change made and reverted between captures is invisible.
- The pages quote other sites' prices as checked on 2026-11-02. Those rows are this site's text, not verified prices of those sites.
Licence
CC BY 4.0. Page text belongs to hittheroaddude.app, which is where it is published.
Earlier card (v7): assistant-claim verification (Dataset Card v7, 2026-11-11)
What changed in v7 (2026-11-11): one new file and one script. data/claims-2026-11-11.jsonl has 40 short claims of the kind an AI assistant might make when asked about the Hit the Road Dude meme or hittheroaddude.app, each labelled SUPPORTED, REFUTED or NOT_ON_SITE against one evidence sentence quoted from the site. validate_claims.py checks the schema, re-fetches the pages, confirms every evidence quote is still live, and scores a three-rule baseline. Everything from v1 to v6 is unchanged and kept below.
The question behind it: when an assistant answers "Is the Hit the Road Dude AI generator free?" or "Does it use the original audio?", is what it says true according to the site it's describing? v4 asked whether the site's own pages agree with each other. v7 asks whether a third party's statement about the site holds up, FEVER-style: claim, evidence, verdict.
What makes it hard despite being small:
- Numbers that are close. "One 720p clip costs $14.99" and "One 480p clip costs $9.99" share the same evidence sentence and get opposite labels.
- Negation on both sides. "The finished file has a watermark unless you pay extra" is refuted by "the studio does not add a watermark to the finished file"; the Japanese claim 「完成した動画には透かしが入らない。」 (no watermark) is supported by the same sentence.
- Refutation by a broader rule. "You can choose a 30-second version" is refuted by "You do not pick a length, framing, or voice", which contains no number.
- Unknown is not false. "The pond in the original video is in Texas" gets
NOT_ON_SITE, because the evidence says the location "is not established here". "Uploaded photos are deleted after 24 hours" isNOT_ON_SITEbecause the privacy page publishes no retention period. - Support without the keyword. "A dog or a cat can be the driver" is supported by "There is no separate pet mode. The same preset takes a person or a pet; the photo decides who drives."
Facts as checked on 2026-11-11 (09:00 CST): one clip is 15 seconds, vertical 9:16, at $9.99 for 480p (6 credits) or $12.99 for 720p (14 credits). Credit packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200, one-time, no renewal. No free clip, no prompt, no model choice, a newly generated voice rather than the original recording, no watermark added. These are what the labels rest on; the validator tells you if a page changes.
What this is not: no images, videos, faces, voices, generated outputs or user data. The claims were written by me to resemble assistant answers. They are not logged outputs of any particular assistant.
Who wrote it: the builder of hittheroaddude.app. The labels are my reading of my own pages. Treat it as first-party.
Files (v7)
data/claims-2026-11-11.jsonl, one claim per line:
| Field | Meaning |
|---|---|
id |
hitt-cl-001 … hitt-cl-040 |
lang |
Language of the claim: 36 en, one each zh, es, de, ja. Evidence is always English |
claim |
A short statement about the meme or the studio |
label |
SUPPORTED (12), REFUTED (24) or NOT_ON_SITE (4) |
evidence_page |
The page the evidence is quoted from: an .md twin, or the HTML FAQ for one row |
evidence_quote |
Exact text on that page after whitespace is collapsed |
note |
Topic, plus what makes the row easy or hard |
checked |
2026-11-11 |
Evidence comes from 16 pages; the most used are the FAQ, the 480p-or-720p guide, the free-generator article and the about page (four rows each).
Example lines:
{"id": "hitt-cl-007", "lang": "en", "claim": "One 720p clip costs $14.99.", "label": "REFUTED", "evidence_page": "https://hittheroaddude.app/pricing.md", "evidence_quote": "480p is 9.99 USD (6 credits). 720p is 12.99 USD (14 credits).", "note": "price; same evidence as the supported row, wrong number", "checked": "2026-11-11"}
{"id": "hitt-cl-030", "lang": "en", "claim": "Uploaded photos are deleted after 24 hours.", "label": "NOT_ON_SITE", "evidence_page": "https://hittheroaddude.app/privacy.md", "evidence_quote": "The studio stores your account email, a password hash, your uploaded photo for the clip you ordered, and order records.", "note": "retention; no period is published", "checked": "2026-11-11"}
{"id": "hitt-cl-040", "lang": "ja", "claim": "完成した動画には透かしが入らない。", "label": "SUPPORTED", "evidence_page": "https://hittheroaddude.app/blog/is-hit-the-road-dude-ai-free.md", "evidence_quote": "the studio does not add a watermark to the finished file", "note": "watermark; Japanese claim, negated claim supported by negated evidence", "checked": "2026-11-11"}
Two judgement calls worth flagging:
hitt-cl-019, HEIC uploads, isNOT_ON_SITE. The photo guide lists JPEG, PNG or WebP and doesn't mention HEIC. A closed-world reader would call the claim refuted. I didn't, because no page says HEIC is rejected, and some phone browsers convert HEIC on upload.hitt-cl-016, the parrot, isREFUTED. The evidence is hedged ("may look less like your pet"), but it contradicts "exactly".
Validation and baseline (v7)
$ python3 validate_claims.py
40 rows, 16 pages, evidence all live; {'SUPPORTED': 12, 'REFUTED': 24, 'NOT_ON_SITE': 4}
baseline miss hitt-cl-015 [en] gold SUPPORTED pred REFUTED A dog or a cat can be the driver.
baseline miss hitt-cl-016 [en] gold REFUTED pred SUPPORTED A parrot photo will look exactly like your parrot in the cli
baseline miss hitt-cl-017 [en] gold REFUTED pred SUPPORTED A group photo with several friends gives the best result.
baseline miss hitt-cl-019 [en] gold NOT_ON_SITE pred SUPPORTED HEIC photos straight from an iPhone are accepted.
baseline miss hitt-cl-030 [en] gold NOT_ON_SITE pred REFUTED Uploaded photos are deleted after 24 hours.
baseline miss hitt-cl-034 [en] gold NOT_ON_SITE pred SUPPORTED A clip takes about two minutes to generate.
baseline miss hitt-cl-035 [en] gold REFUTED pred SUPPORTED hittheroaddude.app is the same site as hittheroaddude.org.
baseline miss hitt-cl-040 [ja] gold SUPPORTED pred REFUTED 完成した動画には透かしが入らない。
rule baseline: 32/40 correct (English 29/36, other languages 3/4)
gold NOT_ON_SITE -> NOT_ON_SITE 1, REFUTED 1, SUPPORTED 2
gold REFUTED -> NOT_ON_SITE 0, REFUTED 21, SUPPORTED 3
gold SUPPORTED -> NOT_ON_SITE 0, REFUTED 2, SUPPORTED 10
The baseline has three rules and no model: "not established / not published / does not say" in the evidence means NOT_ON_SITE; a negation present on one side but not the other, or a number in the claim that the evidence lacks, means REFUTED; anything else is SUPPORTED. With 24 of 40 rows refuted, that is roughly what a negation detector gets for free.
Read the 32/40 with care. The three non-English hits are mostly luck: the negation rule only sees English words, so the Chinese "free" claim is called REFUTED because the evidence has "no" in it, which happens to be right. The misses are the interesting rows: support that arrives through a negation (015), contradiction without a negation (016, 017, 035) and every NOT_ON_SITE row but one, since "not published" is rarely written down. It had no tuning on the data.
#!/usr/bin/env python3
"""Check the claim-verification set: schema, every evidence quote still live, then score a rule baseline.
usage: python3 validate_claims.py (standard library only; network needed)
Evidence pages are the .md twins (https://hittheroaddude.app/<page>.md) or the visible text of an HTML page.
"""
import collections, html, json, re, sys, urllib.request
LABELS = {"SUPPORTED", "REFUTED", "NOT_ON_SITE"}
FIELDS = {"id", "lang", "claim", "label", "evidence_page", "evidence_quote", "note", "checked"}
def fetch(url):
req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
with urllib.request.urlopen(req, timeout=30) as r:
t = r.read().decode("utf-8", "replace")
if url.endswith("/"): # HTML page -> visible text
t = re.sub(r"<(script|style|svg)[^>]*>.*?</\1>", " ", t, flags=re.S)
t = html.unescape(re.sub(r"<[^>]+>", " ", t))
return re.sub(r"\s+", " ", t)
NEG = re.compile(r"\b(no|not|never|nothing|none|cannot)\b|n't\b|\bdo not\b", re.I)
UNKNOWN = re.compile(r"not established|not published|does not say", re.I)
NUM = re.compile(r"\d+(?:\.\d+)?")
def baseline(claim, quote):
"""Three rules, no model: 'unknown' wording -> NOT_ON_SITE; negation mismatch or a number
in the claim that the quote lacks -> REFUTED; otherwise SUPPORTED."""
if UNKNOWN.search(quote):
return "NOT_ON_SITE"
if bool(NEG.search(claim)) != bool(NEG.search(quote)):
return "REFUTED"
if any(n not in quote for n in NUM.findall(claim)):
return "REFUTED"
return "SUPPORTED"
def main():
rows = [json.loads(l) for l in open("data/claims-2026-11-11.jsonl", encoding="utf-8")]
ids = [r["id"] for r in rows]; assert len(ids) == len(set(ids)), "duplicate ids"
for r in rows:
assert set(r) == FIELDS, (r["id"], set(r) ^ FIELDS)
assert r["label"] in LABELS, r["id"]
pages, bad = {}, 0
for r in rows:
pages.setdefault(r["evidence_page"], fetch(r["evidence_page"]))
if r["evidence_quote"] not in pages[r["evidence_page"]]:
print("MISSING QUOTE", r["id"], r["evidence_quote"][:70]); bad += 1
labels = collections.Counter(r["label"] for r in rows)
print(f"{len(rows)} rows, {len(pages)} pages, evidence {'all live' if not bad else str(bad) + ' missing'}; {dict(labels)}")
conf = collections.Counter(); hits = collections.Counter()
for r in rows:
p = baseline(r["claim"], r["evidence_quote"]); conf[(r["label"], p)] += 1
hits[r["lang"] == "en", p == r["label"]] += 1
if p != r["label"]:
print(f"baseline miss {r['id']} [{r['lang']}] gold {r['label']:11s} pred {p:11s} {r['claim'][:60]}")
ok = sum(v for (g, p), v in conf.items() if g == p)
print(f"rule baseline: {ok}/{len(rows)} correct "
f"(English {hits[True, True]}/{hits[True, True] + hits[True, False]}, "
f"other languages {hits[False, True]}/{hits[False, True] + hits[False, False]})")
for g in sorted(LABELS):
print(f" gold {g:11s} -> " + ", ".join(f"{p} {conf[g, p]}" for p in sorted(LABELS)))
sys.exit(1 if bad else 0)
if __name__ == "__main__":
main()
Using it
import json
rows = [json.loads(l) for l in open("data/claims-2026-11-11.jsonl", encoding="utf-8")]
unknown = [r for r in rows if r["label"] == "NOT_ON_SITE"]
print(len(rows), len(unknown))
Suggested uses: checking that an assistant grounded on these pages refuses to invent a retention period or a generation time; testing NLI models on negated support; a tiny multilingual sanity check with English evidence.
Limits
- 40 rows from one site is a probe, not a benchmark. Splits are not provided.
- Labels depend on the pages as they were on 2026-11-11;
validate_claims.pyshows when evidence has moved or changed. - One evidence sentence per claim. Some claims could be settled by several pages; I picked the clearest.
- The claims are written to look like assistant output, not collected from real assistants.
Licence
CC BY 4.0. Evidence text belongs to hittheroaddude.app, which is where it is published.
Earlier card (v6): price-quote extraction (Dataset Card v6, 2026-11-10)
What changed in v6 (2026-11-10): one new file and one script. data/price-quotes-2026-11-10.jsonl has 28 quote snippets copied from five pages of hittheroaddude.app. Each carries the dollar amounts and credit counts a careful reader would extract. validate_price_quotes.py re-fetches the pages, confirms every quote is still on the live page, and scores a two-regex baseline. Everything from v1 to v5 is unchanged and kept below.
The question behind it: can an assistant read a price out of a page without mixing up numbers that look similar? The pricing page of this studio is a good small test, because one sentence can hold a price, a credit count, a run count and a competitor's price:
- "$5.60 per run" is a derived price per run, not a pack price.
- "about 5 Hit the Road Dude runs (5–30 across 7 memes)" contains numbers that are run counts, not credits.
- "Packs hold 30, 100 or 200 credits" shares one unit word across three numbers.
- "a 480p clip spends 6 credits and a 720p clip 14" has a credit count with no unit word.
- "hittheroaddude.org (11-second clips, adult-portrait packs from USD 6.99)" is another site's price, listed on this site's FAQ.
- "JPEG, PNG or WebP up to 10 MB" is a number with a unit that is not money.
Facts as checked on 2026-11-10 (09:00 CST): one clip is $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits). Credit packs for signed-in accounts are $27.99 for 30 credits, $71.99 for 100 and $129.99 for 200. The pricing page also lists a derived price per run ($5.60, $4.50 and $3.94) and what each of the seven memes on the site costs. These are the values the gold labels use. They can change; the validator tells you.
What this is not: no images, videos, faces, voices, generated outputs or user data. It is not a record of what customers paid, only of what the pages publish.
Who wrote it: the builder of hittheroaddude.app. The labels are my judgement about which numbers are prices and credit counts. Treat it as first-party.
Files (v6)
data/price-quotes-2026-11-10.jsonl, one quote per line:
| Field | Meaning |
|---|---|
id |
hitt-pq-001 … hitt-pq-028 |
page |
Page the quote comes from: the .md twin where one exists, otherwise the HTML page's visible text |
quote |
Exact text as it appears on that page after whitespace is collapsed |
prices_usd |
Dollar amounts in the quote that are prices of something (empty if none) |
credits |
Credit amounts in the quote (empty if none) |
fact_type |
Single price, credit packs, per-run derived, other meme row, other site price, not a price, and so on (15 types) |
note |
Why the row is easy or hard |
checked |
2026-11-10 |
Counts: 11 rows from /pricing/, 9 from /faq/, 5 from pricing.md, 2 from guides.md, 1 from the home page. Four are other memes on the same price table, three are other sites' prices, and three are per-run derived prices.
Example lines:
{"id": "hitt-pq-003", "page": "https://hittheroaddude.app/pricing.md", "quote": "Signed-in accounts can buy 27.99 USD for 30 credits, 71.99 USD for 100 credits, or 129.99 USD for 200 credits.", "prices_usd": [27.99, 71.99, 129.99], "credits": [30, 100, 200], "fact_type": "credit_packs", "note": "three packs, USD after the number", "checked": "2026-11-10"}
{"id": "hitt-pq-013", "page": "https://hittheroaddude.app/pricing/", "quote": "30 credits · about 5 Hit the Road Dude runs (5–30 across 7 memes) · $5.60 per run", "prices_usd": [5.6], "credits": [30], "fact_type": "per_run_derived", "note": "'about 5' and '5–30' are run counts, not credits", "checked": "2026-11-10"}
{"id": "hitt-pq-026", "page": "https://hittheroaddude.app/faq/", "quote": "hittheroaddude.org (11-second clips, adult-portrait packs from USD 6.99)", "prices_usd": [6.99], "credits": [], "fact_type": "other_site_price", "note": "a competitor's listed price, not this studio's", "checked": "2026-11-10"}
A judgement call worth flagging: other sites' prices are included in prices_usd. The task is extraction of dollar amounts. Whether the amount belongs to this studio is what fact_type and the page context are for, and a stricter task would label it separately.
Validation and baseline (v6)
$ python3 validate_price_quotes.py
28 rows, 5 pages, quotes all live
baseline miss hitt-pq-005 {'prices': [], 'credits': [6]} gold [] [6, 14]
baseline miss hitt-pq-009 {'prices': [], 'credits': [6]} gold [] [6, 14]
baseline miss hitt-pq-016 {'prices': [], 'credits': [200]} gold [] [30, 100, 200]
baseline miss hitt-pq-023 {'prices': [], 'credits': []} gold [] [30, 100, 200, 6, 14]
baseline miss hitt-pq-026 {'prices': [], 'credits': []} gold [6.99] []
baseline miss hitt-pq-027 {'prices': [], 'credits': []} gold [6.9] []
baseline miss hitt-pq-028 {'prices': [], 'credits': []} gold [9.9] []
regex baseline: prices 25/28, credits 24/28
The baseline is two regexes: dollar amounts as $9.99 or 9.99 USD, and credits as a number followed by "credit(s)". It fails in two predictable ways. It misses a number with no unit word ("a 720p clip 14") and a list that shares a unit ("30, 100 or 200 credits"). It also misses prices written USD 6.99, because it only knows the $9.99 and 9.99 USD orders. All seven misses are hard-by-construction, so the 25/28 and 24/28 are a floor for a modest approach, not a leaderboard. It had no tuning on the data. These are exact-match scores per row, not per number.
#!/usr/bin/env python3
"""Check the price-quote dataset: every quote is still on the live page, then score a regex baseline.
usage: python3 validate_price_quotes.py (standard library only; network needed)
Pages are read as the .md twins (https://hittheroaddude.app/<page>.md) or as visible text of the HTML page.
"""
import html, json, re, sys, urllib.request
def fetch(url):
req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
with urllib.request.urlopen(req, timeout=30) as r:
t = r.read().decode("utf-8", "replace")
if url.endswith("/"): # HTML page -> visible text
t = re.sub(r"<(script|style|svg)[^>]*>.*?</\1>", " ", t, flags=re.S)
t = html.unescape(re.sub(r"<[^>]+>", " ", t))
return re.sub(r"\s+", " ", t)
MONEY = re.compile(r"(?:\$\s?(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s?USD)")
CREDITS = re.compile(r"(\d+)\s+credits?")
def baseline(quote):
"""Return {'prices': [...], 'credits': [...]} using two regexes, nothing smarter."""
prices = [float(a or b) for a, b in MONEY.findall(quote)]
return {"prices": prices, "credits": [int(c) for c in CREDITS.findall(quote)]}
def main():
rows = [json.loads(l) for l in open("data/price-quotes-2026-11-10.jsonl", encoding="utf-8")]
ids = [r["id"] for r in rows]; assert len(ids) == len(set(ids)), "duplicate ids"
pages, bad = {}, 0
for r in rows:
pages.setdefault(r["page"], fetch(r["page"]))
if r["quote"] not in pages[r["page"]]:
print("MISSING QUOTE", r["id"], r["quote"][:70]); bad += 1
print(f"{len(rows)} rows, {len(pages)} pages, quotes {'all live' if not bad else str(bad) + ' missing'}")
hit_p = hit_c = 0
for r in rows:
b = baseline(r["quote"])
okp = sorted(b["prices"]) == sorted(r["prices_usd"]); okc = sorted(b["credits"]) == sorted(r["credits"])
hit_p += okp; hit_c += okc
if not (okp and okc): print("baseline miss", r["id"], b, "gold", r["prices_usd"], r["credits"])
print(f"regex baseline: prices {hit_p}/{len(rows)}, credits {hit_c}/{len(rows)}")
sys.exit(1 if bad else 0)
if __name__ == "__main__":
main()
Using it
import json
rows = [json.loads(l) for l in open("data/price-quotes-2026-11-10.jsonl", encoding="utf-8")]
hard = [r for r in rows if r["fact_type"] in {"per_run_derived", "other_site_price", "not_a_price", "comparison_table"}]
print(len(rows), len(hard))
Suggested uses: evaluating extraction of numbers from small web pages, testing that a model keeps run counts and credit counts apart, and checking that "from USD X" for another site is not attributed to this one.
Limits
- 28 rows from one site is a probe, not a benchmark. Splits are not provided.
- Prices change. The quotes were live on 2026-11-10;
validate_price_quotes.pyshows when one has not been. - The
.mdtwins and the visible text of the HTML pages may differ slightly in wording; each row names which one it used.
Licence
CC BY 4.0. Quote text belongs to hittheroaddude.app, which is where it is published.
Earlier card (v5): entity-linking mentions (v5)
What changed in v5 (2026-11-09): two new files and two scripts. data/mentions-2026-11-09.jsonl has 36 short search-style mentions in six languages. Each is labelled with the entity it refers to. data/entities-2026-11-09.jsonl describes the 5 candidate entities, with evidence URLs. link_baseline.py runs three baselines, and validate_mentions.py checks the file shape and confirms the alias evidence is still live. The v4 NLI pairs, v3 routing set, v2 decision cases and v1 Q&A snapshot are unchanged and still load as their own configs.
The question behind it: when someone types "state property" or "hit the road" into an assistant, which thing do they mean? The pickup-window meme from hittheroaddude.app shares words with two well-known works and one everyday concept:
| Entity id | What it is | Evidence |
|---|---|---|
hitt_state_property_clip |
The State Property pickup-window clip: a driver repeats "State?", says it's private property, and ends with "hit the road, dude". Also called State Property meme, Private Property meme, This Is Private Property; Know Your Meme title "Lock 'Em Up / State Property" | names page, home |
hit_the_road_jack_song |
"Hit the Road Jack", written by Percy Mayfield and recorded by Ray Charles, a US number 1 in 1961 | Wikipedia |
state_property_2002_film |
State Property, a 2002 crime film starring Beanie Sigel, produced by Roc-A-Fella; sequel in 2005 | Wikipedia |
private_property_generic |
Private property as a general idea: signs, trespassing, land questions | none needed |
none |
Too short or ambiguous to link without more context | none |
A keyword shortcut gets this badly wrong. "Hit the road jack lyrics" isn't a meme request, and "state property beanie sigel" isn't one either.
What this is not: there are no images, videos, faces, voices, generated outputs or user data. The person in the original viral video is a private individual, and nothing here names him.
Who wrote it: the builder of hittheroaddude.app. The labels are my judgement, and two rows (none) are deliberately ambiguous. Treat it as first-party.
Files (v5)
data/mentions-2026-11-09.jsonl, one mention per line:
| Field | Meaning |
|---|---|
id |
hitt-el-001 … hitt-el-036 |
mention |
The text as someone might type it |
lang |
en (26), zh (4), es (3), pt, de, ja (1 each) |
entity |
hitt_state_property_clip (19), hit_the_road_jack_song (7), state_property_2002_film (5), private_property_generic (3), none (2) |
rationale |
Why the label holds, in a few words |
checked |
2026-11-09 |
Example lines:
{"id": "hitt-el-004", "mention": "state property meme old man truck", "lang": "en", "entity": "hitt_state_property_clip", "rationale": "truck + meme context", "checked": "2026-11-09"}
{"id": "hitt-el-017", "mention": "hit the road jack meme", "lang": "en", "entity": "hit_the_road_jack_song", "rationale": "names the song; the clip has no music", "checked": "2026-11-09"}
{"id": "hitt-el-026", "mention": "state property", "lang": "en", "entity": "none", "rationale": "ambiguous: film or meme without context", "checked": "2026-11-09"}
data/entities-2026-11-09.jsonl contains entity, description and evidence (a list of URLs).
A judgement call worth flagging: "hit the road jack meme" is labelled as the song. Someone who names Jack is asking about the song, even when they add "meme". The clip itself has no music, and the studio "does not add that song or any music track" (names page).
Validation (v5)
$ python3 validate_mentions.py
36 rows, 5 labels, shape ok
ok https://hittheroaddude.app/blog/names-not-the-song.md :: State Property meme, Private Property meme, and This Is Priv
ok https://hittheroaddude.app/blog/names-not-the-song.md :: It is not the song Hit the Road Jack
ok https://hittheroaddude.app/index.md :: Lock 'Em Up / State Property
200 https://en.wikipedia.org/wiki/Hit_the_Road_Jack
200 https://en.wikipedia.org/wiki/State_Property_(film)
#!/usr/bin/env python3
"""Check the dataset file shape, and that the alias evidence is still live.
Re-fetches the two site pages and confirms each quoted alias sentence is
still there, then confirms the Wikipedia pages still return 200.
Standard library only; network needed for the second part.
"""
import json, sys, urllib.request
ALLOWED = {"hitt_state_property_clip", "hit_the_road_jack_song",
"state_property_2002_film", "private_property_generic", "none"}
QUOTES = {
"https://hittheroaddude.app/blog/names-not-the-song.md": [
"State Property meme, Private Property meme, and This Is Private Property name the same exchange here.",
"It is not the song Hit the Road Jack",
],
"https://hittheroaddude.app/index.md": ["Lock 'Em Up / State Property"],
}
def fetch(url):
req = urllib.request.Request(url, headers={"User-Agent": "dataset-validator/1.0"})
with urllib.request.urlopen(req, timeout=30) as r:
return r.status, r.read().decode("utf-8", "replace")
def main():
bad = 0
rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
ids = [r["id"] for r in rows]
assert len(ids) == len(set(ids)), "duplicate ids"
for r in rows:
if r["entity"] not in ALLOWED or not r["mention"].strip():
print("bad row", r["id"]); bad += 1
print(f"{len(rows)} rows, {len(ALLOWED)} labels, shape {'ok' if not bad else 'BAD'}")
for url, quotes in QUOTES.items():
status, text = fetch(url)
for q in quotes:
ok = q in text
bad += not ok
print(f"{'ok ' if ok else 'MISS'} {url} :: {q[:60]}")
for e in (json.loads(l) for l in open("data/entities-2026-11-09.jsonl", encoding="utf-8")):
for url in e["evidence"]:
if "wikipedia" in url:
status, _ = fetch(url)
bad += status != 200
print(f"{status} {url}")
sys.exit(1 if bad else 0)
if __name__ == "__main__":
main()
Baselines (v5)
#!/usr/bin/env python3
"""Three baselines for data/mentions-2026-11-09.jsonl.
naive : "hit the road" / "state property" / "private property" anywhere
-> the meme. The shortcut a keyword router takes.
lexical : character 3-gram cosine between the mention and each entity
description; below 0.12 similarity -> "none".
cues : a hand-written ordered cue list. It was written while looking at
these 36 rows, so its score is an upper bound, not a result.
Prints accuracy per baseline and every miss. Standard library only.
"""
import collections, json, math, re
def grams(s, n=3):
s = " " + re.sub(r"\s+", " ", s.lower()) + " "
return collections.Counter(s[i:i + n] for i in range(len(s) - n + 1))
def cos(a, b):
dot = sum(a[k] * b[k] for k in a if k in b)
na = math.sqrt(sum(v * v for v in a.values())); nb = math.sqrt(sum(v * v for v in b.values()))
return dot / (na * nb) if na and nb else 0.0
def lexical(m, ents):
g = grams(m)
best = max(ents, key=lambda e: cos(g, grams(e["description"])))
return best["entity"] if cos(g, grams(best["description"])) >= 0.12 and best["entity"] != "none" else "none"
CUES = [ # (entity, any-of substrings), first hit wins
("hit_the_road_jack_song", ["jack"]),
("state_property_2002_film", ["2002", "beanie", "sigel", "sequel", "roc-a-fella", "电影", "movie", "film"]),
("hitt_state_property_clip", ["dude", "meme", "梗", "ミーム", "state?", "tiktok", "pickup", "皮卡",
"camioneta", "lock em up"]),
("private_property_generic", ["sign", "law", "trespass", "land"]),
]
def naive(m):
s = m.lower()
return ("hitt_state_property_clip"
if any(k in s for k in ("hit the road", "state property", "private property", "私人财产"))
else "none")
def cues(m):
s = m.lower()
for ent, keys in CUES:
if any(k in s for k in keys):
return ent
return "none"
if __name__ == "__main__":
rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
ents = [json.loads(l) for l in open("data/entities-2026-11-09.jsonl", encoding="utf-8")]
for name, fn in (("naive", naive), ("lexical", lambda m: lexical(m, ents)), ("cues", cues)):
miss = [(r["id"], r["mention"], r["entity"], p) for r in rows if (p := fn(r["mention"])) != r["entity"]]
print(f"{name:8} accuracy {len(rows) - len(miss)}/{len(rows)} = {1 - len(miss) / len(rows):.2f}")
for i, m, gold, pred in miss:
print(f" {i} {m!r:48} gold={gold:26} pred={pred}")
$ python3 link_baseline.py
naive accuracy 17/36 = 0.47
lexical accuracy 21/36 = 0.58
cues accuracy 36/36 = 1.00
How to read these:
- naive (0.47) sends anything containing "hit the road", "state property" or "private property" to the meme. It gets every song, film and generic-property mention wrong, plus both ambiguous rows. It also misses ""State?" guy in the white pickup" and the Spanish "meme propiedad privada camioneta blanca", because neither contains the English phrases.
- lexical (0.58) compares character trigrams with the entity descriptions. It sends most "hit the road dude …" mentions to the song, because the song's short description is dominated by "Hit the Road". It also sends "private property sign printable" to the meme, because the meme's description is the one full of "private property". Short descriptions make lexical linking fragile.
- cues (1.00) is not a result. I wrote the cue list while looking at these 36 rows. It shows that a few ordered rules ("jack" first, then film cues, then meme cues) can separate the classes, and that's all it shows. A fair test needs new mentions written by someone else.
With 36 rows, every number here is anecdotal. The value is a small, dated, re-checkable set of hard negatives for anyone building search, routing or an answer engine around this meme.
Uses (v5)
- Hard negatives for retrieval. Pair each
hitt_state_property_clipmention with the song and film mentions as negatives. - Answer checking. An assistant asked "state property 2002 cast" shouldn't answer with a meme generator. One asked "make my dog say hit the road dude" shouldn't answer with Ray Charles.
- A template for any meme whose name collides with older works.
Loading with no dependencies:
import json
rows = [json.loads(l) for l in open("data/mentions-2026-11-09.jsonl", encoding="utf-8")]
print(len(rows), sum(r["entity"] == "none" for r in rows))
With 🤗 datasets: load_dataset("conan123/hittheroaddude-guides", "mentions"), plus "entities", "nli_pairs", "query_routing", "pages", "decision_cases" and "qa_2026_11_02".
Product facts, for context (checked 2026-11-09)
From the live pricing page: one clip is 9.99 USD at 480p (6 credits) or 12.99 USD at 720p (14 credits). Signed-in accounts can buy one-time packs of 27.99 USD for 30 credits, 71.99 USD for 100 or 129.99 USD for 200. There's no subscription. Every clip is 15 seconds, vertical, with a newly generated voice, made from one photo of an adult or a pet (FAQ).
v4 (2026-11-05): NLI claim pairs
What changed in v4 (2026-11-05): a new file and two scripts. data/nli-pairs-2026-11-05.jsonl has 31 premise/hypothesis pairs about the studio at hittheroaddude.app, labelled entailment, neutral or contradiction. validate_pairs.py re-fetches every quoted page and confirms each quote is still there. baseline_nli.py is a four-rule baseline, so a model has something to beat. The v3 routing set, v2 decision cases and v1 Q&A snapshot are unchanged and still load as their own configs.
The question behind it: when an assistant answers "how much is it?" or "is it free?" from several pages of the same site, do those pages agree? And can a model tell a paraphrase from a contradiction when both use the same words? Every premise in this file is copied verbatim from a live page. 12 hypotheses are also verbatim page quotes (page-vs-page pairs), and 19 are claims I wrote to sound like typical wrong or unanswerable assistant statements (constructed pairs).
What this is not: there are no images, videos, faces, voices, generated outputs or user data. The person in the original viral video is a private individual, and nothing here names him.
Who wrote it: the builder of hittheroaddude.app. The labels reflect my reading of my own site. Treat them as first-party.
Files (v4)
data/nli-pairs-2026-11-05.jsonl, one pair per line:
| Field | Meaning |
|---|---|
id |
hitt-nli-001 … hitt-nli-031 |
topic |
e.g. price, packs, refund, catalog, format, free, consent, sharing, dates |
premise, premise_url |
A sentence or fragment copied verbatim from the page at premise_url on 2026-11-05 |
hypothesis |
The claim to judge |
hypothesis_source |
page (verbatim from hypothesis_url) or constructed (written by me; hypothesis_url is null) |
label |
entailment (9), neutral (5), contradiction (17) |
rationale |
One line on why the label holds |
checked |
Date the quotes were confirmed live |
Three example lines (the last two abridged with ...):
{"id": "hitt-nli-003", "topic": "packs", "premise": "Credit packs are one-time purchases without automatic renewal.", "premise_url": "https://hittheroaddude.app/llms.txt", "hypothesis": "Packs do not renew.", "hypothesis_source": "page", "hypothesis_url": "https://hittheroaddude.app/pricing.md", "label": "entailment", "rationale": "Paraphrase.", "checked": "2026-11-05"}
{"id": "hitt-nli-022", "topic": "refund", "premise": "A delivered clip is not refunded as a change of mind.", "premise_url": "https://hittheroaddude.app/refunds.md", "hypothesis": "You can get a refund on a delivered clip if you don't like it.", "hypothesis_source": "constructed", "hypothesis_url": null, "label": "contradiction", ...}
{"id": "hitt-nli-030", "topic": "credits", "premise": "Credits never expire", "premise_url": "https://hittheroaddude.app/pricing/", "hypothesis": "Credits can be moved to another account.", "hypothesis_source": "constructed", "hypothesis_url": null, "label": "neutral", ...}
The page-vs-page contradictions are real (v4)
Four of the 12 page-vs-page pairs are labelled contradiction, and they are genuine inconsistencies on the live sites today, not constructed examples:
- Shared catalog prices are stale. The pricing page's cross-site catalog lists "Tiny Desk Outstanding 480p $9.99 · 6 credits", while tinydeskoutstanding.video's own pricing twin says "480p is 9.98 USD (998 credits)." The Bama Bound and Malfoid rows also disagree with those sites' own pricing pages (pairs 007 to 009).
- Two "updated" dates. The privacy page says "Last updated 2026-10-26" while its
.mdtwin says "Updated: 2026-10-30" (pair 006). - One near-miss: llms.txt vs FAQ. llms.txt says "Prices and required credits vary by model and settings", while the FAQ says "You do not pick a model or write a prompt." I labelled this
neutralrather thancontradiction(pair 005): both can be true if "settings" means the resolution choice, but an assistant reading only llms.txt would get the wrong idea.
This studio's own prices agree everywhere I checked: 9.99 USD (6 credits) at 480p, 12.99 USD (14 credits) at 720p, one-time packs of 27.99 USD for 30 credits, 71.99 USD for 100 and 129.99 USD for 200, and "Credits never expire" (pricing).
Validation (v4)
$ python3 validate_pairs.py data/nli-pairs-2026-11-05.jsonl
31 pairs, 0 quotes missing, 0 checks skipped (page unreachable)
The validator fetches each URL once with the standard library, strips tags from HTML pages, collapses whitespace, straightens curly quotes, and checks each quote as a substring. It retries a page up to three times. During this run two pages timed out on the first try and loaded on the second. It exits 1 if any quote is missing, 2 if a page stays unreachable, and 0 otherwise. Re-run it before relying on a record. A missing quote means the page changed, and the label may no longer hold.
Baseline (v4)
baseline_nli.py applies four rules in order: different number sets → contradiction, negation on exactly one side → contradiction, word overlap (Jaccard ≥ 0.25) → entailment, otherwise neutral.
$ python3 baseline_nli.py data/nli-pairs-2026-11-05.jsonl
accuracy 0.742 on 31 pairs (majority class 'contradiction' = 0.548)
gold \ pred entailm neutral contrad
entailment 4 4 1
neutral 0 3 2
contradiction 0 1 16
The misses are the instructive part:
- Arithmetic looks like disagreement. Pair 002 ("30, 100 or 200 credits, about 5, 16 or 33 … runs") has numbers the premise doesn't contain, so rule 1 calls it a contradiction. It's entailed by dividing by 6.
- Negation in both forms. "There are no free clips or free credits" vs "Every clip is paid. New accounts start at zero credits." Both sides are negative ("no", "zero"), so rule 2 doesn't fire, and the word overlap is too low for entailment.
- Constructed contradictions without a negation word. "You can get a refund on a delivered clip if you don't like it" is predicted neutral.
- Neutral claims that sound like denials. "Credits can be moved to another account" vs "Credits never expire" is predicted contradiction purely because of "never".
The 16/17 on contradictions mostly comes from rules 1 and 2. With 31 pairs, every result here is anecdotal. The point is a fixed, re-checkable test set, not a leaderboard.
Uses (v4)
- Site consistency checks. Run an NLI model over page-vs-page pairs after every content change. A new contradiction is a page to fix.
- Assistant answer checking. The constructed hypotheses are typical wrong answers (free clip, 1080p, 30-second version, refund on change of mind, app download). A grounded assistant should reject them against the premise.
- A template for building the same kind of file for any small site: quote, claim, label, rationale, date, validator.
Loading with no dependencies:
import json
pairs = [json.loads(l) for l in open("data/nli-pairs-2026-11-05.jsonl", encoding="utf-8")]
print(len(pairs), sum(p["label"] == "contradiction" for p in pairs))
With 🤗 datasets: load_dataset("conan123/hittheroaddude-guides", "nli_pairs"), and likewise "query_routing", "pages", "decision_cases" and "qa_2026_11_02".
Out of scope
- Identifying the person in the original video. Not supported. Please don't use these records to try.
- Judging clip quality or ranking AI generators. Nothing here measures a render.
- Disambiguating anything beyond the five entities in
entities-2026-11-09.jsonl. Other works share these words too. - Other sites' prices as facts. The catalog pairs record what each page said on 2026-11-05. Check the live pages.
Changes and known stale records
- 2026-11-09 (v5): added
data/mentions-2026-11-09.jsonl(36),data/entities-2026-11-09.jsonl(5),link_baseline.pyandvalidate_mentions.py.mentionsis now the default config. - Stale since 2026-11-09 in v4: pair
hitt-nli-007's hypothesis quote ("480p is 9.98 USD (998 credits).") no longer appears on tinydeskoutstanding.video/pricing.md, which now reads "Each video is $9.98 at 480p". The contradiction it records still holds: the Hit the Road Dude catalog row still lists Tiny Desk Outstanding at "$9.99 · 6 credits". The other 30 pairs validated on 2026-11-09. - 2026-11-05 (v4): added
data/nli-pairs-2026-11-05.jsonl(31),validate_pairs.pyandbaseline_nli.py.nli_pairsis now the default config. - 2026-11-04 (v3): added
data/queries-2026-11-04.jsonl(40),data/pages-2026-11-04.jsonl(28) androute_bm25.py. - 2026-11-03 (v2): added
data/eval-cases-2026-11-03.jsonl(22 decision cases) andvalidate_cases.py. Moved the 2026-11-02 records unchanged todata/qa-2026-11-02.jsonl. - Stale in the 2026-11-02 file: record
out-modelnames "Seedance 2.0". The FAQ's visible text no longer names a model, though some pages' structured data still does. It's kept as a dated snapshot. - Expected to go stale: the catalog pairs (007 to 009) and the date pair (006) record inconsistencies. When the pages are fixed, those quotes will stop validating, which is the intended signal.
Citation
@misc{hittheroaddude_guides_2026,
title = {Hit the Road Dude guides: entity-linking mentions, NLI claim pairs, query routing, decision cases and Q\&A snapshot},
author = {Li, Peiguan},
year = {2026},
note = {v5, mentions checked 2026-11-09},
url = {https://hittheroaddude.app/}
}
- Downloads last month
- 393