pandorga 1.14.1 → 2.0.0

data/scripts/test/test-hero-16x9.rb

@@ -0,0 +1,379 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# PLT-AC-51. A 16:9 home hero at every width (docs/features/hero-16x9.md).
+#
+# Each check names the acceptance item it covers (51.1 … 51.10). Pass item
+# numbers to run a subset: `ruby scripts/test/test-hero-16x9.rb 4 5`.
+# 51.9 writes images with ImageMagick. Without it the generator half is
+# skipped locally and fails on CI, like test-thumbnail-variants.
+
+require "fileutils"
+require "open3"
+require "pathname"
+require "set"
+require "tmpdir"
+require "yaml"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+HOME_CSS = ROOT.join("assets/css/ledger/home.css")
+LAYOUT = ROOT.join("_layouts/home.html")
+SHELL = ROOT.join("_layouts/shell.html")
+RUNTIME = ROOT.join("_includes/content-runtime/60-fragments.html")
+SCHEMA = ROOT.join("lib/pandorga/registry/schema.yml")
+CONFIG_DOC = ROOT.join("docs/configuration.md")
+
+require_relative "../content/hero_portraits"
+require_relative "../../lib/pandorga/thumbnail_variants"
+
+ONLY_ITEMS = ARGV.map { |a| a.sub(/\A(PLT-AC-)?51\./, "") }.to_set
+DESKTOP = "(min-width:1024px)"
+PHONE = "(max-width:767px)"
+
+$failures = []
+
+def item(id)
+  return if !ONLY_ITEMS.empty? && !ONLY_ITEMS.include?(id.to_s)
+
+  @item = id
+  yield
+end
+
+def fail!(msg)
+  $failures << "FAIL PLT-AC-51.#{@item}: #{msg}"
+end
+
+# ── CSS parser (same shape as test-v3-layout.rb) ───────────────────────────
+
+def strip_comments(text)
+  text.gsub(%r{/\*.*?\*/}m, "")
+end
+
+def split_top(text, sep)
+  parts = []
+  depth = 0
+  buf = +""
+  text.each_char do |c|
+    if c == "(" || c == "["
+      depth += 1
+    elsif c == ")" || c == "]"
+      depth -= 1
+    elsif c == sep && depth.zero?
+      parts << buf
+      buf = +""
+      next
+    end
+    buf << c
+  end
+  parts << buf
+  parts.map(&:strip).reject(&:empty?)
+end
+
+def parse_rules(css, media = nil, out = [])
+  i = 0
+  head = +""
+  while i < css.length
+    c = css[i]
+    if c == "{"
+      depth = 1
+      j = i + 1
+      while j < css.length && depth.positive?
+        depth += 1 if css[j] == "{"
+        depth -= 1 if css[j] == "}"
+        j += 1
+      end
+      body = css[(i + 1)...(j - 1)]
+      h = head.strip
+      if h.start_with?("@media")
+        inner = h.sub(/\A@media/, "").gsub(/\s+/, "")
+        parse_rules(body, [media, inner].compact.join("and"), out)
+      elsif h.start_with?("@supports", "@layer", "@container")
+        parse_rules(body, media, out)
+      elsif !h.start_with?("@")
+        decls = split_top(body, ";").filter_map do |d|
+          prop, val = d.split(":", 2)
+          next unless val
+
+          [prop.strip.downcase, val.gsub(/\s+/, " ").strip]
+        end
+        split_top(h, ",").each do |sel|
+          out << { sel: sel.gsub(/\s+/, " ").strip, decls: decls, media: media, order: out.length }
+        end
+      end
+      head = +""
+      i = j
+    elsif c == ";" && head.strip.start_with?("@")
+      head = +""
+      i += 1
+    elsif c == "}"
+      i += 1
+    else
+      head << c
+      i += 1
+    end
+  end
+  out
+end
+
+RULES = parse_rules(strip_comments(HOME_CSS.read))
+
+def rules_for(sel, media: :any)
+  RULES.select do |r|
+    r[:sel] == sel && (media == :any || r[:media] == media)
+  end
+end
+
+# The value the last matching rule declares, or nil.
+def decl(sel, prop, media: nil)
+  rules_for(sel, media: media).reverse_each do |r|
+    pair = r[:decls].reverse.find { |p, _| p == prop }
+    return pair[1] if pair
+  end
+  nil
+end
+
+def expect_decl(sel, prop, want, media: nil)
+  got = decl(sel, prop, media: media)
+  ok = want.is_a?(Regexp) ? got.to_s.match?(want) : got == want
+  where = media ? " under #{media}" : ""
+  fail!("#{sel} #{prop} should be #{want.inspect}#{where}, got #{got.inspect}") unless ok
+end
+
+def hero_rule?(r)
+  r[:sel].include?("home-hero")
+end
+
+# ── 51.1 Plate ──────────────────────────────────────────────────────────────
+
+item(1) do
+  expect_decl(".home-hero-plate", "aspect-ratio", "16 / 9")
+  RULES.select { |r| hero_rule?(r) }.each do |r|
+    r[:decls].each do |prop, val|
+      next unless prop == "aspect-ratio"
+
+      if val.match?(%r{\A(3\s*/\s*4|4\s*/\s*3)\z})
+        fail!("#{r[:sel]} sets aspect-ratio #{val} under #{r[:media].inspect}")
+      end
+    end
+  end
+  landscape = RULES.select { |r| r[:sel].include?("--landscape") && hero_rule?(r) }
+  fail!("no .home-hero-plate--landscape rule may remain") unless landscape.empty?
+end
+
+# ── 51.2 Phone ──────────────────────────────────────────────────────────────
+
+item(2) do
+  expect_decl(".home-hero-portrait", "width", /\Acalc\(100% \+ \(2 \* var\(--gutter-mobile\)\)\)\z/, media: PHONE)
+  expect_decl(".home-hero-portrait", "margin-inline", "calc(-1 * var(--gutter-mobile))", media: PHONE)
+  expect_decl(".home-hero-plate", "border-inline", "0", media: PHONE)
+end
+
+# ── 51.3 768px to 1023px ───────────────────────────────────────────────────
+
+item(3) do
+  rules_for(".home-hero-portrait").each do |r|
+    r[:decls].each do |prop, val|
+      next unless prop == "max-width" && val.match?(/rem/)
+
+      fail!(".home-hero-portrait max-width #{val} under #{r[:media].inspect} caps the plate")
+    end
+  end
+  expect_decl(".home-hero-portrait", "width", "100%")
+end
+
+# ── 51.4 From 1024px ───────────────────────────────────────────────────────
+
+item(4) do
+  expect_decl(".home-hero", "display", "flex", media: DESKTOP)
+  expect_decl(".home-hero-copy", "flex", "0 0 46%", media: DESKTOP)
+  expect_decl(".home-hero-copy", "min-width", "0", media: DESKTOP)
+  expect_decl(".home-hero-portrait", "flex", "1 1 0", media: DESKTOP)
+  expect_decl(".home-hero-portrait", "min-height", "15rem", media: DESKTOP)
+  expect_decl(".home-hero-portrait", "max-width", "none", media: DESKTOP)
+  expect_decl(".home-hero-portrait", "aspect-ratio", "auto", media: DESKTOP)
+  [".home-hero-plate-wrap", ".home-hero-plate"].each do |sel|
+    expect_decl(sel, "position", "absolute", media: DESKTOP)
+    expect_decl(sel, "inset", "0", media: DESKTOP)
+    expect_decl(sel, "aspect-ratio", "auto", media: DESKTOP)
+  end
+  expect_decl(".home-hero-plate img", "object-fit", "cover", media: DESKTOP)
+  expect_decl(".home-hero-plate img", "object-position", /\Acenter( center)?\z/, media: DESKTOP)
+
+  layout = LAYOUT.read
+  fail!("the crosshairs must stay on the plate wrapper") unless layout.include?('class="ledger-frame-crosshairs"')
+  fail!("the corner marks must stay in the plate") unless layout.include?('class="ledger-frame-corners"')
+end
+
+# ── 51.5 Cascade ────────────────────────────────────────────────────────────
+
+item(5) do
+  [".home-hero-portrait", ".home-hero-plate-wrap", ".home-hero-plate", ".home-hero-plate img"].each do |sel|
+    base = rules_for(sel, media: nil).map { |r| r[:order] }.max
+    wide = rules_for(sel, media: DESKTOP).map { |r| r[:order] }.min
+    if base.nil? || wide.nil?
+      fail!("#{sel} needs a base rule and a #{DESKTOP} rule")
+    elsif wide < base
+      fail!("the #{DESKTOP} #{sel} rule comes before its base rule, which wins on source order")
+    end
+  end
+end
+
+# ── 51.6 Name from 1024px ───────────────────────────────────────────────────
+
+item(6) do
+  title = ".home-ledger .home-hero-title"
+  expect_decl(title, "white-space", "normal", media: DESKTOP)
+  expect_decl(title, "font-size",
+              "min(calc(100cqi / var(--hero-name-fit, 8.4)), var(--hero-name-max, 4.5rem))",
+              media: DESKTOP)
+  %w[.home-hero-given .home-hero-family].each do |sel|
+    expect_decl(sel, "display", "inline-block", media: DESKTOP)
+    expect_decl(sel, "white-space", "nowrap", media: DESKTOP)
+  end
+end
+
+# ── 51.7 Markup ─────────────────────────────────────────────────────────────
+
+item(7) do
+  layout = LAYOUT.read
+  imgs = layout.scan(/<img[^>]*data-content-hero-portrait[^>]*>/m)
+  fail!("the layout must render exactly one hero image, got #{imgs.length}") unless imgs.length == 1
+  img = imgs.first.to_s
+  unless img.include?('width="1600"') && img.include?('height="900"')
+    fail!("the hero image must be 1600×900, got #{img.inspect}")
+  end
+  fail!("no data-hero-landscape on the hero image") if img.include?("data-hero-landscape")
+  hero = layout[/<div class="home-hero-portrait">.*?<\/figure>/m].to_s
+  fail!("the plate has no <picture> or <source>") if hero.include?("<picture") || hero.include?("<source")
+  fail!("the home layout must not read hero_landscape") if layout.include?("hero_landscape")
+  fail!("the plate has no --landscape class") if layout.include?("home-hero-plate--landscape")
+  shell = SHELL.read
+  fail!("the shell must not read hero_landscape") if shell.include?("hero_landscape")
+  fail!("the shell must not preload a hero image") if shell.match?(/rel="preload" as="image"/)
+end
+
+# ── 51.8 Runtime ────────────────────────────────────────────────────────────
+
+item(8) do
+  runtime = RUNTIME.read
+  start = runtime.index("function heroPortraitEntries")
+  finish = runtime.index("function hydratePageFragments")
+  if start.nil? || finish.nil? || finish < start
+    fail!("hero functions must precede hydratePageFragments")
+  else
+    body = runtime[start...finish]
+    %w[heroLandscapeEntries paintNarrowHero showConfiguredLandscape showHeroLandscape
+       applyHeroLandscapeFile setNarrowSource watchHeroFrame configuredLandscape heroPlate].each do |name|
+      fail!("#{name} must be removed") if body.include?(name)
+    end
+    fail!("the hero draw must not watch a media query") if body.include?("matchMedia")
+    fail!("the hero runtime must not read a landscape field") if body.include?("landscape")
+    hydrate = body[/function hydrateHeroPortrait\(\) \{.*?\n    \}/m].to_s
+    unless hydrate.include?("loadJson('pages/home/portraits.json')") && hydrate.include?("showHeroPortrait(img, heroPortraitEntries(data))")
+      fail!("hydrateHeroPortrait must draw from portraits.json at every width, got #{hydrate.inspect}")
+    end
+  end
+end
+
+# ── 51.9 Export ─────────────────────────────────────────────────────────────
+
+# Minimal JPEG and PNG headers. HeroPortraits reads only the size.
+def write_jpeg_header(path, width, height)
+  sof = [0xFF, 0xC0, 0x00, 0x11, 0x08].pack("C*") + [height, width].pack("nn") +
+        [0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01].pack("C*")
+  app0 = [0xFF, 0xE0, 0x00, 0x10].pack("C*") + "JFIF\x00".b + [1, 1, 0, 0, 1, 0, 1, 0, 0].pack("C*")
+  FileUtils.mkdir_p(path.dirname)
+  File.binwrite(path, [0xFF, 0xD8].pack("C*") + app0 + sof + [0xFF, 0xD9].pack("C*"))
+end
+
+def write_png_header(path, width, height)
+  ihdr = "IHDR".b + [width, height, 8, 2, 0, 0, 0].pack("NNCCCCC")
+  FileUtils.mkdir_p(path.dirname)
+  File.binwrite(path, "\x89PNG\r\n\x1A\n".b + [13].pack("N") + ihdr + "\x00\x00\x00\x00".b)
+end
+
+item(9) do
+  Dir.mktmpdir("hero-16x9") do |dir|
+    root = Pathname.new(dir)
+    pool = root.join("media/images/hero")
+    write_jpeg_header(pool.join("a.jpg"), 1920, 1080)
+    write_jpeg_header(pool.join("variants/a-480.jpg"), 480, 270)
+    write_jpeg_header(pool.join("variants/a-960.jpg"), 960, 1280) # stale 3:4
+    write_png_header(pool.join("b.png"), 1920, 1080)
+    write_png_header(pool.join("variants/b-1440.jpg"), 1440, 810) # sniffed, not by name
+
+    got = HeroPortraits.entries(root)
+    sizes = "(max-width: 1023px) 100vw, 50vw"
+    want = [
+      { "src" => "/media/images/hero/a.jpg",
+        "srcset" => "/media/images/hero/variants/a-480.jpg 480w", "sizes" => sizes },
+      { "src" => "/media/images/hero/b.png",
+        "srcset" => "/media/images/hero/variants/b-1440.jpg 1440w", "sizes" => sizes }
+    ]
+    fail!("entries must list only 16:9 variants, got #{got.inspect}") unless got == want
+    fail!("no entry may carry landscape") if got.any? { |e| e.key?("landscape") }
+  end
+
+  bins = Pandorga::ThumbnailVariants.resolve_imagemagick
+  if bins.nil?
+    if ENV["CI"]
+      fail!("ImageMagick is missing on CI")
+    else
+      puts "SKIP PLT-AC-51.9 generator: ImageMagick not installed"
+    end
+    next
+  end
+
+  Dir.mktmpdir("hero-16x9-gen") do |dir|
+    root = Pathname.new(dir)
+    pool = root.join("content/media/images/hero")
+    FileUtils.mkdir_p(pool)
+    big = pool.join("wide.jpg")
+    small = pool.join("small.jpg")
+    out, status = Open3.capture2e(*bins[:convert], "-size", "1920x1080", "xc:steelblue", big.to_s)
+    fail!("could not draw a fixture: #{out}") unless status.success?
+    out, status = Open3.capture2e(*bins[:convert], "-size", "1000x750", "xc:tomato", small.to_s)
+    fail!("could not draw a fixture: #{out}") unless status.success?
+    stale = pool.join("variants/wide-960.jpg")
+    FileUtils.mkdir_p(stale.dirname)
+    out, status = Open3.capture2e(*bins[:convert], "-size", "960x1280", "xc:gray", stale.to_s)
+    fail!("could not draw a fixture: #{out}") unless status.success?
+    past = Time.now - 3600
+    File.utime(past, past, big.to_s)
+    File.utime(past, past, small.to_s)
+
+    Pandorga::ThumbnailVariants.generate(root)
+
+    size_of = lambda do |path|
+      o, _e, s = Open3.capture3(*bins[:identify], "-format", "%wx%h", "#{path}[0]")
+      s.success? ? o.strip : nil
+    end
+    { "wide-480.jpg" => "480x270", "wide-960.jpg" => "960x540", "wide-1440.jpg" => "1440x810",
+      "small-480.jpg" => "480x270", "small-960.jpg" => "960x540" }.each do |name, want|
+      got = size_of.call(pool.join("variants", name))
+      fail!("variants/#{name} should be #{want}, got #{got.inspect}") unless got == want
+    end
+    fail!("no variant wider than its original") if pool.join("variants/small-1440.jpg").exist?
+
+    entries = HeroPortraits.entries(root.join("content"))
+    wide = entries.find { |e| e["src"] == "/media/images/hero/wide.jpg" }
+    want = %w[480 960 1440].map { |w| "/media/images/hero/variants/wide-#{w}.jpg #{w}w" }.join(", ")
+    fail!("the export must list the generated variants, got #{wide.inspect}") unless wide && wide["srcset"] == want
+  end
+end
+
+# ── 51.10 Registry ──────────────────────────────────────────────────────────
+
+item(10) do
+  schema = YAML.safe_load(SCHEMA.read, aliases: true) || {}
+  keys = schema.dig("home", "keys") || {}
+  fail!("pandorga.home.hero_landscape must leave the registry schema") if keys.key?("hero_landscape")
+  fail!("docs/configuration.md must not list hero_landscape") if CONFIG_DOC.read.include?("hero_landscape")
+end
+
+if $failures.empty?
+  puts "PLT-AC-51: all checks passed"
+else
+  puts $failures
+  exit 1
+end

data/scripts/test/test-hero-portraits.mjs

@@ -30,10 +30,10 @@ if (!slice.includes('function pickHeroPortrait')) {
 }
 
 const api = new Function(
-  `${slice}\nreturn { heroPortraitEntries, heroLandscapeEntries, pickHeroPortrait };`
+  `${slice}\nreturn { heroPortraitEntries, pickHeroPortrait };`
 )();
 
-const { heroPortraitEntries, heroLandscapeEntries, pickHeroPortrait } = api;
+const { heroPortraitEntries, pickHeroPortrait } = api;
 
 let failed = 0;
 
@@ -81,30 +81,20 @@ same(
   'normalised rows'
 );
 
+// AC-HERO-08: one 16:9 frame at every width. A stale landscape key from an
+// older export is dropped, so no width draws a second file.
 same(
   heroPortraitEntries([
-    { src: '/media/images/hero/a.jpg', landscape: '  /media/images/hero/a-16x9.jpg  ' },
-    { src: '/media/images/hero/b.jpg', landscape: '' },
-    { src: '/media/images/hero/c.jpg', landscape: '   ' },
-    { src: '/media/images/hero/d.jpg', landscape: 4 },
+    { src: '/media/images/hero/a.jpg', landscape: '/media/images/hero/a-16x9.jpg' },
+    { src: '/media/images/hero/b.jpg', srcset: '/v/b-480.jpg 480w', sizes: '50vw', landscape: 'x' },
   ]),
   [
-    { src: '/media/images/hero/a.jpg', alt: '', landscape: '/media/images/hero/a-16x9.jpg' },
-    { src: '/media/images/hero/b.jpg', alt: '' },
-    { src: '/media/images/hero/c.jpg', alt: '' },
-    { src: '/media/images/hero/d.jpg', alt: '' },
+    { src: '/media/images/hero/a.jpg', alt: '' },
+    { src: '/media/images/hero/b.jpg', alt: '', srcset: '/v/b-480.jpg 480w', sizes: '50vw' },
   ],
-  'optional landscape'
+  'landscape dropped'
 );
-same(
-  heroLandscapeEntries([
-    { src: '/media/images/hero/a.jpg', alt: '', landscape: '/media/images/hero/a-16x9.jpg' },
-    { src: '/media/images/hero/b.jpg', alt: '' },
-  ]),
-  [{ src: '/media/images/hero/a.jpg', alt: '', landscape: '/media/images/hero/a-16x9.jpg' }],
-  'landscape pool'
-);
-same(heroLandscapeEntries([]), [], 'empty landscape pool');
+check(!/landscape/i.test(slice), 'the picker slice must not read a landscape field');
 
 // AC-HERO-06
 const two = [

data/scripts/test/test-hero-portraits.rb

@@ -9,6 +9,8 @@
 # AC-HERO-04 the plate starts with no photograph
 # AC-HERO-05 the runtime draws once per load and fades the file in after it loads
 # AC-HERO-06 / AC-HERO-07 the picker, executed from the runtime source
+# AC-HERO-08 one 16:9 frame at every width (PLT-AC-51): no landscape file,
+#            no picture source, no width switch
 
 require "fileutils"
 require "json"
@@ -105,16 +107,15 @@ hero_imgs.each do |hero_img|
   check!(hero_img.include?('fetchpriority="high"'),
          "the hero image must request fetchpriority high, got #{hero_img.inspect}")
 end
-check!(layout.include?("page.hero_landscape") && layout.include?("site.pandorga.home.hero_landscape"),
-       "narrow hero reads front matter and pandorga.home.hero_landscape")
-check!(layout.include?('media="(max-width: 767px)"') && layout.include?("<picture>"),
-       "a configured landscape file is a picture source for narrow viewports")
-check!(layout.include?("data-hero-landscape"),
-       "the image carries the landscape URL for the runtime")
+check!(hero_imgs.length == 1 && hero_imgs.first.include?('width="1600"') &&
+         hero_imgs.first.include?('height="900"'),
+       "AC-HERO-08: one 1600×900 plate image, got #{hero_imgs.inspect}")
+check!(!layout.include?("hero_landscape") && !layout.include?("data-hero-landscape") &&
+         !layout.include?("<picture") && !layout.include?("<source"),
+       "AC-HERO-08: the layout has no landscape file and no picture source")
 shell = SHELL.read
-check!(shell.include?('rel="preload" as="image"') && shell.include?('fetchpriority="high"') &&
-         shell.include?('media="(max-width: 767px)"') && shell.include?("hero_landscape"),
-       "the shell preloads a configured landscape image on narrow viewports")
+check!(!shell.include?("hero_landscape") && !shell.match?(/rel="preload" as="image"/),
+       "AC-HERO-08: the shell preloads no hero image")
 tailwind_at = shell.index('href="/assets/css/tailwind.css"')
 icons_at = shell.index("window.__pandorgaIconsHref")
 check!(tailwind_at && icons_at && tailwind_at < icons_at,
@@ -129,17 +130,23 @@ check!(plate_img&.match?(/opacity:\s*0/) && plate_img.match?(/transition:[^;]*op
 shown = home_css[/^\.home-hero-plate img\.is-shown \{.*?\n\}/m]
 check!(shown&.match?(/opacity:\s*1/),
        "a ready photograph fades to full opacity, got #{shown.inspect}")
-check!(!home_css.include?("aspect-ratio: 4 / 3"),
-       "the phone plate must not cover-crop the portrait into 4:3")
-landscape_plate = home_css[/@media \(max-width: 767px\) \{\s*\.home-hero-plate--landscape \{[^}]*\}/m]
-check!(landscape_plate&.include?("aspect-ratio: 16 / 9"),
-       "a landscape plate is 16:9 on a phone, got #{landscape_plate.inspect}")
-landscape_img = home_css[/\.home-hero-plate--landscape img \{[^}]*\}/m]
-check!(landscape_img&.include?("object-fit: contain") && landscape_img.include?("opacity: 0"),
-       "the 16:9 plate stays empty until the chosen file loads, got #{landscape_img.inspect}")
-landscape_shown = home_css[/\.home-hero-plate--landscape img\.is-shown \{[^}]*\}/m]
-check!(landscape_shown&.include?("opacity: 1"),
-       "the chosen 16:9 file paints in the fixed plate, got #{landscape_shown.inspect}")
+# Scoped to the hero rules: other home cards (the Rascunhos posters,
+# PLT-AC-49) may use 4:3. Any spacing of 4/3 counts.
+hero_crops = home_css.scan(/([^{}]*home-hero[^{}]*)\{([^{}]*)\}/).select do |_selector, body|
+  body.match?(/aspect-ratio:\s*4\s*\/\s*3/)
+end
+check!(hero_crops.empty?,
+       "the phone plate must not cover-crop the portrait into 4:3, got #{hero_crops.map(&:first).map(&:strip).inspect}")
+portrait_crops = home_css.scan(/([^{}]*home-hero[^{}]*)\{([^{}]*)\}/).select do |_selector, body|
+  body.match?(/aspect-ratio:\s*3\s*\/\s*4/)
+end
+check!(portrait_crops.empty?,
+       "AC-HERO-08: no hero rule keeps the 3:4 frame, got #{portrait_crops.map(&:first).map(&:strip).inspect}")
+base_plate = home_css[/^\.home-hero-plate \{.*?\n\}/m]
+check!(base_plate&.match?(%r{aspect-ratio:\s*16\s*/\s*9}),
+       "AC-HERO-08: the plate is 16:9 at every width, got #{base_plate.inspect}")
+check!(!home_css.include?("home-hero-plate--landscape"),
+       "AC-HERO-08: the landscape plate class is gone")
 
 runtime = RUNTIME.read
 start = runtime.index("function heroPortraitEntries")
@@ -161,11 +168,8 @@ check!(onload && onload.index("applyHeroPortraitSources") && onload.index("img.s
        "srcset must be applied before src so the full file is not the first request")
 check!(body.include?("probe.fetchPriority = 'high'"),
        "the portrait probe must use fetchPriority high")
-check!(body.include?("heroLandscapeEntries") && body.include?("paintNarrowHero") &&
-         body.include?("entry.landscape"),
-       "a narrow viewport draws from entries that carry a landscape URL")
-check!(body.include?("showConfiguredLandscape") && body.include?("data-hero-landscape"),
-       "hero_landscape is the fallback when no entry has a landscape")
+check!(!body.include?("landscape") && !body.include?("matchMedia"),
+       "AC-HERO-08: one draw at every width, with no landscape field and no width switch")
 check!(runtime.include?("hydrateHeroPortrait();"),
        "hydratePageFragments must draw the plate before the later fragment chain")
 plate_call = runtime.index("function hydratePageFragments")
@@ -202,6 +206,8 @@ Dir.mktmpdir("hero-portraits") do |dir|
   payload = JSON.parse(exported.read)
   expected = HeroPortraits.entries(ROOT.join("content"))
   check!(payload == expected, "the exported list must be the hero folder, got #{payload.inspect}")
+  check!(payload.none? { |entry| entry.key?("landscape") },
+         "AC-HERO-08: the export writes no landscape field")
   srcs = payload.map { |entry| entry["src"] }
   check!(srcs == pool_names.map { |name| "/media/images/hero/#{name}" },
          "the export must name the four photographs, got #{srcs.inspect}")

data/scripts/test/test-home-lists.rb

@@ -76,6 +76,11 @@ fail!("probe ignores the phone viewport") unless probe.include?("name: 'mobile'"
 fail!("probe ignores the desktop viewport") unless probe.include?("name: 'desktop'")
 fail!("probe does not pin DevTools to IPv4") unless probe.include?("--remote-debugging-address=127.0.0.1")
 fail!("probe gives Chrome only a few seconds to open DevTools") unless probe.include?("attempt < 200")
+# PLT-AC-26: a Chrome that never opens DevTools (seen on the runner) gets a
+# second launch with a fresh profile and port, not a weaker list check.
+fail!("probe does not relaunch Chrome when DevTools stays closed") unless probe.include?("LAUNCH_ATTEMPTS = 2")
+launch = probe[/async function launchChrome\(.*?\n\}/m].to_s
+fail!("each launch must use a fresh profile and port") unless launch.include?("mkdtemp(") && launch.include?("freePort()")
 
 _out, err, status = Open3.capture3("node", "--check", ROOT.join("scripts/check_home_lists.mjs").to_s)
 fail!("home list probe is not valid JavaScript\n#{err}") unless status.success?

data/scripts/test/test-new.rb

@@ -23,8 +23,8 @@ end
 
 guide = ROOT.join("docs/getting-started.md").read
 readme = ROOT.join("README.md").read
-unless guide.include?('gem at `~> 1.3`')
-  warn "FAIL test-new: getting-started must document the scaffold pin ~> 1.3"
+unless guide.include?('gem at `~> 2.0`')
+  warn "FAIL test-new: getting-started must document the scaffold pin ~> 2.0"
   exit 1
 end
 if readme.include?("once 1.1 is on RubyGems")
@@ -51,8 +51,8 @@ scaffold = ROOT.join("lib/pandorga/commands/new.rb").read
     exit 1
   end
 end
-unless deploy.include?('~> 1.3') && deploy.include?(%(tag: "v#{version}"))
-  warn "FAIL test-new: deploy doc must pin ~> 1.3 and tag v#{version}"
+unless deploy.include?('~> 2.0') && deploy.include?(%(tag: "v#{version}"))
+  warn "FAIL test-new: deploy doc must pin ~> 2.0 and tag v#{version}"
   exit 1
 end
 unless deploy.include?("content/*") && deploy.include?("docs/*") && deploy.include?("Gemfile.lock")
@@ -108,8 +108,8 @@ end
 end
 
 gemfile = DEST.join("Gemfile").read
-unless gemfile.include?('gem "pandorga", "~> 1.3"')
-  warn "FAIL test-new: Gemfile must pin pandorga ~> 1.3\n#{gemfile}"
+unless gemfile.include?('gem "pandorga", "~> 2.0"')
+  warn "FAIL test-new: Gemfile must pin pandorga ~> 2.0\n#{gemfile}"
   exit 1
 end
 unless gemfile.include?("path:") && gemfile.include?("github:")

data/scripts/test/test-shell-a11y.rb

@@ -28,7 +28,8 @@ fail!("shell home link needs an identity.name fallback") unless SHELL.include?("
 fail!("footer home link needs an identity.name fallback") unless FOOTER.include?("site.pandorga.identity.name")
 
 fail!("top bar is still a nav") if SHELL.include?('<nav class="sticky')
-fail!("top bar is not a header") unless SHELL.include?('<header class="sticky top-0 z-50 bg-surface">')
+# PLT-AC-49: the header paints the translucent canvas through .site-topbar.
+fail!("top bar is not a header") unless SHELL.include?('<header class="site-topbar sticky top-0 z-50">')
 fail!("section links lost their name") unless SHELL.include?('aria-label="Sections"')
 navs = SHELL.scan(/<nav\b/).size
 fail!("shell should have one nav landmark, found #{navs}") unless navs == 1