python
# Imports
import os, zipfile, re, io, json, shutil, sys, textwrap
from pathlib import Path

# Try to import PyMuPDF (fitz) and PIL
try:
    import fitz  # PyMuPDF
except Exception as e:
    print("PyMuPDF import error:", e)

from PIL import Image

VAULT_ZIP = "/mnt/data/Equgalus Current.zip"
MM_PDF = "/mnt/data/Monster Manual.pdf"

# Workspace paths
workdir = Path("/mnt/data/work")
outdir = workdir / "vault"
assets_root = outdir / "Resources" / "Assets" / "Bestiary"

# Reset workspace
if workdir.exists():
    shutil.rmtree(workdir)
workdir.mkdir(parents=True, exist_ok=True)

# 1) Extract the Obsidian vault zip
with zipfile.ZipFile(VAULT_ZIP, 'r') as z:
    z.extractall(outdir)

# Helper: find the Bestiary subfolders under Ithersta/Compendium/Bestiary
bestiary_root = outdir / "Ithersta" / "Compendium" / "Bestiary"
subfolders_expected = ["Beasts", "Monsters", "Non-Beasts", "Story NPCs"]

existing_subfolders = []
for name in subfolders_expected:
    p = bestiary_root / name
    if p.exists():
        existing_subfolders.append(name)

existing_subfolders, bestiary_root.exists(), outdir.exists()

([], False, True)

python
# Inspect top-level structure of extracted vault
for root, dirs, files in os.walk(outdir):
    depth = Path(root).relative_to(outdir).parts
    if len(depth) <= 2:
        print(root)
        for d in dirs:
            print("  [D]", d)
        for f in files[:5]:
            print("  [F]", f)
        print("---")

python
from collections import defaultdict
import pandas as pd

comp_bestiary_root = outdir / "Compendium" / "Bestiary"
assets_bestiary_root = outdir / "Resources" / "Assets" / "Beastiary"  # spelled as in vault
subfolders = ["Beasts", "Monsters", "Non-Beasts", "Story NPCs"]

creature_notes = []
for sub in subfolders:
    folder = comp_bestiary_root / sub
    if not folder.exists():
        continue
    for md in folder.glob("*.md"):
        # read first non-empty line that starts with '#'
        name = None
        with open(md, 'r', encoding='utf-8', errors='ignore') as f:
            for line in f:
                if line.strip().startswith("#"):
                    # strip leading hashes and whitespace
                    name = line.strip().lstrip("#").strip()
                    break
        if not name:
            # fallback: filename without extension
            name = md.stem
        creature_notes.append({"subfolder": sub, "note_path": str(md), "name": name})

len(creature_notes), creature_notes[:5]

(1067,
 [{'subfolder': 'Beasts',
   'note_path': '/mnt/data/work/vault/Compendium/Bestiary/Beasts/Allosaurus.md',
   'name': 'Allosaurus'},
  {'subfolder': 'Beasts',
   'note_path': '/mnt/data/work/vault/Compendium/Bestiary/Beasts/Almiraj.md',
   'name': 'Almiraj'},
  {'subfolder': 'Beasts',
   'note_path': '/mnt/data/work/vault/Compendium/Bestiary/Beasts/Ankylosaurus.md',
   'name': 'Ankylosaurus'},
  {'subfolder': 'Beasts',
   'note_path': '/mnt/data/work/vault/Compendium/Bestiary/Beasts/Ape.md',
   'name': 'Ape'},
  {'subfolder': 'Beasts',
   'note_path': '/mnt/data/work/vault/Compendium/Bestiary/Beasts/Aurochs.md',
   'name': 'Aurochs'}])

python
# Open PDF
doc = fitz.open(MM_PDF)
n_pages = len(doc)
n_pages

354

python
def extract_largest_image_from_page(page, min_area=20000):
    """Extract largest raster image from a page; return PIL Image object and bbox size"""
    image_list = page.get_images(full=True)
    if not image_list:
        return None, 0
    best_im = None
    best_area = 0
    for img in image_list:
        xref = img[0]
        try:
            pix = fitz.Pixmap(doc, xref)
            if pix.n >= 5:  # CMYK or with alpha
                pix = fitz.Pixmap(fitz.csRGB, pix)
            w, h = pix.width, pix.height
            area = w*h
            if area > best_area:
                # Convert to PIL
                data = pix.tobytes("png")
                im = Image.open(io.BytesIO(data)).convert("RGBA")
                best_im = im
                best_area = area
        except Exception as e:
            continue
    if best_area < min_area:
        return None, best_area
    return best_im, best_area

def find_page_for_name(name):
    """Find candidate page number(s) for a creature name"""
    candidates = []
    needle = name
    for i in range(n_pages):
        page = doc[i]
        rects = page.search_for(needle, quads=False)
        if rects:
            candidates.append(i)
    return candidates

# Test a couple of names
test_names = ["Allosaurus", "Ankylosaurus", "Azer", "Banshee", "Aboleth", "Beholder"]
for nm in test_names:
    cands = find_page_for_name(nm)
    print(nm, "->", cands[:5])

python
def extract_image_for_creature(name):
    candidates = find_page_for_name(name)
    best = None
    best_area = 0
    best_page = None
    for i in candidates:
        page = doc[i]
        im, area = extract_largest_image_from_page(page)
        if im is not None and area > best_area:
            best = im
            best_area = area
            best_page = i
    return best, best_page, best_area

for nm in ["Aboleth", "Banshee", "Azer", "Allosaurus"]:
    im, p, area = extract_image_for_creature(nm)
    print(nm, "page", p, "area", area, "img", bool(im))

python
def extract_image_for_creature_filtered(name, start_page=12, end_page=None):
    if end_page is None:
        end_page = n_pages - 1
    candidates = [i for i in find_page_for_name(name) if start_page <= i <= end_page]
    best = None
    best_area = 0
    best_page = None
    for i in candidates:
        page = doc[i]
        im, area = extract_largest_image_from_page(page)
        if im is not None and area > best_area:
            best = im
            best_area = area
            best_page = i
    return best, best_page, best_area, candidates

for nm in ["Aboleth", "Banshee", "Azer", "Allosaurus"]:
    im, p, area, cands = extract_image_for_creature_filtered(nm, start_page=10, end_page=n_pages-5)
    print(nm, "cands", cands[:5], "chosen", p, "area", area, "img", bool(im))

python
# Precompute lowercased page text from page 10 to n_pages-5
start_index = 10
end_index = n_pages - 5
page_texts = []
for i in range(start_index, end_index+1):
    text = doc[i].get_text().lower()
    page_texts.append(text)
len(page_texts), start_index, end_index

(340, 10, 349)

python
def candidate_pages_from_text(name):
    """Return absolute page indices where the lowercased name appears in the page text."""
    needle = name.lower()
    cands = []
    for idx, text in enumerate(page_texts):
        if needle in text:
            cands.append(start_index + idx)
    return cands

def extract_best_image_for_name(name):
    cands = candidate_pages_from_text(name)
    best_im = None
    best_area = 0
    best_page = None
    for p in cands:
        page = doc[p]
        im, area = extract_largest_image_from_page(page)
        if im is not None and area > best_area:
            best_im = im
            best_area = area
            best_page = p
    return best_im, best_page, best_area, cands

for nm in ["Aboleth", "Banshee", "Allosaurus", "Black Bear", "Bear"]:
    im, p, area, cands = extract_best_image_for_name(nm)
    print(nm, "-> cands", cands[:5], "chosen", p, "area", area)

python
def candidate_pages_exact_title(name):
    needle = "\n" + name.lower() + "\n"
    cands = []
    for idx, text in enumerate(page_texts):
        if needle in text:
            cands.append(start_index + idx)
    return cands

for nm in ["Aboleth", "Banshee", "Allosaurus", "Black Bear", "Bear", "Azer"]:
    cands = candidate_pages_exact_title(nm)
    print(nm, "->", cands)

python
from collections import Counter

counts = Counter([c['subfolder'] for c in creature_notes])
counts

Counter({'Monsters': 746, 'Story NPCs': 143, 'Beasts': 135, 'Non-Beasts': 43})

python
# Preview a few names from each subfolder
sample = defaultdict(list)
for c in creature_notes:
    if len(sample[c['subfolder']]) < 10:
        sample[c['subfolder']].append(c['name'])

sample

defaultdict(list,
            {'Beasts': ['Allosaurus',
              'Almiraj',
              'Ankylosaurus',
              'Ape',
              'Aurochs',
              'Axe Beak',
              'Baboon',
              'Badger',
              'Bat',
              'Black Bear'],
             'Monsters': ['Aarakocra Simulacrum',
              'Aarakocra',
              'Aboleth',
              'Abominable Yeti',
              'Abyssal Wretch',
              'Adult Black Dragon',
              'Adult Blue Dracolich',
              'Adult Blue Dragon',
              'Adult Brass Dragon',
              'Adult Bronze Dragon'],
             'Non-Beasts': ['Abjurer',
              'Acolyte',
              'Apprentice Wizard',
              'Archdruid',
              'Archer',
              'Archmage',
              'Assassin',
              'Bandit Captain',
              'Bandit',
              'Bard'],
             'Story NPCs': ['Acererak',
              'Aerisi Kalinoth',
              'Artus Cimber',
              'Asharra',
              'Augrek Brighthelm',
              'Azbara Jos',
              "Baba Lysaga's Creeping Hut",
              'Baba Lysaga',
              'Bael',
              'Bag of Nails']})

python
import time

# Ensure assets subfolders exist
for sub in subfolders:
    (assets_bestiary_root / sub).mkdir(parents=True, exist_ok=True)

results = []
limit_monsters = 200
limit_beasts = 80
limit_nonbeasts = 40
limit_story = 40

processed_counts = defaultdict(int)

def should_process(sub):
    if sub == "Monsters":
        return processed_counts[sub] < limit_monsters
    if sub == "Beasts":
        return processed_counts[sub] < limit_beasts
    if sub == "Non-Beasts":
        return processed_counts[sub] < limit_nonbeasts
    if sub == "Story NPCs":
        return processed_counts[sub] < limit_story
    return False

def upsert_embed(note_path, name):
    """Insert or update the image embed line right under the H1 line"""
    embed_line = f"![[{name}.png|175]]"
    with open(note_path, 'r', encoding='utf-8', errors='ignore') as f:
        lines = f.read().splitlines()
    # find first H1 line
    h1_idx = None
    for i, line in enumerate(lines):
        if line.strip().startswith("# "):
            h1_idx = i
            break
    if h1_idx is None:
        # Prepend a header
        lines.insert(0, f"# {name}")
        h1_idx = 0
    
    # Check if the next non-empty line is already the desired embed
    insert_idx = h1_idx + 1
    # remove any existing image embed lines immediately after H1 that reference this name (to avoid duplicates)
    changed = False
    # scan up to next 5 lines for an embed referencing .png
    scan_range = list(range(insert_idx, min(insert_idx+6, len(lines))))
    for i in scan_range[::-1]:
        if i < len(lines):
            m = re.search(r'!$$\[(.+?)$$\]', lines[i])
            if m:
                # Replace with the desired embed
                lines[i] = embed_line
                changed = True
                break
    if not changed:
        lines.insert(insert_idx, embed_line)
        changed = True
    
    with open(note_path, 'w', encoding='utf-8', errors='ignore') as f:
        f.write("\n".join(lines))
    return changed

start_time = time.time()
for c in creature_notes:
    sub = c['subfolder']
    if not should_process(sub):
        continue
    name = c['name']
    note_path = c['note_path']
    asset_dir = assets_bestiary_root / sub
    asset_path = asset_dir / f"{name}.png"
    status = {"subfolder": sub, "name": name, "note_path": note_path, "asset_path": str(asset_path),
              "source": None, "page": None, "saved": False, "embed_added": False, "error": None}
    try:
        if not asset_path.exists():
            im, page, area, cands = extract_best_image_for_name(name)
            if im is not None and page is not None:
                # Save the image
                im.save(asset_path)
                status["saved"] = True
                status["source"] = "monster_manual"
                status["page"] = page + 1  # human-readable 1-based
            else:
                status["source"] = "missing_in_mm"
        else:
            status["source"] = "exists"
        # Upsert embed
        embed_done = upsert_embed(note_path, name)
        status["embed_added"] = embed_done
    except Exception as e:
        status["error"] = str(e)
    results.append(status)
    processed_counts[sub] += 1

elapsed = time.time() - start_time
len(results), processed_counts, round(elapsed, 2)

python
# Re-open and rebuild from scratch quickly in this cell (state may be lost due to earlier interrupt).
import os, zipfile, io, re, shutil, time
from pathlib import Path
from collections import defaultdict, Counter
import pandas as pd

from PIL import Image
import fitz

VAULT_ZIP = "/mnt/data/Equgalus Current.zip"
MM_PDF = "/mnt/data/Monster Manual.pdf"

workdir = Path("/mnt/data/work2")
if workdir.exists():
    shutil.rmtree(workdir)
workdir.mkdir(parents=True, exist_ok=True)

outdir = workdir / "vault"
with zipfile.ZipFile(VAULT_ZIP, 'r') as z:
    z.extractall(outdir)

comp_bestiary_root = outdir / "Compendium" / "Bestiary"
assets_bestiary_root = outdir / "Resources" / "Assets" / "Beastiary"

subfolders = ["Beasts", "Monsters", "Non-Beasts", "Story NPCs"]
for sub in subfolders:
    (assets_bestiary_root / sub).mkdir(parents=True, exist_ok=True)

# Gather notes
creature_notes = []
for sub in subfolders:
    folder = comp_bestiary_root / sub
    if not folder.exists():
        continue
    for md in folder.glob("*.md"):
        name = None
        with open(md, 'r', encoding='utf-8', errors='ignore') as f:
            for line in f:
                if line.strip().startswith("#"):
                    name = line.strip().lstrip("#").strip()
                    break
        if not name:
            name = md.stem
        creature_notes.append({"subfolder": sub, "note_path": str(md), "name": name})

# Precompute page texts and page-best images
doc = fitz.open(MM_PDF)
n_pages = len(doc)
start_index = 10
end_index = n_pages - 5
page_texts = [doc[i].get_text().lower() for i in range(start_index, end_index+1)]

def largest_image_for_page(doc, i):
    page = doc[i]
    imgs = page.get_images(full=True)
    best = None
    best_area = 0
    if not imgs:
        return None, 0
    for img in imgs:
        xref = img[0]
        pix = fitz.Pixmap(doc, xref)
        if pix.n >= 5:
            pix = fitz.Pixmap(fitz.csRGB, pix)
        w,h = pix.width, pix.height
        area = w*h
        if area > best_area:
            data = pix.tobytes("png")
            im = Image.open(io.BytesIO(data)).convert("RGBA")
            best = im
            best_area = area
    return best, best_area

page_best = {}
t0 = time.time()
for i in range(start_index, end_index+1):
    im, area = largest_image_for_page(doc, i)
    page_best[i] = (im, area)
t1 = time.time()

def candidate_pages_from_text(name):
    needle = name.lower()
    cands = []
    for idx, text in enumerate(page_texts):
        if needle in text:
            cands.append(start_index + idx)
    return cands

def upsert_embed(note_path, name):
    embed_line = f"![[{name}.png|175]]"
    with open(note_path, 'r', encoding='utf-8', errors='ignore') as f:
        lines = f.read().splitlines()
    # find first H1
    h1_idx = None
    for i, line in enumerate(lines):
        if line.strip().startswith("# "):
            h1_idx = i
            break
    if h1_idx is None:
        lines.insert(0, f"# {name}")
        h1_idx = 0
    insert_idx = h1_idx + 1
    # replace first embed nearby or insert
    replaced = False
    for i in range(insert_idx, min(insert_idx+6, len(lines))):
        if i < len(lines):
            m = re.search(r'!$$\[(.+?)$$\]', lines[i])
            if m:
                lines[i] = embed_line
                replaced = True
                break
    if not replaced:
        lines.insert(insert_idx, embed_line)
    with open(note_path, 'w', encoding='utf-8', errors='ignore') as f:
        f.write("\n".join(lines))

# Process limits to avoid timeouts
limits = {"Monsters": 120, "Beasts": 60, "Non-Beasts": 20, "Story NPCs": 20}
processed_counts = defaultdict(int)

rows = []
for c in creature_notes:
    sub = c['subfolder']
    if processed_counts[sub] >= limits.get(sub, 0):
        continue
    name = c['name']
    note_path = c['note_path']
    asset_path = assets_bestiary_root / sub / f"{name}.png"
    status = {"subfolder": sub, "name": name, "note_path": note_path,
              "asset_path": str(asset_path), "result": None, "mm_page": None}
    try:
        if not asset_path.exists():
            cands = candidate_pages_from_text(name)
            # Choose candidate page with largest image
            best_page = None
            best_area = 0
            best_im = None
            for p in cands:
                im, area = page_best.get(p, (None, 0))
                if im is not None and area > best_area:
                    best_im = im
                    best_area = area
                    best_page = p
            if best_im is not None and best_area > 20000:
                best_im.save(asset_path)
                status["result"] = "saved_from_mm"
                status["mm_page"] = best_page + 1
            else:
                status["result"] = "no_mm_match"
        else:
            status["result"] = "exists"
        # Upsert embed
        upsert_embed(note_path, name)
    except Exception as e:
        status["result"] = f"error: {e}"
    rows.append(status)
    processed_counts[sub] += 1

df = pd.DataFrame(rows)
summary_csv = workdir / "art_insertion_summary.csv"
df.to_csv(summary_csv, index=False)

# Zip the updated vault
output_zip = "/mnt/data/Ithersta_art_update_corrected_partial.zip"
if os.path.exists(output_zip):
    os.remove(output_zip)

with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as z:
    for root, dirs, files in os.walk(outdir):
        for f in files:
            full = Path(root) / f
            rel = full.relative_to(outdir)
            z.write(full, arcname=str(rel))

# Show quick summary counts
processed_counts, df["result"].value_counts().to_dict(), str(output_zip), str(summary_csv)

python
# Retry with a safer image extractor using doc.extract_image for JPX support
import os, zipfile, io, re, shutil, time
from pathlib import Path
from collections import defaultdict, Counter
import pandas as pd

from PIL import Image
import fitz

VAULT_ZIP = "/mnt/data/Equgalus Current.zip"
MM_PDF = "/mnt/data/Monster Manual.pdf"

workdir = Path("/mnt/data/work3")
if workdir.exists():
    shutil.rmtree(workdir)
workdir.mkdir(parents=True, exist_ok=True)

outdir = workdir / "vault"
with zipfile.ZipFile(VAULT_ZIP, 'r') as z:
    z.extractall(outdir)

comp_bestiary_root = outdir / "Compendium" / "Bestiary"
assets_bestiary_root = outdir / "Resources" / "Assets" / "Beastiary"

subfolders = ["Beasts", "Monsters", "Non-Beasts", "Story NPCs"]
for sub in subfolders:
    (assets_bestiary_root / sub).mkdir(parents=True, exist_ok=True)

# Gather notes
creature_notes = []
for sub in subfolders:
    folder = comp_bestiary_root / sub
    if not folder.exists():
        continue
    for md in folder.glob("*.md"):
        name = None
        with open(md, 'r', encoding='utf-8', errors='ignore') as f:
            for line in f:
                if line.strip().startswith("#"):
                    name = line.strip().lstrip("#").strip()
                    break
        if not name:
            name = md.stem
        creature_notes.append({"subfolder": sub, "note_path": str(md), "name": name})

doc = fitz.open(MM_PDF)
n_pages = len(doc)
start_index = 10
end_index = n_pages - 5
page_texts = [doc[i].get_text().lower() for i in range(start_index, end_index+1)]

def largest_image_for_page(doc, i):
    page = doc[i]
    imgs = page.get_images(full=True)
    best_im = None
    best_area = 0
    for img in imgs:
        xref = img[0]
        try:
            info = doc.extract_image(xref)
            img_bytes = info.get("image")
            if not img_bytes:
                continue
            im = Image.open(io.BytesIO(img_bytes)).convert("RGBA")
            w, h = im.size
            area = w*h
            if area > best_area:
                best_im = im
                best_area = area
        except Exception as e:
            continue
    return best_im, best_area

# Precompute largest images per page
page_best = {}
for i in range(start_index, end_index+1):
    im, area = largest_image_for_page(doc, i)
    page_best[i] = (im, area)

def candidate_pages_from_text(name):
    needle = name.lower()
    cands = []
    for idx, text in enumerate(page_texts):
        if needle in text:
            cands.append(start_index + idx)
    return cands

def upsert_embed(note_path, name):
    embed_line = f"![[{name}.png|175]]"
    with open(note_path, 'r', encoding='utf-8', errors='ignore') as f:
        lines = f.read().splitlines()
    # find first H1
    h1_idx = None
    for i, line in enumerate(lines):
        if line.strip().startswith("# "):
            h1_idx = i
            break
    if h1_idx is None:
        lines.insert(0, f"# {name}")
        h1_idx = 0
    insert_idx = h1_idx + 1
    # Replace if there is any embed nearby, else insert
    replaced = False
    for i in range(insert_idx, min(insert_idx+6, len(lines))):
        if i < len(lines):
            m = re.search(r'!$$\[(.+?)$$\]', lines[i])
            if m:
                lines[i] = embed_line
                replaced = True
                break
    if not replaced:
        lines.insert(insert_idx, embed_line)
    with open(note_path, 'w', encoding='utf-8', errors='ignore') as f:
        f.write("\n".join(lines))

# Process with limits
limits = {"Monsters": 120, "Beasts": 60, "Non-Beasts": 20, "Story NPCs": 20}
processed_counts = defaultdict(int)

rows = []
for c in creature_notes:
    sub = c['subfolder']
    if processed_counts[sub] >= limits.get(sub, 0):
        continue
    name = c['name']
    note_path = c['note_path']
    asset_path = assets_bestiary_root / sub / f"{name}.png"
    status = {"subfolder": sub, "name": name, "note_path": note_path,
              "asset_path": str(asset_path), "result": None, "mm_page": None}
    try:
        if not asset_path.exists():
            cands = candidate_pages_from_text(name)
            best_im = None
            best_page = None
            best_area = 0
            for p in cands:
                im, area = page_best.get(p, (None, 0))
                if im is not None and area > best_area:
                    best_im = im
                    best_area = area
                    best_page = p
            if best_im is not None and best_area > 20000:
                best_im.save(asset_path)
                status["result"] = "saved_from_mm"
                status["mm_page"] = best_page + 1
            else:
                status["result"] = "no_mm_match"
        else:
            status["result"] = "exists"
        upsert_embed(note_path, name)
    except Exception as e:
        status["result"] = f"error: {e}"
    rows.append(status)
    processed_counts[sub] += 1

df = pd.DataFrame(rows)
summary_csv = workdir / "art_insertion_summary.csv"
df.to_csv(summary_csv, index=False)

# Zip the updated vault
output_zip = "/mnt/data/Ithersta_art_update_corrected_partial.zip"
if os.path.exists(output_zip):
    os.remove(output_zip)

with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as z:
    for root, dirs, files in os.walk(outdir):
        for f in files:
            full = Path(root) / f
            rel = full.relative_to(outdir)
            z.write(full, arcname=str(rel))

processed_counts, df["result"].value_counts().to_dict(), str(output_zip), str(summary_csv)

python
import os, io, re, zipfile, shutil
from pathlib import Path
from PIL import Image
import fitz

VAULT_ZIP = "/mnt/data/Equgalus Current.zip"
MM_PDF = "/mnt/data/Monster Manual.pdf"

workdir = Path("/mnt/data/work4")
if workdir.exists():
    shutil.rmtree(workdir)
workdir.mkdir(parents=True, exist_ok=True)

outdir = workdir / "vault"
with zipfile.ZipFile(VAULT_ZIP, 'r') as z:
    z.extractall(outdir)

comp_bestiary_root = outdir / "Compendium" / "Bestiary"
assets_bestiary_root = outdir / "Resources" / "Assets" / "Beastiary"

targets = [
    ("Beasts", "Allosaurus"),
    ("Beasts", "Black Bear"),
    ("Beasts", "Bear"),  # will intentionally skip MM art and not place
    ("Monsters", "Aboleth"),
    ("Monsters", "Azer"),
    ("Monsters", "Banshee"),
    ("Monsters", "Ancient Red Dragon"),
    ("Monsters", "Animated Armor"),
]

# open PDF
doc = fitz.open(MM_PDF)
start_index, end_index = 10, len(doc)-5
page_texts = [doc[i].get_text().lower() for i in range(start_index, end_index+1)]

def candidate_pages_from_text(name):
    needle = name.lower()
    cands = []
    for idx, text in enumerate(page_texts):
        if needle in text:
            cands.append(start_index + idx)
    return cands

def largest_image_for_page(doc, i):
    page = doc[i]
    imgs = page.get_images(full=True)
    best = None
    best_area = 0
    for img in imgs:
        xref = img[0]
        try:
            info = doc.extract_image(xref)
            img_bytes = info.get("image")
            if not img_bytes:
                continue
            im = Image.open(io.BytesIO(img_bytes)).convert("RGBA")
            w, h = im.size
            area = w*h
            if area > best_area:
                best = im
                best_area = area
        except Exception:
            continue
    return best, best_area

def upsert_embed(note_path, name):
    embed_line = f"![[{name}.png|175]]"
    with open(note_path, 'r', encoding='utf-8', errors='ignore') as f:
        lines = f.read().splitlines()
    # find first H1
    h1_idx = None
    for i, line in enumerate(lines):
        if line.strip().startswith("# "):
            h1_idx = i
            break
    if h1_idx is None:
        lines.insert(0, f"# {name}")
        h1_idx = 0
    insert_idx = h1_idx + 1
    # replace if nearby embed else insert
    replaced = False
    for i in range(insert_idx, min(insert_idx+6, len(lines))):
        if i < len(lines):
            if re.search(r'!$$\[(.+?)$$\]', lines[i]):
                lines[i] = embed_line
                replaced = True
                break
    if not replaced:
        lines.insert(insert_idx, embed_line)
    with open(note_path, 'w', encoding='utf-8', errors='ignore') as f:
        f.write("\n".join(lines))

report = []

for sub, name in targets:
    note_path = comp_bestiary_root / sub / f"{name}.md"
    asset_dir = assets_bestiary_root / sub
    asset_dir.mkdir(parents=True, exist_ok=True)
    asset_path = asset_dir / f"{name}.png"
    status = {"subfolder": sub, "name": name, "note_exists": note_path.exists(), "asset_saved": False, "source": None}
    if not note_path.exists():
        status["source"] = "note_missing"
        report.append(status)
        continue
    if name == "Bear":
        # intentionally skip MM art to avoid wrong match per your Bear/Black Bear rule
        upsert_embed(str(note_path), name)  # still ensure the link exists (will point to non-existent until filled)
        status["source"] = "skipped_mm_variant_rule"
        report.append(status)
        continue
    # find candidate pages
    cands = candidate_pages_from_text(name)
    best_im, best_area, best_page = None, 0, None
    for p in cands:
        im, area = largest_image_for_page(doc, p)
        if im is not None and area > best_area:
            best_im, best_area, best_page = im, area, p
    if best_im is not None and best_area > 20000:
        best_im.save(asset_path)
        status["asset_saved"] = True
        status["source"] = f"monster_manual_page_{best_page+1}"
        upsert_embed(str(note_path), name)
    else:
        status["source"] = "no_mm_match"
        # still ensure the link placeholder is inserted to be filled later
        upsert_embed(str(note_path), name)
    report.append(status)

# Save a small manifest
import pandas as pd
df = pd.DataFrame(report)
manifest_path = workdir / "manifest_targets.csv"
df.to_csv(manifest_path, index=False)

# Zip partial output
output_zip = "/mnt/data/Ithersta_art_update_targets.zip"
if os.path.exists(output_zip):
    os.remove(output_zip)

with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as z:
    for root, dirs, files in os.walk(outdir):
        for f in files:
            full = Path(root) / f
            rel = full.relative_to(outdir)
            z.write(full, arcname=str(rel))

output_zip, str(manifest_path)

('/mnt/data/Ithersta_art_update_targets.zip',
 '/mnt/data/work4/manifest_targets.csv')