src/flat-html-generator.lua

7local function setup_dir_path(provided_dir)

8 if provided_dir then

9 return provided_dir

10 end

11 return "/mnt/mtwo/programming/ai-stuff/neocities-modernization"

117local FONT_STYLE = [[

118<style>

119body, pre {

120 font-family: 'Hack Nerd Font', 'Hack', 'Fira Code', 'JetBrains Mono',

121 'Cascadia Code', 'Consolas', 'Monaco', 'Liberation Mono',

122 'Courier New', monospace;

123}

124/* True page-centering for the poem column. The old <table align="center">

125 shrink-wrapped to its WIDEST line -- and an attached image (up to 800px) is

126 wider than the ~84-char text frame, so the cell stretched and the frames

127 hugged the left of that wide cell, landing the whole column left-of-center.

128 Fix: the cell centers its children, each <pre> is an inline-block that

129 centers as a block (text stays left-aligned inside), and media centers via

130 auto margins. Now a vertical line down the page bisects every poem AND image,

131 regardless of how wide any single image is. */

132td { text-align: center; }

133pre { display: inline-block; text-align: left; margin: 0 auto; }

134img, video, audio { margin-left: auto; margin-right: auto; }

135</style>

136]]

200local function load_layout_from_config()

201 local layout = unified_config.layout

202 if not layout then return end

204 -- Override LAYOUT values from config

205 if layout.regular_poem_width then LAYOUT.REGULAR_POEM_WIDTH = layout.regular_poem_width end

206 if layout.golden_poem_width then LAYOUT.GOLDEN_POEM_WIDTH = layout.golden_poem_width end

207 if layout.text_content_width then LAYOUT.TEXT_CONTENT_WIDTH = layout.text_content_width end

208 if layout.left_box_width then

209 LAYOUT.REGULAR_LEFT_BOX_WIDTH = layout.left_box_width

210 LAYOUT.GOLDEN_LEFT_BOX_WIDTH = layout.left_box_width

211 end

212 if layout.right_box_width then

213 LAYOUT.REGULAR_RIGHT_BOX_WIDTH = layout.right_box_width

214 LAYOUT.GOLDEN_RIGHT_BOX_WIDTH = layout.right_box_width

215 end

216 if layout.gap_width then

217 LAYOUT.REGULAR_GAP_WIDTH = layout.gap_width

218 LAYOUT.GOLDEN_GAP_WIDTH = layout.gap_width

219 end

220 if layout.left_junction_pos then LAYOUT.REGULAR_LEFT_JUNCTION_POS = layout.left_junction_pos end

221 if layout.right_junction_pos then LAYOUT.REGULAR_RIGHT_JUNCTION_POS = layout.right_junction_pos end

239local function load_diversity_cache(model_name)

240 model_name = model_name or inference_config.get_selected_model()

241 local model_dir = model_name:gsub(":", "_")

242 -- Issue 10-054: diversity stays on disk (embeddings_dir_disk).

243 local cache_file = utils.embeddings_dir_disk(model_name) .. "/diversity_cache.json"

245 if not utils.file_exists(cache_file) then

246 error(string.format([[

247Diversity cache not found: %s

249The diversity cache is required for HTML generation.

250Generate it with: ./run.sh --generate-diversity

252This takes ~1 minute with GPU (or ~42 hours with CPU using --cpu-only).

253]], cache_file))

254 end

256 utils.log_info("Loading diversity cache from: " .. cache_file)

257 local cache_data = utils.read_json_file(cache_file)

259 if not cache_data then

260 error("Failed to parse diversity cache JSON file")

261 end

263 if not cache_data.sequences then

264 error("Diversity cache has invalid format (missing sequences table)")

265 end

267 DIVERSITY_CACHE = cache_data

268 return cache_data

275local function load_similarity_rankings_cache(model_name)

276 model_name = model_name or inference_config.get_selected_model()

277 local model_dir = model_name:gsub(":", "_")

278 -- Issue 10-054: similarity ranking cache is movable (embeddings_dir, RAM).

279 local cache_file = utils.embeddings_dir(model_name) .. "/similarity_rankings_cache.json"

281 if not utils.file_exists(cache_file) then

282 error(string.format([[

283Similarity rankings cache not found: %s

285The similarity rankings cache is required for fast HTML generation.

286Generate it with: ./run.sh --generate-similarity

288This is a post-processing step that pre-sorts similarity rankings.

289]], cache_file))

290 end

292 utils.log_info("Loading similarity rankings cache from: " .. cache_file)

293 local cache_data = utils.read_json_file(cache_file)

295 if not cache_data then

296 error("Failed to parse similarity rankings cache JSON file")

297 end

299 if not cache_data.rankings then

300 error("Similarity rankings cache has invalid format (missing rankings table)")

301 end

303 -- Count rankings (for logging)

304 local count = 0

305 for _ in pairs(cache_data.rankings) do count = count + 1 end

307 -- Validate cache is not empty (Issue: empty cache generated by standalone script)

308 if count == 0 then

309 error(string.format([[

310Similarity rankings cache is empty (0 poems): %s

312This usually means the cache was generated before similarity files existed,

313or the standalone script encountered a path issue.

315To fix, regenerate with: ./run.sh --generate-similarity --force

317This will regenerate both similarity files AND the rankings cache.

318]], cache_file))

319 end

321 SIMILARITY_RANKINGS_CACHE = cache_data

322 return cache_data

335local function media_href(path)

336 path = path or ""

337 local sub = path:match("input/images/(.+)$") or (path:match("([^/]+)$") or path)

338 return (sub:gsub("[^%w%-%._~/]", function(c)

339 return string.format("%%%02X", string.byte(c))

340 end))

353local media_flattening_done = false

355local function flatten_media_files(output_dir)

356 -- Skip if already done this session (idempotent)

357 if media_flattening_done then

358 return true

359 end

361 -- The configured image sources are the source of truth for where to

362 -- look. Each entry has an internal project-relative path (where the

363 -- sync script drops files) and may also have an external source path

364 -- (where the operator's actual files live on the wider file system).

365 -- We prefer the internal path when present, and fall back to the

366 -- external source so a configured-but-not-yet-synced entry still

367 -- contributes media. A configured entry that is missing from both

368 -- is a warning, not a fatal error — operators may legitimately

369 -- declare more sources than are populated at any given moment.

370 local sources_loader = require("sources-loader")

371 sources_loader.set_project_root(DIR)

372 local image_dirs = sources_loader.get_directories_with_external("images")

374 if not image_dirs or #image_dirs == 0 then

375 utils.log_warn("No image sources configured in sources.images.directories; skipping media flattening")

376 media_flattening_done = true

377 return true

378 end

380 local target_dir = output_dir .. "/media"

381 os.execute('mkdir -p "' .. target_dir .. '"')

383 local copied = 0

384 local skipped = 0

385 local errors = 0

386 local sources_used = 0

388 for _, dir in ipairs(image_dirs) do

389 -- sources-loader's resolve_path already returns an ABSOLUTE path (it

390 -- prepends the project root to relative config entries), so use dir.path

391 -- directly. Prepending DIR again produced a doubled "/root//root/..." path

392 -- that never resolved, so every source looked "missing" -- which the

393 -- mandatory-source check below then turned into a fatal stage-9 failure.

394 local internal_path = dir.path

395 local external_path = dir.external and dir.external.source or nil

396 local resolved_path = nil

398 local internal_test = io.open(internal_path, "r")

399 if internal_test then

400 internal_test:close()

401 resolved_path = internal_path

402 elseif external_path then

403 local external_test = io.open(external_path, "r")

404 if external_test then

405 external_test:close()

406 resolved_path = external_path

407 end

408 end

410 if not resolved_path then

411 -- Every configured image source is mandatory (the "optional" concept was

412 -- removed): a missing source means media we expected to ship is absent,

413 -- so we fail loudly here rather than silently skip it. Fix it by running

414 -- the sync/extraction that populates the path, or remove the source from

415 -- config.lua if it is genuinely gone.

416 error(string.format(

417 "Image source '%s' not found at internal '%s'%s -- every source is required; sync/extract it or remove it from config.lua",

418 dir.name or "(unnamed)",

419 dir.path or "(no path)",

420 external_path and (" or external '" .. external_path .. "'") or ""))

421 else

422 sources_used = sources_used + 1

424 -- Find every file under the resolved source and place it under

425 -- output/media/. TWO species, two layouts (must match media_href in

426 -- the renderers exactly, or the <img src> points at the wrong file):

427 -- * art sources (path .../input/images/<source>): keep

428 -- <source>/<subpath>, so two files that share a basename in

429 -- different subdirs (e.g. my-art/x.png and my-art/game-design/x.png)

430 -- stay distinct instead of one silently overwriting the other.

431 -- * everything else (Mastodon media, content-addressed hashes):

432 -- flatten to the bare basename -- already unique, and this

433 -- collapses the ~7-level Mastodon nesting.

434 -- No leading-^ anchor: dir.path is absolute (see above), so we match the

435 -- "input/images/<rest>" tail wherever it appears -- the same tail

436 -- media_href() extracts in the renderers, keeping the two layouts identical.

437 local ns_prefix = dir.path and dir.path:match("input/images/(.+)$") or nil

438 local find_cmd = string.format('find "%s" -type f', resolved_path)

439 local handle = io.popen(find_cmd)

440 if handle then

441 for source_path in handle:lines() do

442 -- this file's path within its own source dir (art subdirs kept)

443 local within = source_path:sub(#resolved_path + 2)

444 local target_sub

445 if ns_prefix then

446 target_sub = ns_prefix .. "/" .. within

447 else

448 target_sub = source_path:match("([^/]+)$")

449 end

450 if target_sub and target_sub ~= "" then

451 local target_path = target_dir .. "/" .. target_sub

452 local exists_check = io.open(target_path, "r")

453 if exists_check then

454 exists_check:close()

455 skipped = skipped + 1

456 else

457 -- create the subdirectory before copying (art paths

458 -- now nest one or more levels under output/media/)

459 local parent = target_path:match("^(.*)/[^/]+$")

460 if parent then os.execute('mkdir -p "' .. parent .. '"') end

461 local cp_cmd = string.format('cp "%s" "%s"', source_path, target_path)

462 local success = os.execute(cp_cmd)

463 if success == 0 or success == true then

464 copied = copied + 1

465 else

466 errors = errors + 1

467 utils.log_warn("Failed to copy: " .. source_path)

468 end

469 end

470 end

471 end

472 handle:close()

473 else

474 utils.log_warn("Could not scan image source: " .. resolved_path)

475 end

476 end

477 end

479 utils.log_info(string.format(

480 "Media flattening: %d sources used | %d copied, %d skipped, %d errors",

481 sources_used, copied, skipped, errors))

483 media_flattening_done = true

484 return errors == 0

492local pagination_config_loaded = false

494local function load_pagination_config()

495 -- Skip if already loaded (idempotent)

496 if pagination_config_loaded then

497 return PAGINATION_CONFIG

498 end

500 -- Load pagination settings from unified config

501 if unified_config.pagination then

502 for key, value in pairs(unified_config.pagination) do

503 if key ~= "_comment" and PAGINATION_CONFIG[key] ~= nil then

504 PAGINATION_CONFIG[key] = value

505 end

506 end

507 end

509 -- Load storage settings from unified config (Issue 8-020)

510 if unified_config.storage then

511 for key, value in pairs(unified_config.storage) do

512 if key ~= "_comment" and STORAGE_CONFIG[key] ~= nil then

513 STORAGE_CONFIG[key] = value

514 end

515 end

516 end

518 pagination_config_loaded = true

519 return PAGINATION_CONFIG

539local function compute_storage_max_pages(output_dir, num_poems)

540 local function popen_num(cmd)

541 local h = io.popen(cmd)

542 if not h then return nil end

543 local out = h:read("*a"); h:close()

544 return tonumber((out or ""):match("(%d+)"))

545 end

546 local function dir_bytes(path)

547 return popen_num(string.format("du -s --block-size=1 %q", path)) or 0

548 end

550 local sim_dir = output_dir .. "/similar"

551 local diff_dir = output_dir .. "/different"

552 local page_count = popen_num(string.format("find %q -maxdepth 1 -name '*.html' | wc -l", sim_dir)) or 0

553 if page_count == 0 or num_poems == 0 then

554 -- First build: nothing to measure yet. Fall back to the NATURAL maximum (every

555 -- other poem could fill pages), i.e. effectively uncapped, and warn. A finite

556 -- value keeps %d logging and the math.min() cap well-defined; the next build

557 -- measures real page sizes and applies the storage cap.

558 local per_page = PAGINATION_CONFIG.poems_per_page

559 local natural_max = math.max(1, math.ceil(num_poems / (per_page > 0 and per_page or 1)))

560 utils.log_warn("Storage page cap: no pages in " .. sim_dir .. " to measure -- "

561 .. "generating UNCAPPED this build (natural max " .. natural_max

562 .. " pages/poem); re-run to apply the measured cap.")

563 return natural_max

564 end

566 local sim_bytes = dir_bytes(sim_dir)

567 local avg_page = sim_bytes / page_count

568 local per_page_level = avg_page * num_poems * 2

569 local fixed = math.max(0, dir_bytes(output_dir) - sim_bytes - dir_bytes(diff_dir))

570 local budget = STORAGE_CONFIG.limit_gb * 1e9 -- decimal GB; conservative vs GiB

572 local max_pages = math.floor((budget - fixed) / per_page_level)

573 if max_pages < 1 then max_pages = 1 end

575 utils.log_info(string.format(

576 "Storage page cap (measured): %d page(s)/poem -- budget %dGB, fixed output %.1fGB, "

577 .. "%.0fKB/page x %d poems x 2 sides", max_pages, STORAGE_CONFIG.limit_gb,

578 fixed / 1e9, avg_page / 1000, num_poems))

579 return max_pages

586local function calculate_page_count(total_poems)

587 local poems_per_page = PAGINATION_CONFIG.poems_per_page

588 return math.ceil(total_poems / poems_per_page)

601local function parse_pages_specification(pages_spec, total_pages_possible)

602 -- Ensure pagination config is loaded

603 load_pagination_config()

605 -- Default: use minimum_pages from config

606 if not pages_spec or pages_spec == "" or pages_spec == "default" then

607 local pages = {}

608 for i = 1, PAGINATION_CONFIG.minimum_pages do

609 table.insert(pages, i)

610 end

611 return {pages = pages, is_all = false}

612 end

614 -- "all" means generate all pages up to max_pages_per_poem limit

615 if pages_spec == "all" then

616 return {pages = nil, is_all = true} -- nil means "generate all" in context

617 end

619 -- Single page number: "5" → {5}

620 local single_num = tonumber(pages_spec)

621 if single_num then

622 return {pages = {single_num}, is_all = false}

623 end

625 -- Range: "1-10" → {1,2,3,...,10}

626 local start_page, end_page = pages_spec:match("^(%d+)%-(%d+)$")

627 if start_page and end_page then

628 start_page = tonumber(start_page)

629 end_page = tonumber(end_page)

631 if start_page and end_page and start_page <= end_page then

632 local pages = {}

633 for i = start_page, end_page do

634 table.insert(pages, i)

635 end

636 return {pages = pages, is_all = false}

637 else

638 utils.log_error(string.format("Invalid page range: %s (start must be <= end)", pages_spec))

639 return {pages = {1}, is_all = false} -- Fallback to page 1

640 end

641 end

643 -- Invalid format - fallback to page 1

644 utils.log_error(string.format("Invalid --pages format: '%s'. Expected: 1, all, or 1-10", pages_spec))

645 return {pages = {1}, is_all = false}

653local function get_poems_for_page(sorted_poems, page_num)

654 local poems_per_page = PAGINATION_CONFIG.poems_per_page

655 local start_idx = ((page_num - 1) * poems_per_page) + 1

656 local end_idx = math.min(start_idx + poems_per_page - 1, #sorted_poems)

658 local page_poems = {}

659 for i = start_idx, end_idx do

660 if sorted_poems[i] then

661 table.insert(page_poems, sorted_poems[i])

662 end

663 end

665 return page_poems

675local function get_unique_poem_filename_id(poem)

676 local category = poem.category or "unknown"

677 local id = poem.id or 0

678 return string.format("%s-%04d", category, id)

690local function get_poem_anchor_id(poem)

691 local poem_index = poem.poem_index or 0

692 return string.format("poem-%d", poem_index)

699local function format_page_number(page_num)

700 local padding = PAGINATION_CONFIG.page_number_padding

701 return string.format("%0" .. padding .. "d", page_num)

711local function generate_page_filename(poem_id, page_num, page_type)

712 local padded_id = string.format("%04d", poem_id)

713 local padded_page = format_page_number(page_num)

714 return string.format("%s/%s-%s.html", page_type, padded_id, padded_page)

727local function generate_prev_next_navigation(current_page, total_pages, poem_id, page_type, total_corpus)

728 local nav_parts = {}

730 -- Calculate poem range for this page

731 local poems_per_page = PAGINATION_CONFIG.poems_per_page

732 local max_pages = PAGINATION_CONFIG.max_pages_per_poem

733 local start_poem = ((current_page - 1) * poems_per_page) + 1

734 local end_poem = math.min(current_page * poems_per_page, total_pages * poems_per_page)

736 -- Check if this is a storage-constrained last page

737 local is_storage_limited = (total_pages == max_pages) and (total_corpus and total_corpus > end_poem)

738 local poems_shown = end_poem

739 local poems_omitted = total_corpus and (total_corpus - poems_shown) or 0

741 -- Header line with page info

742 table.insert(nav_parts, "════════════════════════════════════════════════════════════════════════════════")

744 if page_type == "chronological" then

745 table.insert(nav_parts, string.format(" Page %d of %d │ Poems %d-%d",

746 current_page, total_pages, start_poem, end_poem))

747 else

748 local padded_id = string.format("%04d", poem_id)

749 if is_storage_limited then

750 -- Show storage context on capped pages (Issue 8-020)

751 table.insert(nav_parts, string.format(" %s to Poem %s │ Page %d of %d │ Showing top %d poems",

752 page_type == "similar" and "Similar" or "Different",

753 padded_id, current_page, total_pages, poems_shown))

754 else

755 table.insert(nav_parts, string.format(" %s to Poem %s │ Page %d of %d │ Poems %d-%d",

756 page_type == "similar" and "Similar" or "Different",

757 padded_id, current_page, total_pages, start_poem, end_poem))

758 end

759 end

761 table.insert(nav_parts, "════════════════════════════════════════════════════════════════════════════════")

763 -- Storage constraint notice on last page (Issue 8-020)

764 if is_storage_limited and current_page == total_pages and poems_omitted > 0 then

765 table.insert(nav_parts, string.format(" (%d additional poems omitted for storage constraints)",

766 poems_omitted))

767 end

769 table.insert(nav_parts, "")

771 -- Navigation links

772 local nav_line = ""

774 -- Previous link (left aligned)

775 if current_page > 1 then

776 local prev_file

777 if page_type == "chronological" then

778 -- Issue 8-039 Fix: Chronological pages now in subdirectory, use relative paths

779 prev_file = string.format("%s.html", format_page_number(current_page - 1))

780 else

781 prev_file = string.format("%s-%s.html", string.format("%04d", poem_id), format_page_number(current_page - 1))

782 end

783 nav_line = string.format("[<a href=\"%s\">◀ Previous Page</a>]", prev_file)

784 else

785 nav_line = "[◀ Previous Page]" -- Disabled

786 end

788 -- Calculate padding to push next link to right side

789 local padding = 80 - #nav_line - 16 -- 16 chars for next link

790 if padding < 0 then padding = 0 end

791 nav_line = nav_line .. string.rep(" ", padding)

793 -- Next link (right aligned)

794 if current_page < total_pages then

795 local next_file

796 if page_type == "chronological" then

797 -- Issue 8-039 Fix: Chronological pages now in subdirectory, use relative paths

798 next_file = string.format("%s.html", format_page_number(current_page + 1))

799 else

800 next_file = string.format("%s-%s.html", string.format("%04d", poem_id), format_page_number(current_page + 1))

801 end

802 nav_line = nav_line .. string.format("[<a href=\"%s\">Next Page ▶</a>]", next_file)

803 else

804 nav_line = nav_line .. "[Next Page ▶]" -- Disabled

805 end

807 table.insert(nav_parts, nav_line)

808 table.insert(nav_parts, "────────────────────────────────────────────────────────────────────────────────")

810 return table.concat(nav_parts, "\n")

816local cached_poem_colors = nil

818local function load_poem_colors()

819 -- Skip if already loaded (idempotent)

820 if cached_poem_colors then

821 return cached_poem_colors

822 end

824 local poem_colors_file = utils.embeddings_dir() .. "/poem_colors.json"

825 local poem_colors_data = utils.read_json_file(poem_colors_file)

827 if poem_colors_data and poem_colors_data.poem_colors then

828 -- Count actual entries dynamically (stored total_poems may be stale)

829 cached_poem_colors = poem_colors_data.poem_colors

830 return cached_poem_colors

831 else

832 utils.log_warn("Could not load poem colors, using mock colors")

833 cached_poem_colors = MOCK_POEM_COLORS

834 return cached_poem_colors

835 end

840local function get_file_creation_timestamp(file_path)

841 -- Use bash stat command to get file modification time (best approximation)

842 local cmd = string.format("stat -c %%Y '%s' 2>/dev/null", file_path)

843 local handle = io.popen(cmd)

844

845 if handle then

846 local result = handle:read("*a")

847 handle:close()

848

849 if result and result:match("^%d+") then

850 return tonumber(result:match("^%d+"))

851 end

852 end

853

854 return nil

859local function extract_post_date_from_poem(poem_data)

860 -- First, try to use the creation_date metadata field (if available)

861 local creation_date = poem_data.creation_date or (poem_data.metadata and poem_data.metadata.creation_date)

862 if creation_date then

863 -- Parse ISO 8601 format: "2023-04-20T05:22:03" or "2023-04-20T05:22:03Z"

864 local year, month, day, hour, min, sec = creation_date:match("(%d+)-(%d+)-(%d+)T(%d+):(%d+):(%d+)")

865 if year and month and day then

866 local parsed_time = os.time({

867 year = tonumber(year),

868 month = tonumber(month),

869 day = tonumber(day),

870 hour = tonumber(hour) or 0,

871 min = tonumber(min) or 0,

872 sec = tonumber(sec) or 0

873 })

874 if parsed_time then return parsed_time end

875 end

876

877 -- Fallback: try to extract just date part

878 year, month, day = creation_date:match("(%d+)-(%d+)-(%d+)")

879 if year and month and day then

880 local parsed_time = os.time({

881 year = tonumber(year),

882 month = tonumber(month),

883 day = tonumber(day),

884 hour = 0, min = 0, sec = 0

885 })

886 if parsed_time then return parsed_time end

887 end

888 end

889

890 -- Fallback: Look for date patterns in poem content (legacy logic)

891 local content = poem_data.content or ""

892

893 -- First, try to extract YYYY-MM-DD from the very beginning (processing artifact dates)

894 local year, month, day = content:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)")

895 if year and month and day then

896 return os.time({year=tonumber(year), month=tonumber(month), day=tonumber(day)})

897 end

898

899 -- Try to extract date from first line (other patterns)

900 local date_line = content:match("^([^\n]+)")

901 if date_line then

902 -- MM/DD/YYYY format

903 local month, day, year = date_line:match("(%d%d)/(%d%d)/(%d%d%d%d)")

904 if month and day and year then

905 return os.time({year=tonumber(year), month=tonumber(month), day=tonumber(day)})

906 end

907

908 -- Month DD, YYYY format (like "april 16th 2023")

909 local month_name, day_num, year_num = date_line:match("(%w+)%s+(%d+)%w*%s+(%d%d%d%d)")

910 if month_name and day_num and year_num then

911 local month_map = {

912 january=1, february=2, march=3, april=4, may=5, june=6,

913 july=7, august=8, september=9, october=10, november=11, december=12

914 }

915 local month_num = month_map[month_name:lower()]

916 if month_num then

917 return os.time({year=tonumber(year_num), month=month_num, day=tonumber(day_num)})

918 end

919 end

920 end

921

922 -- Fallback to file creation time if available

923 if poem_data.filepath then

924 local timestamp = get_file_creation_timestamp(poem_data.filepath)

925 if timestamp then

926 return timestamp

927 end

928 end

929

930 -- Final fallback to poem ID as timestamp approximation

931 return poem_data.id or 0

936local function sort_poems_chronologically_by_dates(poems_data)

937 local sorted_poems = {}

938

939 -- Extract all poems with temporal sorting data

940 for i, poem in ipairs(poems_data.poems) do

941 if poem.id then

942 local post_timestamp = extract_post_date_from_poem(poem)

943 table.insert(sorted_poems, {

944 poem = poem,

945 timestamp = post_timestamp,

946 sort_key = post_timestamp,

947 original_index = i

948 })

949 end

950 end

951

952 -- Sort by actual temporal order

953 table.sort(sorted_poems, function(a, b)

954 -- If timestamps are equal, use original index as tiebreaker

955 if a.sort_key == b.sort_key then

956 return a.original_index < b.original_index

957 end

958 return a.sort_key < b.sort_key

959 end)

960

961 return sorted_poems

966local function calculate_chronological_progress(poem_id, total_poems)

967 -- Calculate percentage through chronological corpus

968 local progress_percentage = (poem_id / total_poems) * 100

970 return {

971 poem_id = poem_id,

972 total_poems = total_poems,

973 percentage = progress_percentage,

974 position = poem_id,

975 quartile = math.ceil(progress_percentage / 25)

976 }

984local function compute_chronological_mapping(poems_data, chrono_poems_per_page)

985 -- Sort chronologically (same as generate_chronological_index_with_navigation)

986 local sorted_poems = sort_poems_chronologically_by_dates(poems_data)

987 local total_poems = #sorted_poems

988 local total_pages = chrono_poems_per_page and math.ceil(total_poems / chrono_poems_per_page) or 1

990 -- Issue 8-045: Calculate timeline bounds for time-based progress

991 -- sorted_poems[i].timestamp contains Unix timestamp from extract_post_date_from_poem()

992 local first_timestamp = sorted_poems[1] and sorted_poems[1].timestamp or 0

993 local last_timestamp = sorted_poems[total_poems] and sorted_poems[total_poems].timestamp or 0

994 local timeline_span = last_timestamp - first_timestamp

995 -- Avoid division by zero if all poems have same timestamp

996 if timeline_span <= 0 then timeline_span = 1 end

998 -- Build mapping

999 local mapping = {}

1000 for position, poem_info in ipairs(sorted_poems) do

1001 local poem = poem_info.poem

1002 local poem_index = poem.poem_index

1003 if poem_index then

1004 local page_number = chrono_poems_per_page and math.ceil(position / chrono_poems_per_page) or 1

1005 -- Issue 8-045: Calculate timeline progress as percentage of time elapsed

1006 local poem_timestamp = poem_info.timestamp or first_timestamp

1007 local timeline_progress = ((poem_timestamp - first_timestamp) / timeline_span) * 100

1008 mapping[poem_index] = {

1009 position = position,

1010 page_number = page_number,

1011 total_poems = total_poems,

1012 total_pages = total_pages,

1013 timeline_progress = timeline_progress -- Issue 8-045: time-based progress

1014 }

1015 end

1016 end

1018 return mapping

1035function M.default_chrono_per_page()

1036 -- Pull config.lua's pagination overrides into PAGINATION_CONFIG first, so the

1037 -- default reflects the CONFIG FILE (where --chrono-per-page's default lives),

1038 -- not the bare source-table placeholder. Idempotent; safe to call anywhere.

1039 load_pagination_config()

1040 local value = PAGINATION_CONFIG.chronological_poems_per_page

1041 if not value then

1042 error("config is missing chronological_poems_per_page; chronological "

1043 .. "pagination size is required (pass --chrono-per-page or set it "

1044 .. "in the pagination config)")

1045 end

1046 return value

1051local function generate_progress_dashes(progress_info, color_name, is_golden, position, has_corner_boxes)

1052 -- For golden poems: 82 chars interior (+ 2 corners = 84 total)

1053 -- For regular poems: 83 chars total (positions 0-82)

1054 -- Golden poems have corner characters (╔/┐ or ╚/┘) that add 2 to the width,

1055 -- so interior needs to be 1 less to maintain 84-char total alignment

1056 local total_chars = is_golden and 82 or 83

1057 local progress_chars = math.floor((progress_info.percentage / 100) * total_chars)

1058 local remaining_chars = total_chars - progress_chars

1060 -- Get color information

1061 local hex_color = COLOR_CONFIG[color_name] or COLOR_CONFIG["gray"]

1063 -- For golden bottom borders with corner boxes, we need to insert junction characters

1064 -- Issue 8-055: Fixed junction positions to align ╧/┴ under ┐/┌ corners

1065 -- Junction positions in the 82-char interior (0-indexed):

1066 -- - Position 10: under "similar" box ┐ (same as regular poems)

1067 -- - Position 71: under "different" box ┌ (regular + 1 due to wider golden poem)

1068 local LEFT_JUNCTION_POS = 10 -- Same as regular: left box ┐ at position 10

1069 local RIGHT_JUNCTION_POS = 71 -- Regular + 1: right box ┌ at position 71 (golden is 1 char wider)

1071 -- Junction positions for regular poems (different from golden due to no outer walls)

1072 -- Regular corner boxes: ┌─────────┐ (11 chars) + 59 spaces + ┌───────────┐ (13 chars) = 83 chars

1073 -- Inner walls at positions 10 and 70 (0-indexed)

1074 local REGULAR_LEFT_JUNCTION_POS = 10

1075 local REGULAR_RIGHT_JUNCTION_POS = 70

1077 local visual_output

1078 if is_golden and position == "bottom" and has_corner_boxes then

1079 -- Build progress bar with junction characters inserted

1080 -- We need to construct the bar character by character to insert junctions at the right spots

1082 -- Determine which junction character to use at each position

1083 -- ╧ (U+2567) - up single and horizontal double (connects to ═) - COLORED

1084 -- ┴ (U+2534) - up and horizontal single (connects to ─) - UNCOLORED

1085 local left_in_progress = LEFT_JUNCTION_POS < progress_chars

1086 local right_in_progress = RIGHT_JUNCTION_POS < progress_chars

1088 -- Build colored junctions (╧ when in progress section)

1089 local left_junction

1090 if left_in_progress then

1091 left_junction = string.format('<font color="%s"><b>╧</b></font>', hex_color)

1092 else

1093 left_junction = "┴"

1094 end

1096 local right_junction

1097 if right_in_progress then

1098 right_junction = string.format('<font color="%s"><b>╧</b></font>', hex_color)

1099 else

1100 right_junction = "┴"

1101 end

1103 -- Build the progress section (colored ═) and remaining section (─)

1104 -- We need to split around the junction positions

1105 local segments = {}

1106 local current_pos = 0

1108 -- Helper to add a segment with proper coloring

1109 local function add_segment(start_pos, end_pos)

1110 if end_pos <= start_pos then return end

1111 local seg_len = end_pos - start_pos

1113 -- Determine how much of this segment is progress vs remaining

1114 local progress_in_seg = math.max(0, math.min(seg_len, progress_chars - start_pos))

1115 local remaining_in_seg = seg_len - progress_in_seg

1117 if progress_in_seg > 0 then

1118 table.insert(segments, string.format('<font color="%s"><b>%s</b></font>',

1119 hex_color, string.rep("═", progress_in_seg)))

1120 end

1121 if remaining_in_seg > 0 then

1122 table.insert(segments, string.rep("─", remaining_in_seg))

1123 end

1124 end

1126 -- Bugfix: this copy started at 0 and ended at total_chars, landing the

1127 -- left junction one column too far right (col 11) and the right one a

1128 -- dash short -- so the bottom bar did not line up under the nav-box

1129 -- corners. Start at 1 and end at total_chars+1 to match poem-bars (the

1130 -- word pages, which were correct): 9 dashes before the left junction so

1131 -- it sits at column 10, 11 after the right junction. Width is unchanged.

1132 -- Segment 1: corner ╚ is column 0, so the first dash runs 1..left junction

1133 add_segment(1, LEFT_JUNCTION_POS)

1134 -- Insert left junction (colored if ╧, plain if ┴)

1135 table.insert(segments, left_junction)

1137 -- Segment 2: from left junction + 1 to right junction (exclusive)

1138 add_segment(LEFT_JUNCTION_POS + 1, RIGHT_JUNCTION_POS)

1139 -- Insert right junction (colored if ╧, plain if ┴)

1140 table.insert(segments, right_junction)

1142 -- Segment 3: from right junction + 1 to the far corner (exclusive of ┘)

1143 add_segment(RIGHT_JUNCTION_POS + 1, total_chars + 1)

1145 local interior = table.concat(segments, "")

1146 -- Color the ╚ corner to match the progress bar

1147 local colored_corner = string.format('<font color="%s"><b>╚</b></font>', hex_color)

1148 visual_output = colored_corner .. interior .. "┘"

1150 elseif not is_golden and position == "bottom" and has_corner_boxes then

1151 -- Regular poem bottom border with corner characters and junctions connecting to corner boxes

1152 -- Structure: ╘ (pos 0) + progress bar + ┴/╧ (pos 10) + progress bar + ┴/╧ (pos 69) + progress bar + ┘ (pos 81)

1153 -- ╘ (U+2558) - up single and right double - closes left box, connects to ═ progress

1154 -- ┘ (U+2518) - light up and left - closes right box, connects to ─ remaining

1156 local left_in_progress = REGULAR_LEFT_JUNCTION_POS < progress_chars

1157 local right_in_progress = REGULAR_RIGHT_JUNCTION_POS < progress_chars

1159 -- Build colored junctions (╧ when in progress section, ┴ otherwise)

1160 local left_junction

1161 if left_in_progress then

1162 left_junction = string.format('<font color="%s"><b>╧</b></font>', hex_color)

1163 else

1164 left_junction = "┴"

1165 end

1167 local right_junction

1168 if right_in_progress then

1169 right_junction = string.format('<font color="%s"><b>╧</b></font>', hex_color)

1170 else

1171 right_junction = "┴"

1172 end

1174 -- Left corner ╘ - colored if progress > 0 (position 0 is always in progress section if any progress)

1175 local left_corner

1176 if progress_chars > 0 then

1177 left_corner = string.format('<font color="%s"><b>╘</b></font>', hex_color)

1178 else

1179 left_corner = "╘"

1180 end

1182 -- Right corner ┘ - always uncolored (position 82 is almost never in progress section)

1183 local right_corner = "┘"

1185 -- Build the progress bar with junctions

1186 local segments = {}

1188 -- Helper to add a segment with proper coloring

1189 -- Note: positions are now 1-80 since 0 and 81 are corner characters

1190 local function add_segment(start_pos, end_pos)

1191 if end_pos <= start_pos then return end

1192 local seg_len = end_pos - start_pos

1194 local progress_in_seg = math.max(0, math.min(seg_len, progress_chars - start_pos))

1195 local remaining_in_seg = seg_len - progress_in_seg

1197 if progress_in_seg > 0 then

1198 table.insert(segments, string.format('<font color="%s"><b>%s</b></font>',

1199 hex_color, string.rep("═", progress_in_seg)))

1200 end

1201 if remaining_in_seg > 0 then

1202 table.insert(segments, string.rep("─", remaining_in_seg))

1203 end

1204 end

1206 -- Start with left corner

1207 table.insert(segments, left_corner)

1209 -- Segment 1: from 1 to left junction (exclusive) - 9 chars

1210 add_segment(1, REGULAR_LEFT_JUNCTION_POS)

1211 table.insert(segments, left_junction)

1213 -- Segment 2: from left junction + 1 to right junction (exclusive) - 59 chars

1214 add_segment(REGULAR_LEFT_JUNCTION_POS + 1, REGULAR_RIGHT_JUNCTION_POS)

1215 table.insert(segments, right_junction)

1217 -- Segment 3: from right junction + 1 to end - 1 (exclusive of right corner) - 11 chars

1218 add_segment(REGULAR_RIGHT_JUNCTION_POS + 1, total_chars - 1)

1220 -- End with right corner

1221 table.insert(segments, right_corner)

1223 -- No padding needed - content has 1-space indent for alignment

1224 visual_output = table.concat(segments, "")

1226 elseif is_golden then

1227 -- Golden poem top border or bottom without corner boxes

1228 -- Create progress visualization using equals/dash distinction

1229 local progress_section = string.rep("═", progress_chars)

1230 local remaining_section = string.rep("─", remaining_chars)

1232 local colored_progress = string.format(

1233 '<font color="%s"><b>%s</b></font>%s',

1234 hex_color, progress_section, remaining_section

1235 )

1237 -- Color the left corners to match the progress bar

1238 local colored_top_corner = string.format('<font color="%s"><b>╔</b></font>', hex_color)

1239 local colored_bottom_corner = string.format('<font color="%s"><b>╚</b></font>', hex_color)

1241 if position == "top" then

1242 visual_output = colored_top_corner .. colored_progress .. "┐"

1243 elseif position == "bottom" then

1244 visual_output = colored_bottom_corner .. colored_progress .. "┘"

1245 else

1246 visual_output = colored_top_corner .. colored_progress .. "┐"

1247 end

1248 else

1249 -- Regular poems: no padding needed - content has 1-space indent for alignment

1250 local progress_section = string.rep("═", progress_chars)

1251 local remaining_section = string.rep("─", remaining_chars)

1253 local colored_progress = string.format(

1254 '<font color="%s"><b>%s</b></font>%s',

1255 hex_color, progress_section, remaining_section

1256 )

1257 visual_output = colored_progress

1258 end

1260 -- Screen reader accessible version - brief format for frequent use

1261 local screen_reader_text

1262 if is_golden then

1263 screen_reader_text = string.format(

1264 'aria-label="golden poem border. %s."',

1265 color_name

1266 )

1267 else

1268 screen_reader_text = string.format(

1269 'aria-label="eighty dashes. %s."',

1270 color_name

1271 )

1272 end

1274 return {

1275 visual = visual_output,

1276 accessibility = screen_reader_text,

1277 raw_progress = progress_chars,

1278 raw_remaining = remaining_chars,

1279 color = color_name,

1280 percentage = progress_info.percentage,

1281 is_golden = is_golden or false

1282 }

1287local function wrap_single_line_80_chars(line)

1288 -- Wrap a single line to 80 characters, preserving words

1289 if #line <= 80 then

1290 return line

1291 end

1293 local result_lines = {}

1294 local words = {}

1296 for word in line:gmatch("%S+") do

1297 table.insert(words, word)

1298 end

1300 local current_line = ""

1301 for _, word in ipairs(words) do

1302 if #current_line == 0 then

1303 current_line = word

1304 elseif #current_line + 1 + #word <= 80 then

1305 current_line = current_line .. " " .. word

1306 else

1307 table.insert(result_lines, current_line)

1308 current_line = word

1309 end

1310 end

1312 if #current_line > 0 then

1313 table.insert(result_lines, current_line)

1314 end

1316 return table.concat(result_lines, "\n")

1321local function strip_html_tags(content)

1322 -- Strip all HTML tags and decode HTML entities for TXT export

1323 -- Images should be converted with render_attachment_images_txt() separately

1324 local result = content

1326 -- Strip HTML tags

1327 result = result:gsub("<[^>]+>", "")

1329 -- Decode common HTML entities

1330 result = result:gsub("&amp;", "&")

1331 result = result:gsub("&lt;", "<")

1332 result = result:gsub("&gt;", ">")

1333 result = result:gsub("&quot;", '"')

1334 result = result:gsub("&#39;", "'")

1335 result = result:gsub("&nbsp;", " ")

1336 result = result:gsub("&#(%d+);", function(n)

1337 return string.char(tonumber(n))

1338 end)

1340 -- Normalize multiple consecutive spaces/newlines

1341 result = result:gsub("[ \t]+", " ")

1342 result = result:gsub("\n[ \t]+", "\n")

1343 result = result:gsub("[ \t]+\n", "\n")

1344 result = result:gsub("\n\n\n+", "\n\n")

1346 return result

1351local function wrap_text_80_chars(text)

1352 -- Wrap text to 80 chars while preserving existing newlines (paragraph breaks)

1353 local input_lines = {}

1354 for line in (text .. "\n"):gmatch("(.-)\n") do

1355 table.insert(input_lines, line)

1356 end

1358 local output_lines = {}

1359 for _, line in ipairs(input_lines) do

1360 if #line == 0 then

1361 -- Preserve empty lines (paragraph breaks)

1362 table.insert(output_lines, "")

1363 else

1364 -- Wrap long lines

1365 local wrapped = wrap_single_line_80_chars(line)

1366 for wrapped_line in (wrapped .. "\n"):gmatch("(.-)\n") do

1367 table.insert(output_lines, wrapped_line)

1368 end

1369 end

1370 end

1372 return table.concat(output_lines, "\n")

1380function M.generate_similarity_ranked_list(starting_poem_id, poems_data, similarity_data)

1381 -- Verify cache is loaded

1382 if not SIMILARITY_RANKINGS_CACHE then

1383 error("Similarity rankings cache not loaded! Run: ./run.sh --generate-similarity")

1384 end

1386 if not SIMILARITY_RANKINGS_CACHE.rankings then

1387 error("Similarity rankings cache has invalid format (missing rankings table)")

1388 end

1390 -- Look up pre-sorted ranking for this poem

1391 local cached_ranking = SIMILARITY_RANKINGS_CACHE.rankings[tostring(starting_poem_id)]

1392 if not cached_ranking then

1393 error(string.format("Similarity ranking not found for poem %s in cache.", starting_poem_id))

1394 end

1396 -- Build poem index lookup for fast access

1397 local poem_by_index = {}

1398 for i, poem in ipairs(poems_data.poems) do

1399 if poem.poem_index then

1400 poem_by_index[poem.poem_index] = poem

1401 end

1402 end

1404 -- Initialize ranked list with starting poem

1405 local ranked_poems = {}

1406 local starting_poem = poems_data.poems[starting_poem_id]

1407 table.insert(ranked_poems, {

1408 id = starting_poem_id,

1409 poem = starting_poem,

1410 similarity = 1.0, -- Perfect similarity to self

1411 rank = 1

1412 })

1414 -- Add poems in pre-sorted order from cache

1415 -- Cache contains poem indices already sorted by similarity (descending)

1416 local rank = 2

1417 for _, target_poem_index in ipairs(cached_ranking) do

1418 local poem = poem_by_index[target_poem_index]

1419 if poem then

1420 table.insert(ranked_poems, {

1421 id = poem.id,

1422 poem = poem,

1423 similarity = nil, -- Not needed for display, saves memory

1424 rank = rank

1425 })

1426 rank = rank + 1

1427 end

1428 end

1430 return ranked_poems

1437function M.generate_maximum_diversity_sequence(starting_poem_id, poems_data, embeddings_data)

1438 -- Verify cache is loaded

1439 if not DIVERSITY_CACHE then

1440 error("Diversity cache not loaded! Run: ./run.sh --generate-diversity")

1441 end

1443 if not DIVERSITY_CACHE.sequences then

1444 error("Diversity cache has invalid format (missing sequences table)")

1445 end

1447 -- Look up pre-computed sequence

1448 local cached_sequence = DIVERSITY_CACHE.sequences[tostring(starting_poem_id)]

1449 if not cached_sequence then

1450 error(string.format("Diversity sequence not found for poem %d in cache. Cache may be corrupted or incomplete.", starting_poem_id))

1451 end

1453 -- Convert cached poem_index values to full poem objects

1454 -- Note: The diversity cache stores poem_index (globally unique), NOT poem.id (per-category)

1455 local diversity_sequence = {}

1456 local poem_lookup = {}

1458 -- Build lookup table keyed by poem_index (NOT poem.id which is per-category)

1459 for i, poem in ipairs(poems_data.poems) do

1460 if poem.poem_index then

1461 poem_lookup[poem.poem_index] = poem

1462 end

1463 end

1465 -- Convert cached sequence (contains poem_index values) to format expected by HTML generator

1466 -- Issue 10-025: Skip anchor poem (GPU cache stores source poem as first entry)

1467 for step, poem_index in ipairs(cached_sequence) do

1468 if poem_index ~= starting_poem_id then

1469 local poem = poem_lookup[poem_index]

1470 if poem then

1471 table.insert(diversity_sequence, {

1472 id = poem_index, -- Store poem_index for consistency

1473 poem = poem,

1474 step = step

1475 })

1476 end

1477 end

1478 end

1480 return diversity_sequence

1487local function render_attachment_images(attachments)

1488 -- Render HTML for poem attachments (images, audio, video)

1489 -- Returns empty string if no attachments or no renderable attachments

1490 -- Media output format designed for 80-char width aesthetic

1491 --

1492 -- ATTACHMENT STRUCTURE (from ActivityPub extraction):

1493 -- {

1494 -- media_type = "image/png" or "audio/mpeg" or "video/mp4",

1495 -- url = "https://server.com/media/files/123/456/original/abc.png",

1496 -- relative_path = "files/123/456/original/abc.png",

1497 -- alt_text = "User description" or nil,

1498 -- width = 1920, -- images/video only

1499 -- height = 1080 -- images/video only

1500 -- }

1502 if not attachments or #attachments == 0 then

1503 return ""

1504 end

1506 local media_html = {}

1507 -- "up to the site root" -- these attachments render on poem pages, which sit

1508 -- one level below output/ (output/similar/, output/different/, ...), so a

1509 -- "../" prefix reaches the root. Document-relative: resolves the same opened

1510 -- locally from any folder or served on the site, so no path conversion step.

1511 local base_path = ".."

1513 for _, attachment in ipairs(attachments) do

1514 local media_type = attachment.media_type or ""

1515 -- Issue 8-048: media lives at output/media/<source>/<subpath> (see

1516 -- flatten_media_files); media_href keeps art's source+subdir structure so

1517 -- same-named pieces don't collide. "../media/" reaches it from a poem page.

1518 local relative_path = attachment.relative_path or ""

1519 -- media_href namespaces art by source+subdir (collision-safe) and

1520 -- url-encodes; Mastodon hashes collapse to the bare name. Matches where

1521 -- flatten_media_files placed the file.

1522 local media_src = base_path .. "/media/" .. media_href(relative_path)

1524 if media_type:match("^image/") then

1525 -- Use alt text if available, otherwise generate generic description

1526 -- Issue 9-012: ActivityPub uses 'description' field for alt-text

1527 local alt_text = attachment.description or attachment.alt_text or "Image attachment"

1528 -- Issue 8-053: Normalize newlines to spaces for clean HTML attributes

1529 alt_text = alt_text:gsub("\n", " "):gsub("\r", "")

1530 -- Escape quotes in alt text for HTML attribute

1531 alt_text = alt_text:gsub('"', '&quot;')

1533 -- Build image tag with lazy loading for performance

1534 -- Issue 8-005 Fix: Add max-width to prevent viewport overflow

1535 -- display:block prevents multiple images from appearing side-by-side

1536 -- max-width:min(100%,800px) caps at content width (~80 chars) while being responsive

1537 -- width/height hints help browser reserve space before load (aspect ratio preserved)

1538 -- Issue 8-053: title attribute provides mouse-over tooltip for sighted users

1539 local img_tag

1540 if attachment.width and attachment.height then

1541 img_tag = string.format(

1542 ' <img src="%s" alt="%s" title="%s" loading="lazy" width="%d" height="%d" style="display:block; max-width:min(100%%,800px); height:auto">',

1543 media_src, alt_text, alt_text, attachment.width, attachment.height

1544 )

1545 else

1546 img_tag = string.format(

1547 ' <img src="%s" alt="%s" title="%s" loading="lazy" style="display:block; max-width:min(100%%,800px); height:auto">',

1548 media_src, alt_text, alt_text

1549 )

1550 end

1551 table.insert(media_html, img_tag)

1553 elseif media_type:match("^audio/") then

1554 -- Issue 8-049: Audio playback support

1555 -- controls: Shows play/pause, volume, seek bar

1556 -- preload="metadata": Only loads duration/metadata initially for performance

1557 local audio_tag = string.format(

1558 ' <audio controls preload="metadata" style="display:block; max-width:100%%">\n' ..

1559 ' <source src="%s" type="%s">\n' ..

1560 ' Your browser does not support the audio element.\n' ..

1561 ' </audio>',

1562 media_src, media_type

1563 )

1564 table.insert(media_html, audio_tag)

1566 elseif media_type:match("^video/") then

1567 -- Issue 8-049: Video playback support

1568 -- controls: Shows play/pause, volume, seek bar, fullscreen

1569 -- preload="metadata": Only loads poster frame initially for performance

1570 -- max-width caps at content width while being responsive

1571 local video_tag

1572 if attachment.width and attachment.height then

1573 video_tag = string.format(

1574 ' <video controls preload="metadata" width="%d" height="%d" style="display:block; max-width:min(100%%,800px); height:auto">\n' ..

1575 ' <source src="%s" type="%s">\n' ..

1576 ' Your browser does not support the video element.\n' ..

1577 ' </video>',

1578 attachment.width, attachment.height, media_src, media_type

1579 )

1580 else

1581 video_tag = string.format(

1582 ' <video controls preload="metadata" style="display:block; max-width:min(100%%,800px); height:auto">\n' ..

1583 ' <source src="%s" type="%s">\n' ..

1584 ' Your browser does not support the video element.\n' ..

1585 ' </video>',

1586 media_src, media_type

1587 )

1588 end

1589 table.insert(media_html, video_tag)

1590 end

1591 end

1593 if #media_html == 0 then

1594 return ""

1595 end

1597 -- Issue 8-005 Fix: Close </pre> before media, reopen after

1598 -- Media inside <pre> don't respect max-width:100% because <pre> sizes to content

1599 -- By closing </pre>, media inherit width constraints from the parent <td> container

1600 return "\n</pre>\n" .. table.concat(media_html, "\n") .. "\n<pre>\n"

1606local function render_attachment_images_txt(attachments)

1607 -- Render plain text placeholders for poem attachments (images, audio, video)

1608 -- Returns [Image: alt-text], [Audio: filename], [Video: filename] format for TXT export

1609 -- Unlike render_attachment_images(), this outputs plain text, not HTML

1610 --

1611 -- This function exists because TXT exports cannot contain HTML media tags.

1612 -- Media are replaced with bracketed descriptions.

1614 if not attachments or #attachments == 0 then

1615 return ""

1616 end

1618 local media_lines = {}

1620 for _, attachment in ipairs(attachments) do

1621 local media_type = attachment.media_type or ""

1622 local placeholder

1624 if media_type:match("^image/") then

1625 -- Use alt text if available, otherwise indicate no description

1626 local alt_text = attachment.description or attachment.alt_text or "no description"

1627 placeholder = string.format("[Image: %s]", alt_text)

1629 elseif media_type:match("^audio/") then

1630 -- Issue 8-049: Audio placeholder

1631 local basename = (attachment.relative_path or ""):match("([^/]+)$") or "audio file"

1632 placeholder = string.format("[Audio: %s]", basename)

1634 elseif media_type:match("^video/") then

1635 -- Issue 8-049: Video placeholder

1636 local basename = (attachment.relative_path or ""):match("([^/]+)$") or "video file"

1637 placeholder = string.format("[Video: %s]", basename)

1638 end

1640 if placeholder then

1641 -- Wrap long text to 80 characters

1642 if #placeholder > 80 then

1643 placeholder = wrap_text_80_chars(placeholder)

1644 end

1645 table.insert(media_lines, placeholder)

1646 end

1647 end

1649 if #media_lines == 0 then

1650 return ""

1651 end

1653 -- Return with newline prefix/suffix for proper spacing

1654 return "\n" .. table.concat(media_lines, "\n") .. "\n"

1659local function format_warning_box(warning_text)

1660 -- Create simple ASCII box around content warning

1661 local content = wrap_text_80_chars(warning_text)

1662 local lines = {}

1663 for line in content:gmatch("[^\n]+") do

1664 table.insert(lines, line)

1665 end

1666

1667 -- Find longest line for box width

1668 local max_width = 0

1669 for _, line in ipairs(lines) do

1670 max_width = math.max(max_width, #line)

1671 end

1672

1673 -- Ensure minimum width and maximum of 76 chars (leave room for box borders)

1674 max_width = math.min(math.max(max_width, 20), 76)

1675

1676 local boxed = {}

1677 table.insert(boxed, "┌" .. string.rep("─", max_width + 2) .. "┐")

1678

1679 for _, line in ipairs(lines) do

1680 local padded = line .. string.rep(" ", max_width - #line)

1681 table.insert(boxed, "│ " .. padded .. " │")

1682 end

1683

1684 table.insert(boxed, "└" .. string.rep("─", max_width + 2) .. "┘")

1685

1686 return table.concat(boxed, "\n")

1691local function escape_html(text)

1692 -- Escape HTML special characters in poem content to prevent browser interpretation

1693 -- Issue 8-041: Fixes bug where poem content containing </pre> breaks page rendering

1694 -- IMPORTANT: Must be called BEFORE apply_markdown_formatting() so that

1695 -- markdown-generated HTML tags (like <em>) are NOT escaped

1696 -- Order matters: & must be escaped first, otherwise &lt; becomes &amp;lt;

1697 if not text then return "" end

1698 return text

1699 -- Strip NUL and other C0 control bytes that occasionally ride along in

1700 -- source poem text (a stray \0 in one post is what made a chronological

1701 -- page read as "binary" and could make a browser choke on it). Keep the

1702 -- legitimate whitespace controls: tab (\9), newline (\10), CR (\13).

1703 :gsub("[%z\1-\8\11\12\14-\31]", "")

1704 :gsub("&", "&amp;")

1705 :gsub("<", "&lt;")

1706 :gsub(">", "&gt;")

1711local function apply_markdown_formatting(text)

1712 -- Handle *\*text*\* (italics with asterisks)

1713 text = text:gsub("%*\\%*([^%*]+)%*\\%*", "<em>*%1*</em>")

1715 -- Handle *text* (simple italics)

1716 text = text:gsub("%*([^%*]+)%*", "<em>%1</em>")

1718 return text

1723local function is_golden_poem(poem)

1724 -- Issue 8-044: Use pre-calculated golden status from extraction metadata

1725 -- This correctly accounts for:

1726 -- - Pre-anonymization content (original @mentions preserved)

1727 -- - Content warning text (without "CW: " prefix)

1728 -- The extraction calculates this once; we use metadata as single source of truth

1729 if poem.metadata and poem.metadata.is_golden_poem then

1730 return true

1731 end

1732 return false

1737local function is_boost_poem(poem)

1738 -- Issue 8-057: Detect boosted/shared posts for visual formatting

1739 -- Boosts are reshared content from other fediverse users

1740 -- boost_type can be: "cached_external", "external", or "embedded"

1741 if poem.metadata and poem.metadata.is_boost then

1742 return true

1743 end

1744 return false

1749local function get_poem_display_filename(poem)

1750 -- Returns the display filename for a poem (without extension)

1751 -- For notes: uses metadata.source_file (the original filename)

1752 -- For fediverse/messages: uses the numeric ID

1753 -- All categories: no .txt extension (cleaner display)

1754 local category = poem.category or "unknown"

1755 local filename

1757 if category == "notes" and poem.metadata and poem.metadata.source_file then

1758 -- Notes preserve their original descriptive filenames

1759 filename = poem.metadata.source_file

1760 else

1761 -- Fediverse and messages use numeric ID

1762 filename = tostring(poem.id or "unknown")

1763 end

1765 return category .. "/" .. filename

1770local function generate_corner_box_separator(hex_color)

1771 -- Generate the separator line with corner box tops for GOLDEN poems

1772 -- Format: ╟─────────┐ ┌───────────┤

1773 -- Left box: 11 chars (╟ + 9×─ + ┐)

1774 -- Right box: 13 chars (┌ + 11×─ + ┤)

1775 -- Gap: 60 chars (spaces)

1776 -- Total: 84 chars

1777 -- The left junction ╟ is colored to match the progress bar

1778 local colored_junction = string.format('<font color="%s"><b>╟</b></font>', hex_color)

1779 local left_box = colored_junction .. string.rep("─", 9) .. "┐"

1780 local right_box = "┌" .. string.rep("─", 11) .. "┤"

1781 local gap = string.rep(" ", 60)

1782 return left_box .. gap .. right_box

1788local function colorize_char(char, hex_color)

1789 if hex_color then

1790 return string.format('<font color="%s"><b>%s</b></font>', hex_color, char)

1791 end

1792 return char

1798local function generate_regular_corner_box_top(progress_chars, hex_color)

1799 -- Generate the top line of corner boxes for REGULAR poems (no side walls)

1800 -- Format: ┌─────────┐ ┌───────────┐

1801 -- Left box: 11 chars (┌ + 9×─ + ┐) at positions 0-10

1802 -- Right box: 13 chars (┌ + 11×─ + ┐) at positions 70-82

1803 -- Gap: 59 chars (spaces) at positions 11-69

1804 -- Total: 83 chars

1806 progress_chars = progress_chars or 0

1808 -- Left box (positions 0-10)

1809 local left_parts = {}

1810 -- Position 0: ┌

1811 table.insert(left_parts, progress_chars > 0 and colorize_char("┌", hex_color) or "┌")

1812 -- Positions 1-9: ─────────

1813 for i = 1, 9 do

1814 table.insert(left_parts, progress_chars > i and colorize_char("─", hex_color) or "─")

1815 end

1816 -- Position 10: ┐

1817 table.insert(left_parts, progress_chars > 10 and colorize_char("┐", hex_color) or "┐")

1819 -- Gap (positions 11-69) - spaces don't need coloring

1820 local gap = string.rep(" ", 59)

1822 -- Right box (positions 70-82)

1823 local right_parts = {}

1824 -- Position 70: ┌

1825 table.insert(right_parts, progress_chars > 70 and colorize_char("┌", hex_color) or "┌")

1826 -- Positions 71-81: ───────────

1827 for i = 71, 81 do

1828 table.insert(right_parts, progress_chars > i and colorize_char("─", hex_color) or "─")

1829 end

1830 -- Position 82: ┐

1831 table.insert(right_parts, progress_chars > 82 and colorize_char("┐", hex_color) or "┐")

1833 return table.concat(left_parts) .. gap .. table.concat(right_parts)

1838local function generate_regular_corner_box_bottom()

1839 -- Generate the bottom line of corner boxes for REGULAR poems

1840 -- Format: └─────────┘ └───────────┘

1841 -- Gap: 59 chars, Total: 83 chars

1842 local left_box = "└" .. string.rep("─", 9) .. "┘"

1843 local right_box = "└" .. string.rep("─", 11) .. "┘"

1844 local gap = string.rep(" ", 59)

1845 return left_box .. gap .. right_box

1850local function generate_corner_box_nav_line(similar_link, different_link, chronological_link, hex_color)

1851 -- Generate the navigation line with corner box walls for GOLDEN poems (Issue 8-030)

1852 -- Format: ║ similar │ chronological │ different │

1853 -- Left box: ║ + space + link + space + │ = 11 chars

1854 -- Center text: chronological (13 chars visible) - or empty space if nil (on chronological.html)

1855 -- Right box: │ + space + link + space + │ = 13 chars

1856 -- Gaps: 2 gaps of ~23 chars each

1857 -- Total: 84 chars

1858 -- The left wall ║ is colored to match the progress bar

1860 -- The links contain HTML, so we need to measure visible text

1861 local similar_visible = similar_link:gsub("<[^>]+>", "") -- "similar"

1862 local different_visible = different_link:gsub("<[^>]+>", "") -- "different"

1864 -- Handle nil chronological_link (on chronological.html page, we don't show this link)

1865 local center_text = ""

1866 local center_visible_len = 0

1867 if chronological_link then

1868 center_text = chronological_link

1869 center_visible_len = chronological_link:gsub("<[^>]+>", ""):len() -- "chronological" = 13 chars

1870 end

1872 -- Left box: ║ (colored) + space + similar + padding + │

1873 local colored_wall = string.format('<font color="%s"><b>║</b></font>', hex_color)

1874 local left_content_width = 9 -- space between ║ and │

1875 local similar_padding = left_content_width - 1 - #similar_visible -- 1 for leading space

1876 local left_box = colored_wall .. " " .. similar_link .. string.rep(" ", similar_padding) .. "│"

1878 -- Right box: │ + space + different + padding + │

1879 local right_content_width = 11 -- space between │ and │

1880 local different_padding = right_content_width - 1 - #different_visible -- 1 for leading space

1881 local right_box = "│ " .. different_link .. string.rep(" ", different_padding) .. "│"

1883 -- Calculate gaps: Total 84 - 11 (left) - center_visible - 13 (right) = remaining

1884 -- If no center text, distribute all 47+13 = 60 chars into the gaps (30 left, 30 right)

1885 -- If center text (13 chars), split remaining 47 into 22 left + 25 right

1886 local left_gap, right_gap

1887 if center_visible_len > 0 then

1888 left_gap = string.rep(" ", 22)

1889 right_gap = string.rep(" ", 25)

1890 else

1891 -- No chronological link - distribute 60 chars evenly (30+30)

1892 left_gap = string.rep(" ", 30)

1893 right_gap = string.rep(" ", 30)

1894 end

1896 return left_box .. left_gap .. center_text .. right_gap .. right_box

1902local function generate_regular_corner_box_nav_line(similar_link, different_link, chronological_link, progress_chars, hex_color)

1903 -- Generate the navigation line with corner box walls for REGULAR poems (Issue 8-030)

1904 -- Format: │ similar │ chronological │ different │

1905 -- Left box: │ + space + link + space + │ = 11 chars (positions 0-10)

1906 -- Center text: chronological (13 chars visible) - or empty space if nil (on chronological.html)

1907 -- Right box: │ + space + link + space + │ = 13 chars (positions 70-82)

1908 -- Gaps: 2 gaps totaling 59 chars (with 13 char center text: 23 left + 23 right)

1909 -- Total: 83 chars

1911 progress_chars = progress_chars or 0

1913 local similar_visible = similar_link:gsub("<[^>]+>", "")

1914 local different_visible = different_link:gsub("<[^>]+>", "")

1916 -- Handle nil chronological_link (on chronological.html page, we don't show this link)

1917 local center_text = ""

1918 local center_visible_len = 0

1919 if chronological_link then

1920 center_text = chronological_link

1921 center_visible_len = chronological_link:gsub("<[^>]+>", ""):len() -- "chronological" = 13 chars

1922 end

1924 -- Left box: │ + space + similar + padding + │

1925 -- Wall characters at positions 0 and 10

1926 local left_wall = progress_chars > 0 and colorize_char("│", hex_color) or "│"

1927 local right_wall_of_left = progress_chars > 10 and colorize_char("│", hex_color) or "│"

1928 local left_content_width = 9

1929 local similar_padding = left_content_width - 1 - #similar_visible

1930 local left_box = left_wall .. " " .. similar_link .. string.rep(" ", similar_padding) .. right_wall_of_left

1932 -- Right box: │ + space + different + padding + │

1933 -- Wall characters at positions 70 and 82

1934 local left_wall_of_right = progress_chars > 70 and colorize_char("│", hex_color) or "│"

1935 local right_wall = progress_chars > 82 and colorize_char("│", hex_color) or "│"

1936 local right_content_width = 11

1937 local different_padding = right_content_width - 1 - #different_visible

1938 local right_box = left_wall_of_right .. " " .. different_link .. string.rep(" ", different_padding) .. right_wall

1940 -- Calculate gaps: Total 83 - 11 (left) - 13 (right) = 59 for gaps + center

1941 -- If no center text, distribute 59 chars into the gaps (29 left, 30 right)

1942 -- If center text (13 chars), split remaining 46 into 23 left + 23 right

1943 local left_gap, right_gap

1944 if center_visible_len > 0 then

1945 left_gap = string.rep(" ", 23)

1946 right_gap = string.rep(" ", 23)

1947 else

1948 -- No chronological link - distribute 59 chars (29+30)

1949 left_gap = string.rep(" ", 29)

1950 right_gap = string.rep(" ", 30)

1951 end

1953 return left_box .. left_gap .. center_text .. right_gap .. right_box

1958local function apply_golden_poem_formatting(content, is_golden, similar_link, different_link, chronological_link, hex_color)

1959 -- Golden poem side borders: ║ on left (colored), │ on right

1960 -- Interior width: 80 characters for content (with 1 space padding on each side)

1961 -- Format: ║ + space + 80 chars content (padded) + space + │ = 84 total

1962 -- The left wall ║ is colored to match the progress bar

1963 if not is_golden then

1964 return content

1965 end

1967 local CONTENT_WIDTH = 80 -- Content area between padding spaces

1968 local color = hex_color or "#787878" -- Default to gray if no color provided

1970 -- Helper to count UTF-8 characters (not bytes)

1971 -- Box-drawing chars are 3 bytes each, so #str gives wrong count

1972 local function utf8_char_count(str)

1973 -- Remove UTF-8 continuation bytes (0x80-0xBF), count what remains

1974 return #(str:gsub("[\128-\191]", ""))

1975 end

1977 -- Split content into lines (append newline to handle last line without trailing newline)

1978 local lines = {}

1979 for line in (content .. "\n"):gmatch("(.-)\n") do

1980 table.insert(lines, line)

1981 end

1983 local formatted_lines = {}

1984 local colored_wall = string.format('<font color="%s"><b>║</b></font>', color)

1986 for _, line in ipairs(lines) do

1987 -- Calculate visible length (excluding HTML tags, counting UTF-8 chars)

1988 -- Issue 8-055: Also decode HTML entities for accurate width counting

1989 -- e.g., &gt; is 4 bytes but displays as 1 character (>)

1990 local visible_length = text_formatter.calculate_visible_width(line)

1992 -- Pad or handle line to fit content width

1993 local padded_line

1994 if visible_length >= CONTENT_WIDTH then

1995 -- Line is already at or over width - use as-is

1996 padded_line = line

1997 else

1998 -- Pad with spaces to reach content width

1999 local padding_needed = CONTENT_WIDTH - visible_length

2000 padded_line = line .. string.rep(" ", padding_needed)

2001 end

2003 -- Add side borders with padding: ║ (colored) content │

2004 table.insert(formatted_lines, colored_wall .. " " .. padded_line .. " │")

2005 end

2007 -- Add corner box navigation (separator + nav line) if links provided

2008 -- Issue 9-003 Fix: Only require similar and different links - chronological_link can be nil

2009 if similar_link and different_link then

2010 -- Add separator line with corner box tops: ╟─────────┐ ┌───────────┤

2011 table.insert(formatted_lines, generate_corner_box_separator(color))

2012 -- Add navigation line with corner box walls: ║ similar │ chronological │ different │

2013 -- chronological_link may be nil on chronological.html (shows empty space in center)

2014 table.insert(formatted_lines, generate_corner_box_nav_line(similar_link, different_link, chronological_link, color))

2015 end

2017 return table.concat(formatted_lines, "\n")

2047local function format_content_with_warnings(text, poem_category, poem, similar_link, different_link, chronological_link, hex_color)

2048 -- Issue 8-041: Escape HTML special characters in poem content FIRST

2049 -- This prevents browser from interpreting poem content as HTML markup

2050 -- (e.g., a poem containing "</pre>" would otherwise close the preformatted block)

2051 text = escape_html(text)

2053 -- Apply markdown formatting AFTER escaping

2054 -- This allows *italics* to become <em>italics</em> while keeping

2055 -- literal < > & in poem content safely escaped

2056 text = apply_markdown_formatting(text)

2058 -- Check if this is a golden poem

2059 local is_golden = poem and is_golden_poem(poem)

2061 local formatted_lines = {}

2063 -- Issue 9-011: Display content warning from poem.content_warning field (Mastodon CW)

2064 -- This is separate from in-content CW: patterns - it comes from ActivityPub summary field

2065 if poem and poem.content_warning and poem.content_warning ~= "" then

2066 local cw_label = "CW: " .. poem.content_warning

2067 local warning_box = format_warning_box(cw_label)

2068 table.insert(formatted_lines, warning_box)

2069 table.insert(formatted_lines, "") -- First newline

2070 table.insert(formatted_lines, "") -- Second newline for spacing

2071 end

2073 -- Detect additional content warning patterns in text (CW:, content warning:, etc.)

2074 -- Issue 10-021: Use text_formatter.format_poem_lines to preserve empty lines (paragraph breaks)

2075 local lines = text_formatter.format_poem_lines(text)

2077 for _, line in ipairs(lines) do

2078 -- Check if line starts with content warning (in-content CW pattern)

2079 if line:lower():match("^%s*cw%s*:") or line:lower():match("^%s*content warning%s*:") then

2080 -- Format content warning with box

2081 local warning_box = format_warning_box(line)

2082 table.insert(formatted_lines, warning_box)

2083 table.insert(formatted_lines, "") -- First newline

2084 table.insert(formatted_lines, "") -- Second newline for spacing

2085 else

2086 -- Issue 10-021: Wrap long lines while preserving leading whitespace

2087 -- This replaces 8-056's no-wrap approach with whitespace-aware wrapping

2088 local wrapped = text_formatter.wrap_preserving_indent(line, 80)

2089 for _, wrapped_line in ipairs(wrapped) do

2090 table.insert(formatted_lines, wrapped_line)

2091 end

2092 end

2093 end

2095 local formatted_content = table.concat(formatted_lines, "\n")

2097 -- Apply golden poem box-drawing formatting (with corner box nav inside)

2098 if is_golden then

2099 formatted_content = apply_golden_poem_formatting(formatted_content, true, similar_link, different_link, chronological_link, hex_color)

2100 else

2101 -- For regular poems, add 1-space left padding to each content line

2102 -- Content uses 1-space indent for alignment (83 chars total width)

2103 local padded_lines = {}

2104 for line in (formatted_content .. "\n"):gmatch("(.-)\n") do

2105 table.insert(padded_lines, " " .. line)

2106 end

2107 formatted_content = table.concat(padded_lines, "\n")

2108 end

2110 return formatted_content, is_golden

2116local function format_single_poem_with_progress_and_color(poem, total_poems, poem_colors, chrono_mapping)

2117 -- Issue 9-013: a ranked IMAGE entry (pseudo-poem) renders as an image box,

2118 -- not a poem. Inert until inject_pseudo_poems tags/append image entries.

2119 if poem.is_image then

2120 return image_render.format_image_entry(poem)

2121 end

2123 local formatted = ""

2125 -- Get semantic color for this poem (key by poem_index, NOT poem.id)

2126 local poem_color_data = poem_colors[poem.poem_index]

2127 local semantic_color = poem_color_data and poem_color_data.color or "gray"

2128 local hex_color = COLOR_CONFIG[semantic_color] or COLOR_CONFIG["gray"]

2130 -- Calculate chronological progress (using poem_index for lookup)

2131 local progress_info = calculate_chronological_progress(poem.poem_index, total_poems)

2133 -- Check if this is a golden poem (exactly 1024 characters)

2134 local is_golden = is_golden_poem(poem)

2136 -- Issue 8-057: Check if this is a boost (reshared content from another author)

2137 local is_boost = is_boost_poem(poem)

2139 -- Build navigation links for this poem (using category prefix for anchors, poem_index for paginated files)

2140 local unique_id = get_unique_poem_filename_id(poem) -- For anchor IDs only (e.g. "messages-0001")

2141 local anchor_id = get_poem_anchor_id(poem)

2142 local poem_index = poem.poem_index or 0 -- Numeric ID for paginated files (e.g. 1 → "0001")

2144 -- Issue 8-012 Phase E: Link to paginated format (similar/0001-01.html)

2145 -- Issue 9-003: Use absolute file:// paths - helper script converts to production URLs

2146 local base_path = ".."

2147 local similar_link = string.format("<a href='%s/similar/%04d-01.html'>similar</a>", base_path, poem_index)

2148 local different_link = string.format("<a href='%s/different/%04d-01.html'>different</a>", base_path, poem_index)

2149 -- Issue 8-039: Chronological now in subdirectory

2150 -- Issue 10-036: Use chrono_mapping for correct paginated link (index.html redirect loses anchors)

2151 local chrono_info = chrono_mapping and chrono_mapping[poem_index]

2152 local chrono_page = chrono_info and string.format("%02d", chrono_info.page_number) or "01"

2153 local chronological_link = string.format("<a href='%s/chronological/%s.html#%s'>chronological</a>", base_path, chrono_page, anchor_id)

2155 -- Add file header (notes show original filename, others show numeric ID)

2156 formatted = formatted .. string.format(" -> file: %s\n", get_poem_display_filename(poem))

2157 -- Issue 9-013: text+image posts get a direct "image.png" link below the

2158 -- header. (Image entries never reach here -- they return early above.)

2159 local img_link = image_render.text_image_link(poem)

2160 if img_link ~= "" then formatted = formatted .. " " .. img_link .. "\n" end

2162 -- Issue 8-057: Boost formatting - uses complete nested frame with arrows and [BOOST] label

2163 -- Boost formatting replaces all standard elements (top bar, content, nav, bottom bar)

2164 if is_boost then

2165 -- Escape HTML and apply markdown to content

2166 local text = escape_html(poem.content or "")

2168 -- Issue 10-037: Defensive fallback for blank boost content

2169 -- If content is empty, display the original URI or diagnostic message

2170 if text == "" or text:match("^%s*$") then

2171 local original_uri = poem.metadata and poem.metadata.original_uri

2172 if original_uri then

2173 text = "External post: " .. escape_html(original_uri)

2174 else

2175 text = "(Boost content unavailable)"

2176 end

2177 end

2179 -- Issue 10-039: Make external boost URLs clickable

2180 -- Pattern: "External post: https://..." -> wrap URL in anchor tag

2181 local external_pattern = "^External post: (https?://[^%s]+)$"

2182 local external_url = text:match(external_pattern)

2183 if external_url then

2184 -- Wrap the URL across box lines (boost content width) instead of

2185 -- letting it overflow the box; each line links to the full URL.

2186 text = text_formatter.wrap_external_url("External post: ", external_url, boost_bars.CONTENT_WIDTH)

2187 else

2188 -- Issue 10-041: Wrap long embedded content to fit the boost box.

2189 -- Only wrap non-external-post content (external posts keep URLs intact)

2190 local BOOST_CONTENT_WIDTH = boost_bars.CONTENT_WIDTH

2191 local wrapped_lines = {}

2192 for line in (text .. "\n"):gmatch("(.-)\n") do

2193 local wrapped = text_formatter.wrap_preserving_indent(line, BOOST_CONTENT_WIDTH)

2194 for _, wrapped_line in ipairs(wrapped) do

2195 table.insert(wrapped_lines, wrapped_line)

2196 end

2197 end

2198 text = table.concat(wrapped_lines, "\n")

2199 end

2201 text = apply_markdown_formatting(text)

2203 -- Calculate progress as decimal (0-1) for boost functions

2204 local progress_percent = progress_info.percentage / 100

2206 -- Apply complete boost formatting (includes all frame elements)

2207 local boost_formatted = apply_boost_poem_formatting(

2208 text, progress_percent, similar_link, different_link, chronological_link

2209 )

2210 formatted = formatted .. boost_formatted .. "\n"

2212 -- Render attached images after boost frame

2213 if poem.attachments then

2214 formatted = formatted .. render_attachment_images(poem.attachments)

2215 end

2217 return {

2218 content = formatted,

2219 semantic_color = semantic_color,

2220 progress_percentage = progress_info.percentage,

2221 poem_id = poem.id

2222 }

2223 end

2225 -- Standard formatting for golden and regular poems

2226 -- Generate top progress bar separator (with golden corners if applicable)

2227 local top_dashes = generate_progress_dashes(progress_info, semantic_color, is_golden, "top")

2228 formatted = formatted .. string.format('<span %s>%s</span>',

2229 top_dashes.accessibility,

2230 top_dashes.visual)

2232 -- Add newline after top border for all poems

2233 -- Golden poems: ┐ corner needs newline before ║ content wall on next line

2234 -- Regular poems: progress bar needs newline before content

2235 formatted = formatted .. "\n"

2237 -- Format poem content with content warning handling and whitespace preservation

2238 -- Pass nav links and hex_color for golden poems

2239 local content_formatted = format_content_with_warnings(

2240 poem.content or "", poem.category, poem,

2241 is_golden and similar_link or nil,

2242 is_golden and different_link or nil,

2243 is_golden and chronological_link or nil,

2244 is_golden and hex_color or nil

2245 )

2246 formatted = formatted .. content_formatted

2248 -- Render attached images if present (from ActivityPub extraction)

2249 -- Images appear after poem content, before navigation links

2250 -- Issue 9-010: Images stay with their original post only (no associated_images rendering)

2251 if poem.attachments then

2252 formatted = formatted .. render_attachment_images(poem.attachments)

2253 end

2255 -- For golden poems, content already includes nav in corner boxes

2256 -- For regular poems, add corner-boxed navigation links (top and nav lines only, bottom connects to progress bar)

2257 if not is_golden then

2258 -- Issue 8-035: Calculate progress_chars and hex_color for nav box colorization

2259 local total_chars = LAYOUT.REGULAR_POEM_WIDTH

2260 local progress_chars = math.floor((progress_info.percentage / 100) * total_chars)

2261 local hex_color = COLOR_CONFIG[semantic_color]

2263 formatted = formatted .. "\n"

2264 formatted = formatted .. generate_regular_corner_box_top(progress_chars, hex_color) .. "\n"

2265 formatted = formatted .. generate_regular_corner_box_nav_line(similar_link, different_link, chronological_link, progress_chars, hex_color) .. "\n"

2266 -- No bottom line - corner boxes connect directly to progress bar via junctions

2267 else

2268 -- Golden poems: add newline after nav line (content_formatted doesn't end with newline)

2269 formatted = formatted .. "\n"

2270 end

2272 -- Generate bottom progress bar separator (with junctions for both golden and regular poems)

2273 -- The has_corner_boxes parameter enables junction characters at wall positions

2274 local bottom_dashes = generate_progress_dashes(progress_info, semantic_color, is_golden, "bottom", true)

2275 formatted = formatted .. string.format('<span %s>%s</span>\n',

2276 bottom_dashes.accessibility,

2277 bottom_dashes.visual)

2279 return {

2280 content = formatted,

2281 semantic_color = semantic_color,

2282 progress_percentage = progress_info.percentage,

2283 poem_id = poem.id

2284 }

2289local function format_single_poem_with_warnings(poem)

2290 local formatted = ""

2292 -- Add file header (notes show original filename, others show numeric ID)

2293 formatted = formatted .. string.format(" -> file: %s\n", get_poem_display_filename(poem))

2294 formatted = formatted .. string.rep("-", 80) .. "\n"

2296 -- Format poem content with content warning handling and whitespace preservation

2297 formatted = formatted .. format_content_with_warnings(poem.content or "", poem.category, poem)

2299 -- Render attached images if present

2300 if poem.attachments then

2301 formatted = formatted .. render_attachment_images(poem.attachments)

2302 end

2304 return formatted

2309local function format_single_poem_80_width(poem)

2310 -- Format a single poem for TXT export (80-character width, no HTML)

2311 -- Uses strip_html_tags() to remove HTML and render_attachment_images_txt() for images

2312 local formatted = ""

2314 -- Add file header (notes show original filename, others show numeric ID)

2315 formatted = formatted .. string.format(" -> file: %s\n", get_poem_display_filename(poem))

2316 formatted = formatted .. string.rep("-", 80) .. "\n"

2318 -- Strip HTML tags and format poem content to 80-character width

2319 local clean_content = strip_html_tags(poem.content or "")

2320 formatted = formatted .. wrap_text_80_chars(clean_content)

2322 -- Render attached images as [Image: alt-text] placeholders (not HTML)

2323 if poem.attachments then

2324 formatted = formatted .. render_attachment_images_txt(poem.attachments)

2325 end

2327 return formatted

2333local function format_all_poems_with_progress_and_color(starting_poem, sorted_poems, total_poems, poem_colors, chrono_mapping)

2334 local content = ""

2336 -- Add starting poem first with progress visualization

2337 local formatted_starting = format_single_poem_with_progress_and_color(starting_poem, total_poems, poem_colors, chrono_mapping)

2338 content = content .. formatted_starting.content .. "\n\n"

2340 -- Add all other poems sorted by similarity/diversity

2341 for _, poem_info in ipairs(sorted_poems) do

2342 if poem_info.id ~= starting_poem.id then -- Skip starting poem since we already added it

2343 local formatted_poem = format_single_poem_with_progress_and_color(poem_info.poem, total_poems, poem_colors, chrono_mapping)

2344 content = content .. formatted_poem.content .. "\n\n"

2345 end

2346 end

2348 return content

2353local function format_all_poems_with_content_warnings(starting_poem, sorted_poems)

2354 local content = ""

2355

2356 -- Add starting poem first

2357 content = content .. format_single_poem_with_warnings(starting_poem)

2358 content = content .. "\n\n"

2359

2360 -- Add all other poems sorted by similarity/diversity

2361 for _, poem_info in ipairs(sorted_poems) do

2362 if poem_info.id ~= starting_poem.id then -- Skip starting poem since we already added it

2363 content = content .. format_single_poem_with_warnings(poem_info.poem)

2364 content = content .. "\n\n"

2365 end

2366 end

2367

2368 return content

2373local function format_all_poems_80_width(starting_poem, sorted_poems)

2374 local content = ""

2375

2376 -- Add starting poem first

2377 content = content .. format_single_poem_80_width(starting_poem)

2378 content = content .. "\n\n"

2379

2380 -- Add all other poems sorted by similarity/diversity

2381 for _, poem_info in ipairs(sorted_poems) do

2382 if poem_info.id ~= starting_poem.id then -- Skip starting poem since we already added it

2383 content = content .. format_single_poem_80_width(poem_info.poem)

2384 content = content .. "\n\n"

2385 end

2386 end

2387

2388 return content

2394function M.generate_flat_poem_list_html_with_progress(starting_poem, sorted_poems, page_type, starting_poem_id, use_progress, chrono_mapping)

2395 -- Template uses pure HTML without CSS (except Issue 16-010 font-stack)

2396 -- Content is pre-wrapped to 80 chars, <pre> provides monospace formatting

2397 -- Issue 9-003 Fix: Use centered table for block centering with left-aligned text inside

2398 -- Issue 16-010: Added FONT_STYLE for Hack Nerd Font font-stack

2399 local template = [[<!DOCTYPE html>

2400<html>

2401<head>

2402<meta charset="UTF-8">

2403<title>Poems sorted by %s to: %s</title>

2404]] .. FONT_STYLE .. [[</head>

2405<body bgcolor="#000000" text="#FFFFFF" link="#6699FF" vlink="#9966FF">

2406<center>

2407<h1>Poetry Collection</h1>

2408<p>All poems sorted by %s to: %s</p>

2409</center>

2410<table align="center"><tr><td>

2411<pre>

2412%s

2413</pre>

2414</td></tr></table>

2415</body>

2416</html>]]

2417

2418 local formatted_content

2419

2420 if use_progress then

2421 -- Load poem colors and use enhanced formatting

2422 local poem_colors = load_poem_colors()

2423

2424 -- Calculate actual total poems by finding the maximum poem ID

2425 -- This represents the total chronological span of the corpus

2426 local max_poem_id = starting_poem.id or 1

2427

2428 for _, poem_info in ipairs(sorted_poems) do

2429 if poem_info.id and poem_info.id > max_poem_id then

2430 max_poem_id = poem_info.id

2431 elseif poem_info.poem and poem_info.poem.id and poem_info.poem.id > max_poem_id then

2432 max_poem_id = poem_info.poem.id

2433 end

2434 end

2435

2436 local total_poems = max_poem_id

2438 -- Issue 10-036: Pass chrono_mapping for correct paginated chronological links

2439 formatted_content = format_all_poems_with_progress_and_color(starting_poem, sorted_poems, total_poems, poem_colors, chrono_mapping)

2440 else

2441 -- Use standard formatting with content warnings

2442 formatted_content = format_all_poems_with_content_warnings(starting_poem, sorted_poems)

2443 end

2444

2445 local page_type_desc = (page_type == "similar") and "similarity" or "difference"

2446 local starting_title = starting_poem.title or ("Poem " .. starting_poem_id)

2447

2448 return string.format(template,

2449 page_type_desc,

2450 starting_title,

2451 page_type_desc,

2452 starting_title,

2453 formatted_content)

2459function M.generate_flat_poem_list_html(starting_poem, sorted_poems, page_type, starting_poem_id, chrono_mapping)

2460 -- Default to using progress bars

2461 return M.generate_flat_poem_list_html_with_progress(starting_poem, sorted_poems, page_type, starting_poem_id, true, chrono_mapping)