pandorga 1.2.1

data/scripts/content/flatten-ansi-capture.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+// flatten-ansi-capture.mjs — turn a terminal capture into an ```ansi fence.
+//
+// An `ansi` fence is rendered by _includes/content-runtime/25-code-blocks.html,
+// which honours SGR colour and nothing else. Real captures are not that clean:
+// anything that paints columns does it by moving the cursor, and neofetch in
+// particular draws its whole info block by jumping up twenty rows and right
+// forty-three columns for every line. Pasted as-is, the result is one column of
+// overstruck text.
+//
+// So the moves are played out here, onto a character grid, and the result is
+// re-emitted as ordinary lines that carry colour and nothing else. What the
+// fence stores is then what a reader sees.
+//
+// Usage:
+//   script -qec "neofetch" /dev/null > capture.txt
+//   node scripts/content/flatten-ansi-capture.mjs capture.txt > block.txt
+//
+// `script` is what makes the capture worth taking: neofetch, like most tools,
+// drops its colour when stdout is not a terminal, and `script` gives it a pty
+// to write to. Paste the output between ```ansi fences.
+//
+// --raw emits the 0x1b control byte instead of the printable `\e[` spelling.
+// The default is the printable form, because that is what survives an editor,
+// a JSON export and a diff; the renderer reads both.
+
+import fs from 'node:fs';
+
+const ESC = String.fromCharCode(27);
+
+/* SGR is accumulated rather than replaced. Tools write the attributes of one
+   run as several sequences in a row — neofetch's logo is `\e[0m\e[31m\e[1m` —
+   so treating each `m` as the whole state throws away every colour. */
+function makeAttr() {
+  return { fg: null, bg: null, bold: false };
+}
+
+function applySgr(attr, params) {
+  const codes = params === '' ? ['0'] : params.split(';');
+  for (let i = 0; i < codes.length; i++) {
+    const n = parseInt(codes[i], 10);
+    if (Number.isNaN(n) || n === 0) { attr.fg = null; attr.bg = null; attr.bold = false; }
+    else if (n === 1) attr.bold = true;
+    else if (n === 22) attr.bold = false;
+    else if (n === 39) attr.fg = null;
+    else if (n === 49) attr.bg = null;
+    else if ((n >= 30 && n <= 37) || (n >= 90 && n <= 97)) attr.fg = String(n);
+    else if ((n >= 40 && n <= 47) || (n >= 100 && n <= 107)) attr.bg = String(n);
+    else if (n === 38 || n === 48) {
+      const target = n === 38 ? 'fg' : 'bg';
+      if (codes[i + 1] === '5') { attr[target] = `${n};5;${codes[i + 2]}`; i += 2; }
+      else if (codes[i + 1] === '2') {
+        attr[target] = `${n};2;${codes[i + 2]};${codes[i + 3]};${codes[i + 4]}`;
+        i += 4;
+      }
+    }
+  }
+}
+
+function sgrOf(attr) {
+  const parts = [];
+  if (attr.bold) parts.push('1');
+  if (attr.fg) parts.push(attr.fg);
+  if (attr.bg) parts.push(attr.bg);
+  return parts.join(';');
+}
+
+export function flattenAnsi(input) {
+  const grid = [];
+  let row = 0;
+  let col = 0;
+  const attr = makeAttr();
+
+  const cell = (r, c) => {
+    while (grid.length <= r) grid.push([]);
+    const line = grid[r];
+    while (line.length <= c) line.push({ ch: ' ', sgr: '', bg: false });
+    return line[c];
+  };
+
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === ESC && input[i + 1] === '[') {
+      const m = /^\x1b\[([0-9;?]*)([A-Za-z])/.exec(input.slice(i));
+      if (m) {
+        const [, params, final] = m;
+        const n = parseInt(params, 10) || 1;
+        // `?` params belong to the private mode sequences (cursor hide, wrap
+        // off) that every capture opens and closes with. Nothing to draw.
+        if (final === 'm') applySgr(attr, params.replace(/\?/g, ''));
+        else if (final === 'A') row = Math.max(0, row - n);
+        else if (final === 'B') row += n;
+        else if (final === 'C') col += n;
+        else if (final === 'D') col = Math.max(0, col - n);
+        else if (final === 'G') col = Math.max(0, n - 1);
+        i += m[0].length - 1;
+        continue;
+      }
+    }
+    if (ch === '\n') { row++; col = 0; continue; }
+    if (ch === '\r') { col = 0; continue; }
+    if (ch === ESC || ch < ' ') continue;
+    const target = cell(row, col);
+    target.ch = ch;
+    target.sgr = sgrOf(attr);
+    target.bg = attr.bg != null;
+    col++;
+  }
+
+  const lines = grid.map((line) => {
+    // Trailing blanks are padding unless they carry a background colour, which
+    // is how the palette strips at the foot of a neofetch block are drawn.
+    let last = -1;
+    for (let i = 0; i < line.length; i++) if (line[i].ch !== ' ' || line[i].bg) last = i;
+    let text = '';
+    let active = '';
+    for (let i = 0; i <= last; i++) {
+      const c = line[i];
+      // A plain space shows no attribute of its own, so it stays inside the
+      // run it sits in rather than forcing a reset mid-line.
+      const want = c.ch === ' ' && !c.bg ? active : c.sgr;
+      // Every run states its attributes absolutely, leading with the reset.
+      // SGR is additive, so `\e[1m` after a red run is *bold red*, not bold
+      // default — and that is exactly the pair neofetch's logo alternates
+      // between. Emitting the difference would silently repaint the white
+      // letters of the Ubuntu mark in red.
+      if (want !== active) { text += `${ESC}[${want ? `0;${want}` : '0'}m`; active = want; }
+      text += c.ch;
+    }
+    if (active) text += `${ESC}[0m`;
+    return text;
+  });
+
+  while (lines.length && lines[lines.length - 1].replace(/\x1b\[[0-9;]*m/g, '').trim() === '') {
+    lines.pop();
+  }
+  return lines.join('\n');
+}
+
+const args = process.argv.slice(2);
+const raw = args.includes('--raw');
+const source = args.filter((a) => !a.startsWith('--'))[0];
+
+if (!source) {
+  console.error('usage: flatten-ansi-capture.mjs <capture.txt> [--raw]');
+  process.exit(2);
+}
+
+// latin1 throughout: a capture is a byte stream, and decoding it as UTF-8
+// would fold the box-drawing bytes some logos use into replacement characters.
+const flattened = flattenAnsi(fs.readFileSync(source, 'latin1'));
+const out = raw ? flattened : flattened.split(ESC + '[').join('\\e[');
+process.stdout.write(Buffer.from(out + '\n', 'latin1'));

data/scripts/content/hero_portraits.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# The home hero pool is the folder. The content export writes the public
+# paths to pages/home/portraits.json. The author uploads a photograph under
+# content/media/images/hero/ and does not keep a second list.
+
+require "pathname"
+
+module HeroPortraits
+  IMAGE_EXTENSIONS = %w[.jpg .jpeg .png .webp .gif].freeze
+
+  module_function
+
+  def entries(content_root)
+    image_files(Pathname.new(content_root)).map do |file|
+      { "src" => "/media/images/hero/#{file.basename}" }
+    end
+  end
+
+  def image_files(root)
+    dir = root.join("media/images/hero")
+    return [] unless dir.directory?
+
+    dir.children.select do |path|
+      path.file? && IMAGE_EXTENSIONS.include?(path.extname.downcase)
+    end.sort_by { |path| path.basename.to_s }
+  end
+end

data/scripts/content/publish-content-to-object-store.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# Publish exported editorial JSON and media to an S3-compatible bucket.
+# Accepts S3_* or legacy R2_* environment variables.
+# Used by `pandorga publish` and CI content pipelines.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+SITE_ROOT="${PANDORGA_SITE_ROOT:-$ROOT}"
+EXPORT_ROOT="${1:-$SITE_ROOT/_content_json}"
+
+# Prefer S3_* names; fall back to R2_* for Cloudflare R2 callers.
+S3_ENDPOINT="${S3_ENDPOINT:-${R2_ENDPOINT:-}}"
+S3_BUCKET="${S3_BUCKET:-${R2_BUCKET:-}}"
+S3_ACCESS_KEY_ID="${S3_ACCESS_KEY_ID:-${R2_ACCESS_KEY_ID:-}}"
+S3_SECRET_ACCESS_KEY="${S3_SECRET_ACCESS_KEY:-${R2_SECRET_ACCESS_KEY:-}}"
+S3_REGION="${S3_REGION:-${R2_REGION:-auto}}"
+
+: "${S3_ENDPOINT:?Set S3_ENDPOINT or R2_ENDPOINT (S3-compatible API URL)}"
+: "${S3_BUCKET:?Set S3_BUCKET or R2_BUCKET}"
+: "${S3_ACCESS_KEY_ID:?Set S3_ACCESS_KEY_ID or R2_ACCESS_KEY_ID}"
+: "${S3_SECRET_ACCESS_KEY:?Set S3_SECRET_ACCESS_KEY or R2_SECRET_ACCESS_KEY}"
+
+export AWS_ACCESS_KEY_ID="$S3_ACCESS_KEY_ID"
+export AWS_SECRET_ACCESS_KEY="$S3_SECRET_ACCESS_KEY"
+export AWS_DEFAULT_REGION="$S3_REGION"
+
+# Keep sync helper (still reads R2_* names) working.
+export R2_ENDPOINT="$S3_ENDPOINT"
+export R2_BUCKET="$S3_BUCKET"
+export R2_ACCESS_KEY_ID="$S3_ACCESS_KEY_ID"
+export R2_SECRET_ACCESS_KEY="$S3_SECRET_ACCESS_KEY"
+export R2_REGION="$S3_REGION"
+
+if ! command -v aws >/dev/null 2>&1; then
+  echo "aws CLI is required for object-store publish." >&2
+  exit 1
+fi
+
+run_ruby() {
+  if command -v mise >/dev/null 2>&1; then
+    mise exec -- ruby "$@"
+  else
+    ruby "$@"
+  fi
+}
+
+sync_json_prefix() {
+  local prefix="$1"
+  local src="$EXPORT_ROOT/$prefix"
+  if [ -d "$src" ]; then
+    echo "==> Object store replace sync $prefix/"
+    run_ruby "$ROOT/scripts/content/sync-content-json-to-r2.rb" "$EXPORT_ROOT" "$prefix"
+  fi
+}
+
+echo "==> Publishing content JSON to bucket: ${S3_BUCKET}"
+echo "==> Endpoint: ${S3_ENDPOINT}"
+sync_json_prefix collections
+sync_json_prefix data
+sync_json_prefix pages
+
+echo "==> Upload manifest.json"
+aws s3 cp "$EXPORT_ROOT/manifest.json" "s3://${S3_BUCKET}/manifest.json" \
+  --endpoint-url "$S3_ENDPOINT" \
+  --cache-control "public,max-age=60" \
+  --content-type "application/json"
+
+MEDIA_ROOT="$SITE_ROOT/content/media"
+if [ -d "$MEDIA_ROOT" ]; then
+  echo "==> Sync media/"
+  aws s3 sync "$MEDIA_ROOT" "s3://${S3_BUCKET}/media" \
+    --endpoint-url "$S3_ENDPOINT" \
+    --delete \
+    --size-only \
+    --cache-control "public,max-age=31536000,immutable"
+fi
+
+echo "==> Object-store publish complete"

data/scripts/content/publish-content-to-r2.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Compatibility wrapper — prefer publish-content-to-object-store.sh (S3_* or R2_*).
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec bash "$ROOT/publish-content-to-object-store.sh" "$@"

data/scripts/content/sync-content-json-to-r2.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Incremental JSON prefix sync to Cloudflare R2.
+# Skip aws s3 cp when list-objects-v2 ETag is a single-part MD5 equal to the
+# local file (case-insensitive). Upload if missing, ETag blank, multipart
+# ("-" in ETag), or hash mismatch. Delete remote keys absent locally.
+# Stale bodies cannot survive: mismatch still uploads and extras still delete.
+# writing_index.json is always PUT so listings match the live object set.
+#
+# Usage:
+#   sync-content-json-to-r2.rb <export_root> <prefix>
+# Example:
+#   sync-content-json-to-r2.rb _content_json collections
+
+require "digest"
+require "json"
+require "open3"
+require "pathname"
+require "set"
+
+require_relative "../lib/r2_json_sync"
+require_relative "../lib/withdrawn_public_objects"
+
+$stdout.sync = true
+$stderr.sync = true
+
+EXPORT_ROOT = Pathname.new(ARGV[0] || "_content_json").expand_path
+PREFIX = (ARGV[1] || "").sub(%r{\A/+}, "").sub(%r{/+\z}, "")
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+fail!("Usage: #{$PROGRAM_NAME} <export_root> <prefix>") if PREFIX.empty?
+
+endpoint = ENV["R2_ENDPOINT"].to_s
+bucket = ENV["R2_BUCKET"].to_s
+fail!("R2_ENDPOINT is required") if endpoint.empty?
+fail!("R2_BUCKET is required") if bucket.empty?
+fail!("aws CLI is required") if Open3.capture3("bash", "-lc", "command -v aws").last.exitstatus != 0
+
+SRC = EXPORT_ROOT.join(PREFIX)
+fail!("Missing local prefix directory: #{SRC}") unless SRC.directory?
+
+CACHE_CONTROL = "public,max-age=60"
+
+# The export is mostly JSON, and was entirely JSON until the home band plates
+# started shipping as drawings. Serving an SVG as application/json costs nothing
+# for a fetch that reads it as text, and everything for anything that does not.
+CONTENT_TYPES = {
+  ".json" => "application/json",
+  ".svg" => "image/svg+xml"
+}.freeze
+
+def content_type_for(path)
+  CONTENT_TYPES.fetch(path.extname.downcase) do
+    fail!("no content type registered for #{path.extname} (#{path}); add one to CONTENT_TYPES")
+  end
+end
+
+def run_aws(*args)
+  cmd = ["aws", *args, "--endpoint-url", ENV.fetch("R2_ENDPOINT")]
+  stdout, stderr, status = Open3.capture3(
+    {
+      "AWS_ACCESS_KEY_ID" => ENV.fetch("R2_ACCESS_KEY_ID"),
+      "AWS_SECRET_ACCESS_KEY" => ENV.fetch("R2_SECRET_ACCESS_KEY"),
+      "AWS_DEFAULT_REGION" => ENV.fetch("R2_REGION", "auto")
+    },
+    *cmd
+  )
+  [stdout, stderr, status]
+end
+
+def list_remote_objects(prefix)
+  etags = {}
+  token = nil
+  loop do
+    args = [
+      "s3api", "list-objects-v2",
+      "--bucket", ENV.fetch("R2_BUCKET"),
+      "--prefix", "#{prefix}/",
+      "--output", "json"
+    ]
+    args += ["--continuation-token", token] if token
+    stdout, stderr, status = run_aws(*args)
+    fail!("list-objects-v2 failed for #{prefix}/: #{stderr}") unless status.success?
+
+    payload = stdout.strip.empty? ? {} : JSON.parse(stdout)
+    etags.merge!(R2JsonSync.contents_to_etags(payload["Contents"]))
+    break unless payload["IsTruncated"]
+
+    token = payload["NextContinuationToken"]
+    fail!("list-objects-v2 truncated without continuation token") if token.to_s.empty?
+  end
+  etags
+end
+
+def local_md5(path)
+  Digest::MD5.hexdigest(path.binread)
+end
+
+local_files = SRC.find.select(&:file?).map do |path|
+  rel = path.relative_path_from(SRC).to_s
+  key = "#{PREFIX}/#{rel}"
+  [path, key, local_md5(path)]
+end
+
+remote_etags = list_remote_objects(PREFIX)
+plan = R2JsonSync.plan(
+  local_files.map { |(_path, key, md5)| { "key" => key, "md5" => md5 } },
+  remote_etags
+)
+upload_keys = plan["upload"].to_set
+
+uploaded = 0
+local_files.each do |path, key, _md5|
+  next unless upload_keys.include?(key)
+
+  _stdout, stderr, status = run_aws(
+    "s3", "cp", path.to_s, "s3://#{ENV.fetch('R2_BUCKET')}/#{key}",
+    "--cache-control", CACHE_CONTROL,
+    "--content-type", content_type_for(path)
+  )
+  fail!("upload failed for #{key}: #{stderr}") unless status.success?
+
+  uploaded += 1
+end
+
+deleted = 0
+plan["delete"].each do |key|
+  _stdout, stderr, status = run_aws(
+    "s3", "rm", "s3://#{ENV.fetch('R2_BUCKET')}/#{key}"
+  )
+  fail!("delete failed for #{key}: #{stderr}") unless status.success?
+
+  deleted += 1
+end
+
+skipped = plan["skip"].length
+local_keys = local_files.map { |(_, key, _)| key }.to_set
+
+remote_after = list_remote_objects(PREFIX)
+extra = (remote_after.keys.to_set - local_keys).to_a.sort
+missing = (local_keys - remote_after.keys.to_set).to_a.sort
+unless extra.empty? && missing.empty?
+  fail!("R2 keyset drift for #{PREFIX}/ extra=#{extra.inspect} missing=#{missing.inspect}")
+end
+
+local_files.each do |_path, key, md5|
+  etag = remote_after[key].to_s
+  next if R2JsonSync.multipart_etag?(etag)
+
+  unless etag.casecmp?(md5)
+    fail!("R2 origin mismatch for #{key}: etag=#{etag.inspect} md5=#{md5.inspect}")
+  end
+end
+
+WithdrawnPublicObjects::EXPORT_PATHS.each do |relative|
+  next unless relative.start_with?("#{PREFIX}/")
+  next unless remote_after.key?(relative)
+
+  fail!("withdrawn object still present on R2: #{relative}")
+end
+
+puts "R2 replace sync #{PREFIX}/: uploaded=#{uploaded} skipped=#{skipped} deleted=#{deleted}"

data/scripts/content/sync-content-redirects.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+require_relative "../../_plugins/content_keys"
+
+REPO_ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+
+ContentKeys.validate!(REPO_ROOT)
+ContentKeys.sync_redirects_file!(REPO_ROOT)
+puts "Content redirects synced to #{REPO_ROOT.join('_redirects')}"

data/scripts/generate-configuration-doc.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Regenerate docs/configuration.md from lib/pandorga/registry/schema.yml.
+# Refs: PLT-AC-11
+
+require "pathname"
+require "yaml"
+
+ROOT = Pathname.new(__dir__).join("..").expand_path
+SCHEMA_PATH = ROOT.join("lib/pandorga/registry/schema.yml")
+DOC_PATH = ROOT.join("docs/configuration.md")
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+def required_cell(value)
+  case value
+  when true then "yes"
+  when false then "no"
+  when nil then ""
+  else value.to_s
+  end
+end
+
+def render_keys_table(keys, include_required:)
+  lines = []
+  if include_required
+    lines << "| Key | Type | Required | Notes |"
+    lines << "|---|---|---|---|"
+  else
+    lines << "| Key | Type | Notes |"
+    lines << "|---|---|---|"
+  end
+
+  keys.each do |key, meta|
+    meta = {} unless meta.is_a?(Hash)
+    label = meta["key_label"] || key
+    type = meta["type"].to_s
+    notes = meta["notes"].to_s
+    if include_required
+      lines << "| `#{label}` | #{type} | #{required_cell(meta['required'])} | #{notes} |"
+    else
+      lines << "| `#{label}` | #{type} | #{notes} |"
+    end
+  end
+  lines.join("\n")
+end
+
+def render_home_attributes(entries)
+  lines = ["| Key | Notes |", "|---|---|"]
+  entries.each do |entry|
+    entry = {} unless entry.is_a?(Hash)
+    lines << "| #{entry['key']} | #{entry['notes']} |"
+  end
+  lines.join("\n")
+end
+
+def generate(schema)
+  out = []
+  out << "# Configuration reference"
+  out << ""
+  out << "Generated from `lib/pandorga/registry/schema.yml`. Gate: keep in sync"
+  out << "via `scripts/generate-configuration-doc.rb` (`PLT-AC-11`)."
+  out << ""
+
+  %w[identity content home].each do |section|
+    data = schema.fetch(section)
+    out << "## #{data.fetch('title')}"
+    out << ""
+    include_required = section == "identity"
+    out << render_keys_table(data.fetch("keys"), include_required: include_required)
+    out << ""
+    intro = data["intro"].to_s.strip
+    unless intro.empty?
+      out << intro
+      out << ""
+    end
+  end
+
+  tax = schema.fetch("taxonomies")
+  out << "## #{tax.fetch('title')}"
+  out << ""
+  out << tax.fetch("prose").to_s.strip
+  out << ""
+
+  pages = schema.fetch("pages")
+  out << "## #{pages.fetch('title')}"
+  out << ""
+  out << render_keys_table(pages.fetch("keys"), include_required: true)
+  out << ""
+  footer = pages["footer"].to_s.strip
+  out << footer unless footer.empty?
+  out << ""
+
+  home_attrs = pages.fetch("home_attributes")
+  out << "### #{home_attrs.fetch('title')}"
+  out << ""
+  out << render_home_attributes(home_attrs.fetch("entries"))
+  out << ""
+
+  "#{out.join("\n").rstrip}\n"
+end
+
+schema = YAML.safe_load(SCHEMA_PATH.read)
+fail!("schema missing or empty: #{SCHEMA_PATH}") unless schema.is_a?(Hash)
+
+text = generate(schema)
+
+if ARGV.include?("--check")
+  unless DOC_PATH.file? && DOC_PATH.read == text
+    warn "FAIL: docs/configuration.md is stale; run scripts/generate-configuration-doc.rb"
+    exit 1
+  end
+  puts "OK docs/configuration.md matches schema"
+  exit 0
+end
+
+if ARGV.include?("--stdout")
+  print text
+  exit 0
+end
+
+DOC_PATH.write(text)
+puts "Wrote #{DOC_PATH.relative_path_from(ROOT)}"

data/scripts/lib/content_license.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+# Shared editorial license metadata (_config.yml → content_license).
+module ContentLicense
+  # No default rights_holder — sites must set content_license.rights_holder.
+  DEFAULTS = {
+    "id" => "CC-BY-4.0",
+    "name" => "Creative Commons Attribution 4.0 International",
+    "url" => "https://creativecommons.org/licenses/by/4.0/",
+    "page_path" => "/pages/license/"
+  }.freeze
+
+  SOFTWARE = {
+    "id" => "MIT",
+    "name" => "MIT License",
+    "url" => "https://opensource.org/licenses/MIT",
+    "file" => "LICENSE"
+  }.freeze
+
+  EDITORIAL_TYPES = %w[article post product project job resource].freeze
+
+  module_function
+
+  def load(repo_root = Pathname.new(__dir__).join("..", "..").expand_path)
+    config_path = repo_root.join("_config.yml")
+    return DEFAULTS.dup unless config_path.file?
+
+    config = YAML.safe_load(config_path.read) || {}
+    raw = config["content_license"]
+    return DEFAULTS.dup unless raw.is_a?(Hash)
+
+    DEFAULTS.merge(raw.transform_keys(&:to_s))
+  end
+
+  def payload(license = load)
+    license.slice("id", "name", "url", "rights_holder", "page_path")
+  end
+
+  def copyright_notice(license = load, year: Time.now.utc.year)
+    holder = license["rights_holder"] || DEFAULTS["rights_holder"]
+    "© #{year} #{holder}"
+  end
+
+  def editorial?(type)
+    EDITORIAL_TYPES.include?(type)
+  end
+end

data/scripts/lib/content_storage_config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+
+# Shared reader for the public content store base URL.
+# Prefers pandorga.content.base_url; falls back to content_api_base_url.
+module ContentStorageConfig
+  PLACEHOLDER_MARKERS = [
+    "__R2_PUBLIC_BASE_URL__",
+    "REPLACE_WITH_R2_PUBLIC_BASE_URL",
+    "__S3_PUBLIC_BASE_URL__",
+    "REPLACE_WITH_S3_PUBLIC_BASE_URL"
+  ].freeze
+  LEGACY_GCS_HOST = "storage.googleapis.com"
+
+  module_function
+
+  def repo_root
+    Pathname.new(__dir__).join("..", "..").expand_path
+  end
+
+  def config_path
+    repo_root.join("_config.yml")
+  end
+
+  def load_config
+    YAML.safe_load(config_path.read, aliases: true) || {}
+  rescue Errno::ENOENT
+    {}
+  end
+
+  def base_url
+    env = ENV["S3_PUBLIC_BASE_URL"].to_s.strip
+    env = ENV["R2_PUBLIC_BASE_URL"].to_s.strip if env.empty?
+    env = ENV["CONTENT_API_BASE_URL"].to_s.strip if env.empty?
+    unless env.empty?
+      return env.chomp("/")
+    end
+
+    config = load_config
+    begin
+      require "pandorga/registry"
+      url = PandorgaRegistry.content_base_url(config)
+      return url unless url.empty?
+    rescue LoadError
+      # CLI gates may run without the gem on LOAD_PATH.
+    end
+
+    url = config["content_api_base_url"].to_s.strip
+    url.empty? ? nil : url.chomp("/")
+  end
+
+  def placeholder?(url = base_url)
+    return true if url.nil? || url.empty?
+
+    PLACEHOLDER_MARKERS.any? { |marker| url.include?(marker) }
+  end
+
+  def legacy_gcs?(url = base_url)
+    return false if url.nil? || url.empty?
+
+    url.include?(LEGACY_GCS_HOST)
+  end
+
+  def configured_for_live_checks?
+    url = base_url
+    !url.nil? && !url.empty? && !placeholder?(url) && !legacy_gcs?(url)
+  end
+end