pandorga 1.2.1

data/scripts/test/test-home-band-art.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Home band art (docs/features/home-band-art.md).
+#
+# AC-BAND-01 the export writes both plates under data/
+# AC-BAND-03 a second export with no content change reports them unchanged
+# AC-BAND-07 the layout carries no generated SVG markup
+# AC-BAND-08 the network plate prints the counts computed from the same corpus
+# AC-BAND-09 an entry joined to nothing leaves the plate's bar short of full width
+
+require "fileutils"
+require "json"
+require "open3"
+require "pathname"
+require "tmpdir"
+
+require_relative "../content/band_art"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+EXPORT = ROOT.join("scripts/content/export-content-json.rb")
+LAYOUT = ROOT.join("_layouts/home.html")
+INDEX_BAND = ROOT.join("_includes/home/band-index.html")
+EXAMPLE_CONTENT = ROOT.join("examples/full/content")
+
+def check!(condition, message = "condition was false")
+  raise "Assertion failed: #{message}" unless condition
+end
+
+puts "Testing home band art..."
+
+# ── The drawing, against a corpus small enough to count by hand ────────────
+
+index = [
+  { "key" => "a", "url" => "/articles/a/", "collection" => "articles", "date" => "2026-01-01",
+    "tags" => %w[Engineering Writing], "xcites" => [] },
+  { "key" => "b", "url" => "/articles/b/", "collection" => "articles", "date" => "2026-02-01",
+    "tags" => ["Engineering"], "xcites" => ["a"] },
+  { "key" => "c", "url" => "/posts/c/", "collection" => "posts", "date" => "2026-03-01",
+    "tags" => ["Writing"], "xcites" => %w[a a b] },
+  # Joined to nothing, so it is counted in the corpus and drawn nowhere.
+  { "key" => "d", "url" => "/posts/d/", "collection" => "posts", "date" => "2026-04-01",
+    "tags" => ["Solitude"], "xcites" => [] },
+  # Not writing: the plate's legend never names projects.
+  { "key" => "e", "url" => "/projects/e/", "collection" => "projects", "date" => "2026-05-01",
+    "tags" => ["Engineering"], "xcites" => ["a"] }
+]
+
+graph = BandArt.idea_graph(index)
+check! graph[:nodes].map { |node| node["key"] } == %w[a b c],
+       "unjoined and non-writing entries must stay out of the graph, got #{graph[:nodes].map { |n| n['key'] }}"
+check! graph[:corpus] == 4, "corpus counts every keyed article and post, got #{graph[:corpus]}"
+check! graph[:edges].length == 3, "c cites a twice and it counts once, got #{graph[:edges].length}"
+check! graph[:themes].map { |theme| theme[:name] } .sort == %w[Engineering Writing],
+       "a tag used once is not a theme, got #{graph[:themes].map { |t| t[:name] }}"
+
+resources = [
+  { "slug" => "one", "category" => "Academic", "type" => "youtube" },
+  { "slug" => "two", "category" => "Academic", "type" => "podcast" },
+  { "slug" => "three", "category" => "Music", "type" => "website" }
+]
+
+plates = BandArt.build(writing_index: index, resources: resources)
+check! plates.keys.sort == %w[network sources], "build draws both plates, got #{plates.keys}"
+
+# AC-BAND-08: the numbers are counted, not typed. The three numerals are the
+# drawing, so they are read out of the markup rather than out of a caption.
+network = plates["network"]
+numerals = network.scan(%r{class="home-index-metric"[^>]*>(\d+)<}).flatten
+check! numerals == %w[3 3 2], "the metric card must print the computed graph, got #{numerals.inspect}"
+check! network.include?(%(data-band-tally="3 of 4 pieces joined")),
+       "the caption must say how much of the corpus is joined, got #{network[%r{data-band-tally="[^"]*"}]}"
+check! network.include?(%(home-index-spine--articles" x="10" y="96" width="150")) &&
+       network.include?(%(home-index-spine--posts" x="160" y="96" width="75")),
+       "the spine scales to the corpus and stops short of the margin when a piece is unjoined, "        "got #{network.scan(%r{home-index-spine--\w+" x="[^"]*" y="[^"]*" width="[^"]*"})}"
+check! plates["sources"].include?('data-band-tally="3 sources · 2 collections"'),
+       "sources tally must restate the shelf, got #{plates['sources'][/data-band-tally="[^"]*"/]}"
+check! plates["sources"].include?(">Acad.<") && plates["sources"].include?(">Music<"),
+       "shelf labels must use the short forms, got #{plates['sources'].scan(%r{home-index-collection[^>]*>([^<]+)})}"
+
+# Nothing may be drawn in a colour the palette cannot repaint.
+plates.each do |name, svg|
+  check! !svg.match?(/#[0-9a-fA-F]{3,8}\b/), "#{name} plate carries a literal colour"
+  check! svg.start_with?("<svg "), "#{name} plate must be a standalone SVG document"
+  check! svg.include?('xmlns="http://www.w3.org/2000/svg"'), "#{name} plate needs the SVG namespace"
+end
+
+# AC-BAND-07: the layout may not hold generated markup any more.
+layout = LAYOUT.read
+check! !layout.include?("<svg"), "_layouts/home.html must not carry generated SVG"
+index_band = INDEX_BAND.read
+check! index_band.include?('data-content-band-art="sources"') ||
+         index_band.include?('data-content-band-art="{{ _art_key }}"'),
+       "the sources panel needs its mount point"
+check! index_band.include?("data-content-band-art"),
+       "the network panel needs its mount point"
+
+# ── The export, end to end ────────────────────────────────────────────────
+
+Dir.mktmpdir("band-art") do |dir|
+  out = Pathname.new(dir).join("export")
+  content_root = EXAMPLE_CONTENT.directory? ? EXAMPLE_CONTENT : ROOT.join("content")
+  env = {
+    "CONTENT_API_BASE_URL" => "",
+    "CONTENT_EXPORT_SKIP_VALIDATE" => "1",
+    "PANDORGA_SITE_ROOT" => (EXAMPLE_CONTENT.directory? ? ROOT.join("examples/full") : ROOT).to_s,
+    "RUBYOPT" => "-I#{ROOT.join('lib')}"
+  }
+  command = ["ruby", EXPORT.to_s, content_root.to_s, out.to_s]
+
+  first, status = Open3.capture2e(env, *command, chdir: env["PANDORGA_SITE_ROOT"])
+  check! status.success?, "first export failed:\n#{first}"
+
+  # AC-BAND-01
+  %w[band-art-sources.svg band-art-network.svg].each do |name|
+    path = out.join("data", name)
+    check! path.file?, "the export must write data/#{name}"
+    check! path.read.start_with?("<svg "), "data/#{name} must be an SVG document"
+  end
+
+  manifest = JSON.parse(out.join("manifest.json").read)
+  check! manifest["files"]["band_art"].sort == ["data/band-art-network.svg", "data/band-art-sources.svg"],
+         "the manifest must list both plates, got #{manifest['files']['band_art'].inspect}"
+
+  before = out.join("data", "band-art-sources.svg").read
+
+  # AC-BAND-03: a re-export must reuse the bytes, or every run churns R2.
+  second, status = Open3.capture2e(env, *command, chdir: env["PANDORGA_SITE_ROOT"])
+  check! status.success?, "second export failed:\n#{second}"
+  check! out.join("data", "band-art-sources.svg").read == before,
+         "a re-export with no content change rewrote the sources plate"
+  check! second.include?("band_art: 2"), "the export must report both plates:\n#{second}"
+end
+
+puts "Home band art OK."

data/scripts/test/test-install-functions.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Refs: PLT-0.2
+require "pathname"
+require "open3"
+require "fileutils"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+EXE = ROOT.join("exe/pandorga")
+DEST = ROOT.join("tmp/install-functions-test")
+
+FileUtils.rm_rf(DEST)
+DEST.mkpath
+env = { "RUBYOPT" => "-I#{ROOT.join('lib')}" }
+stdout, stderr, status = Open3.capture3(env, "ruby", EXE.to_s, "install-functions", DEST.to_s)
+unless status.success?
+  warn "FAIL test-install-functions: #{stdout}\n#{stderr}"
+  exit 1
+end
+
+api = DEST.join("functions/api/studio/[[path]].js")
+unless api.file?
+  warn "FAIL test-install-functions: functions not copied"
+  exit 1
+end
+stamp = DEST.join("functions/.pandorga-version")
+unless stamp.file? && stamp.read.match?(/\d+\.\d+\.\d+/)
+  warn "FAIL test-install-functions: version stamp missing"
+  exit 1
+end
+# Must not embed a default owner repo in the stub.
+body = api.read
+owner_slug = %w[alexandre lheinen].join
+if body.include?(owner_slug)
+  warn "FAIL test-install-functions: personal data in functions stub"
+  exit 1
+end
+
+puts "PASS test-install-functions"

data/scripts/test/test-language-export.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# The [EN]/[PT] pills read `language` off writing_index entries. The field has
+# always been in front matter, but was never exported, so listings had no way
+# to reach it. Guard both halves: the key is always present, and any value it
+# carries is one the UI knows how to render.
+
+require "json"
+require "pathname"
+require "yaml"
+require "date"
+
+REPO_ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+EXPORT_ROOT = REPO_ROOT.join("_content_json")
+CONTENT_ROOT = REPO_ROOT.join("content/collections")
+
+# Empty is allowed: an unset language renders no pill at all, which is the
+# correct behaviour for an item whose language was never declared.
+ALLOWED = ["", "enus", "ptbr"].freeze
+TAGGED_COLLECTIONS = %w[articles posts].freeze
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+def check!(condition, message)
+  fail!(message) unless condition
+end
+
+puts "Testing language export..."
+
+index_path = EXPORT_ROOT.join("data/writing_index.json")
+unless index_path.file?
+  puts "  skipped: no export at #{index_path.relative_path_from(REPO_ROOT)}"
+  exit 0
+end
+
+entries = JSON.parse(index_path.read)
+check!(entries.any?, "writing_index.json is empty")
+
+missing = entries.reject { |e| e.key?("language") }
+check!(missing.empty?,
+       "writing_index entries missing the language key: " \
+       "#{missing.take(3).map { |e| e['slug'] }.join(', ')}")
+
+bad = entries.reject { |e| ALLOWED.include?(e["language"].to_s) }
+check!(bad.empty?,
+       "unknown language values: " \
+       "#{bad.take(5).map { |e| "#{e['slug']}=#{e['language'].inspect}" }.join(', ')}")
+
+# Front matter is the source of truth; catch a value that exists on disk but
+# is dropped somewhere between parsing and the index.
+TAGGED_COLLECTIONS.each do |collection|
+  Dir.glob(CONTENT_ROOT.join(collection, "*.md")).sort.each do |path|
+    source = File.read(path)
+    next unless source.start_with?("---")
+
+    front_matter = YAML.safe_load(source.split(/^---\s*$/, 3)[1],
+                                  permitted_classes: [Date, Time]) || {}
+    next if front_matter["published"] == false
+
+    declared = front_matter["language"].to_s.strip
+    next if declared.empty?
+
+    slug = File.basename(path, ".md")
+    entry = entries.find { |e| e["slug"] == slug && e["collection"] == collection }
+    next if entry.nil?
+
+    check!(entry["language"].to_s == declared,
+           "#{collection}/#{slug}: front matter language #{declared.inspect} " \
+           "but index has #{entry['language'].inspect}")
+  end
+end
+
+declared_count = entries.count { |e| !e["language"].to_s.empty? }
+puts "  #{entries.size} entries, #{declared_count} with a declared language."
+puts "All language export tests passed."

data/scripts/test/test-listing-filter-contract.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Gate: every filter facet a page offers must be a facet the filter reads.
+#
+# ListingFilter keeps one state object. A chip group writes `state[group.key]`
+# on click; `filterItems` reads a fixed set of names. Nothing connects the
+# two, so renaming a facet in a layout — `category` to `tag`, say — leaves the
+# chips rendering, highlighting and pushing a query string while the list
+# beNewsreader them never changes. That shipped on the Sources page: every click set
+# a key nothing read.
+#
+# There is no build error and no console error to notice, so the contract is
+# checked here: chip-group keys against the state ListingFilter initialises
+# and the names filterItems actually consumes, plus the URL parameters a
+# layout can set against the ones syncUrl clears.
+
+require "pathname"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+FILTER = ROOT.join("_includes/content-runtime/42-listing-filter.html")
+LAYOUT_DIR = ROOT.join("_layouts")
+
+# A chip group is the only place a layout writes `key: '<literal>'` followed by
+# a label. Matching the pair keeps unrelated object literals out.
+CHIP_GROUP_KEY = /key:\s*(['"])(\w+)\1\s*,\s*(?:\/\*.*?\*\/\s*|\/\/[^\n]*\n\s*)*label:/m
+PARAM_OPTION = /(?:tagParam|categoryParam):\s*(['"])([\w-]+)\1/
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+def check!(condition, message)
+  fail!(message) unless condition
+end
+
+puts "Testing the listing filter facet contract..."
+
+source = FILTER.read
+
+state_block = source[/var state = \{(.*?)\n        \};/m, 1]
+check!(!state_block.nil?, "could not find the ListingFilter state object in #{FILTER}")
+state_keys = state_block.scan(/^\s*(\w+):/).flatten.uniq
+check!(state_keys.length >= 3, "only found state keys #{state_keys.inspect}; the regex has drifted")
+
+filter_items = source[/filterItems: function \(items, state, options\) \{(.*?)\n      \}\n    \};/m, 1]
+check!(!filter_items.nil?, "could not find ListingFilter.filterItems in #{FILTER}")
+read_keys = filter_items.scan(/\bstate\.(\w+)/).flatten.uniq
+check!(read_keys.length >= 3, "only found read keys #{read_keys.inspect}; the regex has drifted")
+
+sync_url = source[/function syncUrl\(\) \{(.*?)\n        \}/m, 1]
+check!(!sync_url.nil?, "could not find syncUrl in #{FILTER}")
+cleared_params = sync_url[/\[(.*?)\]\.forEach/m, 1].to_s.scan(/['"]([\w-]+)['"]/).flatten
+check!(cleared_params.any?, "syncUrl clears no query parameters; the regex has drifted")
+
+# Dead state is a facet waiting to happen: something can set it and nothing
+# will ever act on it.
+dead = state_keys - read_keys
+check!(
+  dead.empty?,
+  "ListingFilter initialises #{dead.inspect} but filterItems never reads " \
+  "#{dead.length == 1 ? 'it' : 'them'}. A chip group keyed on a dead name " \
+  "filters nothing."
+)
+
+groups = 0
+layouts_with_groups = []
+
+Dir.glob(LAYOUT_DIR.join("*.html")).sort.each do |path|
+  layout = Pathname.new(path)
+  body = layout.read
+  keys = body.scan(CHIP_GROUP_KEY).map { |_, key| key }
+  next if keys.empty?
+
+  layouts_with_groups << layout.basename.to_s
+  groups += keys.length
+
+  keys.uniq.each do |key|
+    check!(
+      state_keys.include?(key),
+      "#{layout.basename}: chip group keyed on '#{key}', which ListingFilter " \
+      "never initialises (it knows #{state_keys.sort.inspect}). Clicking a " \
+      "chip would set a key nothing reads."
+    )
+    check!(
+      read_keys.include?(key),
+      "#{layout.basename}: chip group keyed on '#{key}', which filterItems " \
+      "never reads (it consumes #{read_keys.sort.inspect}). The chips would " \
+      "highlight and the list would not move."
+    )
+  end
+
+  check!(
+    body.include?("ListingFilter.filterItems"),
+    "#{layout.basename} builds chip groups but never calls " \
+    "ListingFilter.filterItems, so no click can reach the list"
+  )
+
+  body.scan(PARAM_OPTION).each do |_, param|
+    check!(
+      cleared_params.include?(param),
+      "#{layout.basename} writes ?#{param}= but syncUrl never clears it " \
+      "(clears #{cleared_params.inspect}), so switching facets leaves a stale filter in the URL"
+    )
+  end
+end
+
+check!(
+  layouts_with_groups.length >= 3,
+  "only #{layouts_with_groups.inspect} declare chip groups; the redesign put a " \
+  "filter deck on every listing page, so the scan has probably stopped matching"
+)
+check!(groups >= 5, "only found #{groups} chip groups; the scan has probably stopped matching")
+
+puts "  state: #{state_keys.sort.join(', ')}"
+puts "  read by filterItems: #{read_keys.sort.join(', ')}"
+puts "  #{groups} chip group(s) across #{layouts_with_groups.join(', ')}"
+puts "All listing filter facet checks passed."

data/scripts/test/test-math-row-breaks.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Unit checks for display-math row-break normalization.
+ * See scripts/lib/normalize-display-math.mjs and docs/content/elements.md.
+ */
+import { normalizeDisplayMathTex, normalizeMathRegion } from '../lib/normalize-display-math.mjs';
+
+function assertEqual(actual, expected, label) {
+  if (actual !== expected) {
+    console.error(`FAIL: ${label}`);
+    console.error('  expected:', JSON.stringify(expected));
+    console.error('  actual:  ', JSON.stringify(actual));
+    process.exit(1);
+  }
+  console.log(`  ok: ${label}`);
+}
+
+console.log('Testing display-math row-break normalization...');
+
+const alignBroken = [
+  '\\begin{align}',
+  'p(x) &= \\int p(x,y)\\mathrm{d}y \\',
+  'p(y|x) &= \\frac{p(x,y)}{p(x)} \\',
+  'p(x|y) &= \\frac{p(y|x)p(x)}{p(y)}',
+  '\\end{align}',
+].join('\n');
+
+const alignFixed = [
+  '\\begin{align}',
+  'p(x) &= \\int p(x,y)\\mathrm{d}y \\\\',
+  'p(y|x) &= \\frac{p(x,y)}{p(x)} \\\\',
+  'p(x|y) &= \\frac{p(y|x)p(x)}{p(y)}',
+  '\\end{align}',
+].join('\n');
+
+assertEqual(
+  normalizeDisplayMathTex(alignBroken),
+  alignFixed,
+  'align trailing single backslash → \\\\'
+);
+
+assertEqual(
+  normalizeDisplayMathTex('\\begin{bmatrix}x-x_r\\ y-y_r\\end{bmatrix}'),
+  '\\begin{bmatrix}x-x_r\\\\ y-y_r\\end{bmatrix}',
+  'bmatrix mid-line \\ + space → \\\\'
+);
+
+const alignedOk = [
+  '\\begin{aligned}',
+  'a &= 1 \\\\',
+  'b &= 2',
+  '\\end{aligned}',
+].join('\n');
+
+assertEqual(
+  normalizeDisplayMathTex(alignedOk),
+  alignedOk,
+  'already-correct \\\\ left unchanged'
+);
+
+assertEqual(
+  normalizeDisplayMathTex('a = b\\,c\\;d'),
+  'a = b\\,c\\;d',
+  'spacing commands \\, and \\; untouched outside row envs'
+);
+
+assertEqual(
+  normalizeMathRegion('$$\\begin{align}a &= 1 \\ b &= 2\\end{align}$$'),
+  '$$\\begin{align}a &= 1 \\\\ b &= 2\\end{align}$$',
+  '$$ region wrapper preserved'
+);
+
+assertEqual(
+  normalizeMathRegion('$a\\\\b$'),
+  '$a\\\\b$',
+  'inline math not normalized'
+);
+
+console.log('All display-math row-break tests passed.');

data/scripts/test/test-math-row-breaks.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+SCRIPT = Pathname.new(__dir__).join("test-math-row-breaks.mjs")
+
+puts "Testing math row-break normalization..."
+stdout, stderr, status = Open3.capture3("node", SCRIPT.to_s, chdir: ROOT.join("scripts").to_s)
+unless status.success?
+  warn stderr
+  warn stdout
+  raise "math row-break tests failed"
+end
+puts stdout
+puts "All math row-break tests passed."

data/scripts/test/test-new.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Refs: PLT Phase 6 — pandorga new
+require "pathname"
+require "open3"
+require "fileutils"
+require "yaml"
+require "date"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+EXE = ROOT.join("exe/pandorga")
+DEST = ROOT.join("tmp/new-site-test")
+
+def run_new(*args)
+  env = { "RUBYOPT" => "-I#{ROOT.join('lib')}" }
+  Open3.capture3(env, "ruby", EXE.to_s, "new", *args)
+end
+
+def run_doctor(dir)
+  env = { "RUBYOPT" => "-I#{ROOT.join('lib')}" }
+  Open3.capture3(env, "ruby", EXE.to_s, "doctor", dir.to_s)
+end
+
+FileUtils.rm_rf(DEST)
+
+stdout, stderr, status = run_new(DEST.to_s)
+unless status.success?
+  warn "FAIL test-new: expected exit 0\n#{stdout}\n#{stderr}"
+  exit 1
+end
+unless stdout.include?("Created site at") && stdout.include?("bundle install")
+  warn "FAIL test-new: missing next-steps output\n#{stdout}"
+  exit 1
+end
+
+required = %w[
+  _config.yml
+  Gemfile
+  index.html
+  _redirects
+  content/pages/headers.yml
+  content/collections/articles/2026-01-01-hello.md
+  content/collections/articles/2026-01-02-second.md
+]
+required.each do |rel|
+  unless DEST.join(rel).file?
+    warn "FAIL test-new: missing #{rel}"
+    exit 1
+  end
+end
+
+%w[Gemfile.lock _site vendor .bundle _content_json .jekyll-cache].each do |name|
+  if DEST.join(name).exist?
+    warn "FAIL test-new: should exclude #{name}"
+    exit 1
+  end
+end
+
+gemfile = DEST.join("Gemfile").read
+unless gemfile.include?('gem "pandorga", "~> 1.2"')
+  warn "FAIL test-new: Gemfile must pin pandorga ~> 1.2\n#{gemfile}"
+  exit 1
+end
+unless gemfile.include?("path:") && gemfile.include?("github:")
+  warn "FAIL test-new: Gemfile should comment path/github fallbacks"
+  exit 1
+end
+
+config = YAML.safe_load(DEST.join("_config.yml").read, permitted_classes: [Date]) || {}
+pandorga = config["pandorga"]
+unless pandorga.is_a?(Hash)
+  warn "FAIL test-new: missing pandorga: in _config.yml"
+  exit 1
+end
+identity = pandorga["identity"]
+unless identity.is_a?(Hash) && identity["name"].to_s == "Ada Example"
+  warn "FAIL test-new: expected Ada Example identity"
+  exit 1
+end
+backend = pandorga.dig("content", "backend")
+unless backend == "static"
+  warn "FAIL test-new: expected content.backend: static, got #{backend.inspect}"
+  exit 1
+end
+pages = pandorga["pages"]
+unless pages.is_a?(Array) && pages.any?
+  warn "FAIL test-new: expected pandorga.pages entries"
+  exit 1
+end
+
+dout, derr, dstatus = run_doctor(DEST)
+unless dstatus.success? && dout.include?("pandorga doctor: ok")
+  warn "FAIL test-new: doctor failed on scaffold\n#{dout}\n#{derr}"
+  exit 1
+end
+
+_out, err, st = run_new(DEST.to_s)
+if st.success?
+  warn "FAIL test-new: expected failure without --force on nonempty dir"
+  exit 1
+end
+unless err.include?("--force")
+  warn "FAIL test-new: expected --force hint\n#{err}"
+  exit 1
+end
+
+stdout2, stderr2, status2 = run_new(DEST.to_s, "--force")
+unless status2.success?
+  warn "FAIL test-new: --force should succeed\n#{stdout2}\n#{stderr2}"
+  exit 1
+end
+
+puts "PASS test-new"

data/scripts/test/test-no-personal-data.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Refs: PLT-AC-1
+require "pathname"
+require "find"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+
+# Public repo home (ADR-001) may appear as a URL or Bundler github: source.
+REPO_URL_OK = %r{(?:github\.com/)?alexandrelheinen/pandorga}
+
+PATTERNS = [
+  [/pub-[0-9a-f]{32}\.r2\.dev/i, "r2 bucket URL"],
+  [/pk_live_[A-Za-z0-9_-]{16,}/, "live publishable key"],
+  [/sk_live_[A-Za-z0-9_-]{16,}/, "live secret key"],
+  [/github_pat_[A-Za-z0-9_]+/, "github pat"],
+  [/Alexandre L\. Heinen/, "owner short name"],
+  [/Alexandre Loeblein Heinen/, "owner full name"],
+  [/alexandrelheinen\.pages\.dev/i, "pages domain"],
+  [/dev\.alexandrelheinen\.studio/i, "android applicationId"]
+].freeze
+
+SKIP_DIRS = %w[
+  .git
+  tmp
+  _site
+  _content_json
+  vendor
+  .bundle
+  node_modules
+  .guidelines
+  .agents
+].freeze
+
+# Migration spec documents the extraction source; .gitmodules points at the
+# owner's private guidelines repo (not shipped as platform code).
+ALLOW_REL = %w[
+  docs/spec.md
+  docs/decisions.md
+  .gitmodules
+].freeze
+
+failures = []
+Find.find(ROOT) do |path|
+  path = Pathname.new(path)
+  if path.directory?
+    Find.prune if SKIP_DIRS.include?(path.basename.to_s)
+    next
+  end
+  next unless path.file?
+  next if path.basename.to_s == "test-no-personal-data.rb"
+  next if path.extname.match?(/\.(png|jpe?g|gif|webp|ico|woff2?|ttf|eot|pdf|zip|gz|wasm)$/i)
+
+  rel = path.relative_path_from(ROOT).to_s
+  next if ALLOW_REL.include?(rel)
+
+  raw = begin
+    path.read(mode: "rb")
+  rescue StandardError
+    next
+  end
+  next if raw.include?("\x00")
+
+  text = raw.force_encoding("UTF-8")
+  next unless text.valid_encoding?
+
+  # Strip allowed repo URLs before scanning for the owner slug.
+  scrubbed = text.encode("UTF-8", invalid: :replace, undef: :replace).gsub(REPO_URL_OK, "")
+  if scrubbed.match?(/alexandrelheinen/i)
+    failures << "#{rel}: owner slug outside allowed repo URL"
+  end
+
+  PATTERNS.each do |re, label|
+    next unless text.match?(re)
+
+    failures << "#{rel}: #{label}"
+  end
+end
+
+if failures.any?
+  warn "FAIL test-no-personal-data:\n#{failures.uniq.join("\n")}"
+  exit 1
+end
+
+puts "PASS test-no-personal-data"