primocode 10.13.0 → 10.14.0

package/lib/estudio/dados/projetos-ae/processo-motion-100-ia/take-unico/oraculo_take.py

@@ -0,0 +1,137 @@
+"""oraculo_take.py — confere um take único antes de alguém assistir, e exporta os eventos para a trilha.
+
+  python oraculo_take.py comp/index.html --video render/demo.mp4            # relatório (pernas abaixo)
+  python oraculo_take.py comp/index.html --eventos audio/eventos.json       # só exporta window.__events()
+
+Pernas (inspiradas no verify/probe do onetake, 05-pesquisa/referencias/2026-10-12-onetake-take-unico.md):
+- continuidade: em cada fronteira de __meta.batidas, algo de __track(t) aparece na tela dos dois lados e anda ≥ 2 % da
+  diagonal ou muda ≥ 10 % de tamanho em ±0,25 s (carried); só um objeto grande parado (anchored, vale ½); nada (bare).
+  Nota = (carried + anchored/2) / fronteiras. Reprova < 0,5, alerta < 0,7. Cega a carry feito de dois elementos.
+- enquadramento: cada id de __meta.inFrame = {id: [t0, t1]} fica com o centro dentro do quadro (margem 40 px).
+- velocidade: pico de __motion por quadro; acima de ~80 px/quadro precisa do obturador (render_take.py já faz).
+- vídeo: fração de quadros de baixa energia (respiros) e trecho calmo mais longo; saltos (diferença 3× a mediana
+  dos vizinhos); na nossa regra a câmera nunca para, então "parado" aqui é energia baixa, não zero.
+- áudio: loudness integrada (alvo −14 LUFS no narrado) e pico.
+"""
+import argparse, json, subprocess, sys
+from pathlib import Path
+sys.stdout.reconfigure(encoding="utf-8")
+import numpy as np
+
+
+def pagina(comp, fn):
+    from playwright.sync_api import sync_playwright
+    path, _, q = comp.partition("?")
+    url = Path(path).resolve().as_uri() + ("?" + q if q else "")
+    with sync_playwright() as p:
+        br = p.chromium.launch()
+        pg = br.new_context(viewport={"width": 1080, "height": 1920}).new_page()
+        pg.goto(url); pg.evaluate("window.__ready")
+        r = fn(pg)
+        br.close()
+    return r
+
+
+def continuidade(pg, meta):
+    W, H = meta.get("w", 1080), meta.get("h", 1920)
+    diag = (W * W + H * H) ** 0.5
+    dentro = lambda b: b and b["w"] > 1 and b["x"] + b["w"] > 0 and b["x"] < W and b["y"] + b["h"] > 0 and b["y"] < H
+    res = []
+    for tb in meta.get("batidas", []):
+        A = pg.evaluate(f"window.__track({tb - 0.25})"); B = pg.evaluate(f"window.__track({tb + 0.25})")
+        tipo, quem = "bare", ""
+        for k in A:
+            a, b = A[k], B.get(k)
+            if not (dentro(a) and dentro(b)):
+                continue
+            anda = ((a["x"] + a["w"] / 2 - b["x"] - b["w"] / 2) ** 2 + (a["y"] + a["h"] / 2 - b["y"] - b["h"] / 2) ** 2) ** 0.5
+            esc = abs((b["w"] * b["h"]) ** 0.5 / max(1, (a["w"] * a["h"]) ** 0.5) - 1)
+            if anda >= 0.02 * diag or esc >= 0.10:
+                tipo, quem = "carried", k; break
+            if a["w"] * a["h"] >= 0.03 * W * H:
+                tipo, quem = "anchored", k
+        res.append((tb, tipo, quem))
+    nota = sum(1 if t == "carried" else 0.5 if t == "anchored" else 0 for _, t, _ in res) / max(1, len(res))
+    return nota, res
+
+
+def enquadramento(pg, meta, fps=10):
+    W, H, falhas = meta.get("w", 1080), meta.get("h", 1920), []
+    for k, (t0, t1) in meta.get("inFrame", {}).items():
+        for t in np.arange(t0, t1, 1 / fps):
+            b = pg.evaluate(f"window.__track({t})").get(k)
+            if not b: continue
+            cx, cy = b["x"] + b["w"] / 2, b["y"] + b["h"] / 2
+            if not (40 <= cx <= W - 40 and 40 <= cy <= H - 40):
+                falhas.append((k, round(float(t), 2)))
+    return falhas
+
+
+def velocidade(pg, meta, fps=30):
+    dur = meta["dur"]; v = pg.evaluate(f"(() => {{ const r = []; for (let f = 0; f < {int(dur * fps) - 1}; f++) r.push(window.__motion(f / {fps}, (f + 1) / {fps})); return r; }})()")
+    i = int(np.argmax(v)); return float(v[i]), i / fps, float(np.mean(np.array(v) > 80))
+
+
+def video(vid):
+    """Energia entre quadros em fluxo (um quadro por vez: um vídeo de 2 min não cabe inteiro na memória) e fps lido do arquivo."""
+    w, h = 192, 341
+    r = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=r_frame_rate", "-of", "csv=p=0", vid], capture_output=True, text=True).stdout.strip()
+    n_, d_ = (r.split("/") + ["1"])[:2]; fps = float(n_) / float(d_ or 1)
+    pr = subprocess.Popen(["ffmpeg", "-v", "error", "-i", vid, "-vf", f"scale={w}:{h},format=gray", "-f", "rawvideo", "-"], stdout=subprocess.PIPE)
+    tam, ant, dl = w * h, None, []
+    while True:
+        b = pr.stdout.read(tam)
+        if len(b) < tam: break
+        q = np.frombuffer(b, np.uint8).astype(np.int16)
+        if ant is not None: dl.append(float(np.abs(q - ant).mean()))
+        ant = q
+    pr.wait()
+    d = np.array(dl)
+    baixo = d < 0.4
+    maior, cur = 0, 0
+    for b in baixo:
+        cur = cur + 1 if b else 0; maior = max(maior, cur)
+    saltos = [round((i + 1) / fps, 2) for i in range(2, len(d) - 2) if d[i] > 3 * max(np.median(np.r_[d[i - 2:i], d[i + 1:i + 3]]), 0.3) and d[i] > 1.5]
+    return float(baixo.mean()), maior / fps, saltos
+
+
+def audio(vid):
+    try:
+        import pyloudnorm as pyln, soundfile as sf
+        tmp = Path(vid).with_suffix(".oraculo.wav")
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", vid, "-vn", "-ac", "2", "-ar", "48000", str(tmp)], check=True)
+        x, sr = sf.read(str(tmp)); tmp.unlink()
+        return pyln.Meter(sr).integrated_loudness(x), 20 * np.log10(np.abs(x).max() + 1e-9)
+    except Exception as e:
+        return None, str(e)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("comp"); ap.add_argument("--video"); ap.add_argument("--eventos")
+    a = ap.parse_args()
+    if a.eventos:
+        ev = pagina(a.comp, lambda pg: pg.evaluate("window.__events()"))
+        json.dump(ev, open(a.eventos, "w", encoding="utf-8"), indent=1); print(len(ev["events"]), "eventos →", a.eventos); return
+    def tudo(pg):
+        meta = pg.evaluate("window.__meta")
+        return meta, continuidade(pg, meta), enquadramento(pg, meta), velocidade(pg, meta)
+    meta, (nota, res), falhas, (pico, tpico, rapido) = pagina(a.comp, tudo)
+    ok = True
+    print(f"continuidade {nota:.2f} sobre {len(res)} fronteiras " + ("REPROVA" if nota < 0.5 else "alerta" if nota < 0.7 else "ok"))
+    for tb, tipo, quem in res: print(f"   {tb:6.2f}s  {tipo:8s} {quem}")
+    ok &= nota >= 0.5
+    print(f"enquadramento: {'ok' if not falhas else 'FALHA ' + str(falhas[:8])}"); ok &= not falhas
+    print(f"velocidade: pico {pico:.0f} px/quadro a {tpico:.2f}s; {rapido:.0%} dos quadros acima de 80 px (obturador obrigatório)")
+    if a.video:
+        bx, calmo, saltos = video(a.video)
+        print(f"respiros: {bx:.0%} de quadros com energia baixa, trecho calmo mais longo {calmo:.1f}s " + ("ok" if bx >= 0.25 else "poucos respiros"))
+        print(f"saltos: {saltos or 'nenhum'} (todo salto tem de ser corte de propósito)")
+        L, pk = audio(a.video)
+        if L is not None: print(f"áudio: {L:.1f} LUFS, pico {pk:.1f} dBFS")
+    print("RESULTADO:", "PASSA" if ok else "REPROVA")
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

package/lib/estudio/dados/projetos-ae/processo-motion-100-ia/take-unico/render_take.py

@@ -0,0 +1,388 @@
+"""render_take.py — renderiza uma composição seek(t) do take único, com desfoque de movimento de obturador real.
+
+  python render_take.py comp/index.html --out render/demo-v1.mp4 --audio audio/mix.wav        # 30 qps, 1080x1920
+  python render_take.py comp/index.html --out render/demo-v1-60.mp4 --fps 60 --audio audio/mix.wav
+  python render_take.py comp/index.html --stills 0.5,3,6.2 --out revisao/stills-v1.png       # folha de quadros
+  python render_take.py comp/index.html --out render/previa.mp4 --previa --audio audio/mix.wav   # prévia em ~1 min
+  python render_take.py comp/index.html --out render/final.mp4 --fps 60 --trechos 4 --turbo --audio audio/mix.wav
+      # final: refaz só os trechos de 4 s que mudaram desde o último render (cache em render/_trechos/)
+
+Contrato da página: window.__ready (Promise), window.__seek(t) → Promise (resolve com as imagens decodificadas),
+window.__meta = {dur, w, h}; opcional window.__motion(t0, t1) → px que algo anda na tela entre t0 e t1.
+
+Obturador: cada quadro é a média, em luz linear, de S capturas espalhadas em `--shutter` graus em volta do instante
+do quadro. Primeiro captura as duas pontas: se forem iguais, nada mexeu e o quadro sai sem custo. S vem do __motion
+(cópias a no máximo `--gap` px uma da outra, entre --smin e --smax); sem __motion, --samples. Se um único passo entre
+capturas vizinhas concentra a mudança (corte seco, letra que aparece), só se média o lado do corte que contém o
+instante do quadro: corte continua corte, não vira dissolve. Vários Chromium em paralelo (--workers).
+Método do onetake (05-pesquisa/referencias/2026-10-12-onetake-take-unico.md), código nosso.
+
+Velocidade (13/10, medido no Reel Soldier; ver 07-videos/projetos/2026-10-13-video-mais-rapido/README.md):
+captura pelo CDP com optimizeForSpeed (PNG sem perda, mesmos pixels), Chromium na GPU (padrão; --sem-gpu volta ao
+SwiftShader), --previa (sem obturador, JPEG, resolução cheia: 62 s em ~22 s) e --trechos N (hash de cada quadro numa
+passada rápida na CPU; só os trechos que mudaram são refeitos, o resto vem do cache e é emendado sem recodificar).
+"""
+import argparse, base64, hashlib, io, json, math, multiprocessing as mp, os, shutil, subprocess, sys, time
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+sys.stdout.reconfigure(encoding="utf-8")
+
+_u = np.arange(256) / 255.0
+S2L = np.where(_u <= 0.04045, _u / 12.92, ((_u + 0.055) / 1.055) ** 2.4).astype(np.float32)
+_l = np.arange(65536) / 65535.0
+L2S = np.clip(np.rint(np.where(_l <= 0.0031308, _l * 12.92, 1.055 * np.power(_l, 1 / 2.4) - 0.055) * 255), 0, 255).astype(np.uint8)
+
+
+def url_de(comp):
+    path, _, q = comp.partition("?")
+    return Path(path).resolve().as_uri() + ("?" + q if q else "")
+
+
+def lado_do_corte(pngs):
+    """Índices das capturas a integrar: todas, a não ser que um passo carregue a mudança (≥ 3× qualquer outro)."""
+    n = len(pngs)
+    if n < 4:
+        return list(range(n))
+    small = [np.asarray(Image.open(io.BytesIO(p)).convert("L").reduce(8), np.int16) for p in pngs]
+    d = np.array([np.abs(small[k + 1] - small[k]).mean() for k in range(n - 1)])
+    j = int(d.argmax())
+    if d[j] <= 0 or d[j] < 3 * np.delete(d, j).max():
+        return list(range(n))
+    return list(range(j + 1, n)) if j < n // 2 else list(range(j + 1))
+
+
+def integrar(pngs):
+    keep = lado_do_corte(pngs)
+    acc = None
+    for k in keep:
+        lin = S2L[np.asarray(Image.open(io.BytesIO(pngs[k])).convert("RGB"))]
+        acc = lin if acc is None else acc + lin
+    return L2S[np.clip(np.rint(acc * (65535.0 / len(keep))), 0, 65535).astype(np.uint16)], len(keep) < len(pngs)
+
+
+GPU_ARGS = ["--enable-gpu", "--use-angle=d3d11", "--ignore-gpu-blocklist"]
+
+
+def abrir(p, a):
+    args = ["--force-color-profile=srgb", "--disable-lcd-text", "--font-render-hinting=none"]
+    br = p.chromium.launch(args=args + (GPU_ARGS if a.get("gpu") else []))
+    pg = br.new_context(viewport={"width": a["w"], "height": a["h"]}, device_scale_factor=a["scale"]).new_page()
+    erros = []
+    pg.on("pageerror", lambda e: erros.append(str(e)))
+    pg.on("console", lambda m: erros.append(m.text) if m.type == "error" else None)
+    pg.goto(url_de(a["comp"]))
+    pg.evaluate("window.__ready")
+    pg._cdp = pg.context.new_cdp_session(pg)
+    return br, pg, erros
+
+
+def capturar(pg, a):
+    """PNG sem perda (padrão) ou JPEG (prévia), direto pelo CDP com optimizeForSpeed. Com escala < 1 o CDP
+    devolveria a imagem no tamanho cheio: o clip com a mesma escala mantém o tamanho real (ex.: 270×480 a 0,25)."""
+    if a["captura"] == "playwright":
+        return pg.screenshot(type="png")
+    opts = {"format": "jpeg", "quality": 90} if a["captura"] == "jpeg" else {"format": "png"}
+    if a["scale"] != 1:
+        opts["clip"] = {"x": 0, "y": 0, "width": a["w"], "height": a["h"], "scale": a["scale"]}
+    return base64.b64decode(pg._cdp.send("Page.captureScreenshot", dict(opts, optimizeForSpeed=True))["data"])
+
+
+def trabalhador(a):
+    from playwright.sync_api import sync_playwright
+    st = {"capturas": 0, "parados": 0, "cortes": 0, "erros": [], "hist": {}}
+    fps, dur, aberto = a["fps"], a["dur"], (a["shutter"] / 360.0) / a["fps"]
+    with sync_playwright() as p:
+        br, pg, erros = abrir(p, a)
+        adapt = a["shutter"] > 0 and pg.evaluate("typeof window.__motion === 'function'")
+
+        def grab(t):
+            pg.evaluate(f"window.__seek({t:.6f})")
+            st["capturas"] += 1
+            return capturar(pg, a)
+
+        feitos = 0
+        quadros = a["lista"][a["k"]::a["n"]] if a.get("lista") else range(a["f0"] + a["k"], a["f1"], a["n"])
+        for f in quadros:
+            if feitos and feitos % 200 == 0:          # Chrome que tira milhares de capturas cresce; recicla
+                br.close(); br, pg, erros2 = abrir(p, a); erros += erros2
+            feitos += 1
+            t, out = f / fps, os.path.join(a["dir"], f"{f:05d}.{a['ext']}")
+            if a.get("retomar") and os.path.exists(out) and os.path.getsize(out) > 0:
+                continue
+            if a["shutter"] <= 0:
+                open(out, "wb").write(grab(t)); continue
+            S = a["samples"]
+            if adapt:
+                try:
+                    far = pg.evaluate(f"window.__motion({max(t - aberto / 2, 0):.6f}, {min(t + aberto / 2, dur - 1e-6):.6f})")
+                    S = min(a["smax"], max(a["smin"], math.ceil(far * a["scale"] / a["gap"])))
+                except Exception:
+                    pass
+            ts = [min(max(t + aberto * ((i + 0.5) / S - 0.5), 0.0), dur - 1e-6) for i in range(S)]
+            ini, fim = grab(ts[0]), grab(ts[-1])
+            if ini == fim:
+                open(out, "wb").write(ini); st["parados"] += 1; continue
+            pngs = [ini] + [grab(x) for x in ts[1:-1]] + [fim]
+            img, corte = integrar(pngs)
+            st["cortes"] += corte
+            if a["ext"] == "jpg":
+                Image.fromarray(img).save(out, quality=92)
+            else:
+                Image.fromarray(img).save(out, compress_level=1)
+            st["hist"][S] = st["hist"].get(S, 0) + 1
+        br.close()
+    st["erros"] = erros[:5]
+    return st
+
+
+def trabalhador_seguro(a):
+    """O navegador (ou o driver do Playwright) às vezes cai num render longo: reabre e continua de onde parou."""
+    for tentativa in range(4):
+        # a partir da 3ª tentativa sem GPU: "Unable to capture screenshot" da GPU às vezes se repete (13/10); na CPU nunca falhou
+        gpu = a.get("gpu") and tentativa < 2
+        try:
+            return trabalhador(dict(a, retomar=a.get("retomar") or tentativa > 0, gpu=gpu))
+        except Exception as e:
+            print(f"navegador {a['k']} caiu ({type(e).__name__}: {str(e)[:80]}), tentativa {tentativa + 2}"
+                  + ("" if tentativa < 1 or not a.get("gpu") else " sem GPU"), flush=True)
+            time.sleep(2)
+    raise RuntimeError(f"navegador {a['k']} caiu 4 vezes")
+
+
+def info(a):
+    from playwright.sync_api import sync_playwright
+    with sync_playwright() as p:
+        br, pg, erros = abrir(p, a)
+        m = pg.evaluate("window.__meta || {}")
+        br.close()
+    return m, erros
+
+
+def stills(a, times, out):
+    from playwright.sync_api import sync_playwright
+    ims = []
+    with sync_playwright() as p:
+        br, pg, erros = abrir(p, a)
+        for t in times:
+            pg.evaluate(f"window.__seek({t})")
+            ims.append(Image.open(io.BytesIO(pg.screenshot(type="png"))).convert("RGB"))
+        br.close()
+    cols = min(len(ims), a.get("cols") or 6)
+    th = 640; tw = round(ims[0].width * th / ims[0].height)
+    rows = math.ceil(len(ims) / cols)
+    folha = Image.new("RGB", (cols * tw, rows * (th + 34)), (24, 24, 24))
+    dr = ImageDraw.Draw(folha)
+    try:
+        fonte = ImageFont.truetype("arial.ttf", 24)
+    except OSError:
+        fonte = ImageFont.load_default()
+    for i, (t, im) in enumerate(zip(times, ims)):
+        x, y = (i % cols) * tw, (i // cols) * (th + 34)
+        folha.paste(im.resize((tw, th), Image.LANCZOS), (x, y + 34))
+        dr.text((x + 8, y + 4), f"{t:.2f} s", fill=(255, 220, 90), font=fonte)
+    folha.save(out)
+    print("folha:", out, "erros:", erros[:3] or "nenhum")
+
+
+def commit_livre_gb():
+    """Memória que o Windows ainda pode comprometer (RAM + arquivo de paginação). Sem isso o render derruba o PC."""
+    try:
+        import ctypes
+        class M(ctypes.Structure):
+            _fields_ = [("a", ctypes.c_ulong), ("b", ctypes.c_ulong)] + [(n, ctypes.c_ulonglong) for n in "cdefghi"]
+        m = M(); m.a = ctypes.sizeof(M)
+        ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m))
+        return m.f / 2**30
+    except Exception:
+        return 999.0
+
+
+GB_POR_NAVEGADOR, GB_RESERVA = 1.8, 6.0   # medido em 13/10: 8 navegadores no final a 60 qps = 14 GB
+
+
+def renderizar(job, f0, f1, pasta, lista=None):
+    """Quadros f0..f1-1 (ou só os de `lista`) em `pasta` (nome = número absoluto do quadro), em job['n'] navegadores."""
+    pasta.mkdir(parents=True, exist_ok=True)
+    n = max(1, min(job["n"], len(lista) if lista else f1 - f0))
+    with mp.get_context("spawn").Pool(n) as pool:
+        res = pool.map(trabalhador_seguro, [dict(job, dir=str(pasta), f0=f0, f1=f1, n=n, k=k, lista=lista) for k in range(n)])
+    tot = {"capturas": 0, "parados": 0, "cortes": 0, "hist": {}, "erros": []}
+    for r in res:
+        for k in ("capturas", "parados", "cortes"):
+            tot[k] += r[k]
+        for k, v in r["hist"].items():
+            tot["hist"][k] = tot["hist"].get(k, 0) + v
+        tot["erros"] += r["erros"]
+    return tot
+
+
+def codificar(pasta, f0, f1, ext, fps, out, crf, preset, audio=None, de=0.0):
+    seq = pasta / "_seq"
+    shutil.rmtree(seq, ignore_errors=True); seq.mkdir()
+    for i, f in enumerate(range(f0, f1)):          # renumera a partir de 0 para o ffmpeg (sem mover o original)
+        src = pasta / f"{f:05d}.{ext}"
+        try:
+            os.link(src, seq / f"q{i:05d}.{ext}")
+        except OSError:
+            shutil.copy2(src, seq / f"q{i:05d}.{ext}")
+    cmd = ["ffmpeg", "-v", "error", "-y", "-framerate", str(fps), "-i", str(seq / f"q%05d.{ext}")]
+    if audio:
+        cmd += ["-ss", f"{de:.3f}", "-i", audio]
+    cmd += ["-c:v", "libx264", "-preset", preset, "-crf", str(crf), "-pix_fmt", "yuv420p", "-movflags", "+faststart",
+            "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"]
+    if audio:
+        cmd += ["-af", "apad", "-c:a", "aac", "-b:a", "256k", "-shortest"]   # apad: a voz acabar antes não corta o vídeo
+    subprocess.run(cmd + [str(out)], check=True)
+    shutil.rmtree(seq, ignore_errors=True)
+
+
+DIGITAIS_N = 8   # sempre o mesmo: o Chromium guarda estado entre seeks e outro nº de navegadores muda ~6% dos quadros
+
+
+def digitais(job, f0, f1, pasta):
+    """Impressão digital de cada quadro (hash), para saber o que mudou desde o último render. Captura em escala 1,
+    na CPU, JPEG, sem obturador: assim o Chromium desenha o mesmo quadro bit a bit (medido em 13/10: 0 de 160
+    diferentes). Na GPU (157 de 1.200) e em escala reduzida (11 de 160) o mesmo quadro varia entre passadas, e com
+    outro número de navegadores também (226 de 3.720): por isso DIGITAIS_N fixo."""
+    shutil.rmtree(pasta, ignore_errors=True)
+    n = DIGITAIS_N
+    cabe = max(2, int((commit_livre_gb() - GB_RESERVA) / 1.3))
+    if cabe < n:
+        print(f"memória curta: digitais em {cabe} navegadores (o cache pode refazer trechos que não mudaram)", flush=True)
+        n = cabe
+    renderizar(dict(job, n=n, scale=1, shutter=0, captura="jpeg", ext="jpg", retomar=False, gpu=False), f0, f1, pasta)
+    out = {f: hashlib.sha1((pasta / f"{f:05d}.jpg").read_bytes()).hexdigest()[:16] for f in range(f0, f1)}
+    shutil.rmtree(pasta, ignore_errors=True)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("comp"); ap.add_argument("--out", required=True)
+    ap.add_argument("--fps", type=int, default=30); ap.add_argument("--scale", type=float, default=None)
+    ap.add_argument("--shutter", type=float, default=None); ap.add_argument("--samples", type=int, default=8)
+    ap.add_argument("--gap", type=float, default=18); ap.add_argument("--smin", type=int, default=3); ap.add_argument("--smax", type=int, default=16)
+    ap.add_argument("--workers", type=int, default=None)
+    ap.add_argument("--de", type=float, default=0); ap.add_argument("--ate", type=float, default=None)
+    ap.add_argument("--audio"); ap.add_argument("--crf", type=int, default=None)
+    ap.add_argument("--stills"); ap.add_argument("--cols", type=int, default=6)
+    ap.add_argument("--manter-quadros", action="store_true")
+    ap.add_argument("--retomar", action="store_true", help="mantém os quadros de um render que caiu e faz só os que faltam")
+    ap.add_argument("--previa", action="store_true", help="rápida: sem obturador (sem desfoque de movimento), JPEG; para ver, não para entregar")
+    ap.add_argument("--turbo", action="store_true", help="usa o PC inteiro (mais navegadores); para o render final")
+    ap.add_argument("--trechos", type=float, default=0, help="segundos por trecho: refaz só os trechos que mudaram (cache)")
+    ap.add_argument("--refazer", help="com --trechos: 'a,b' em segundos = o que você mexeu; pula as digitais e refaz só esses trechos")
+    ap.add_argument("--sem-gpu", action="store_true", help="Chromium sem GPU (SwiftShader), como antes de 13/10")
+    ap.add_argument("--captura", choices=["png", "jpeg", "playwright"], default=None)
+    a = ap.parse_args()
+    cpu = os.cpu_count() or 4
+    if a.previa:
+        scale, shutter, captura, crf, preset = a.scale or 1, 0 if a.shutter is None else a.shutter, a.captura or "jpeg", a.crf or 23, "veryfast"
+    else:
+        scale, shutter, captura, crf, preset = a.scale or 1, 180 if a.shutter is None else a.shutter, a.captura or "png", a.crf or 16, "medium"
+    workers = a.workers or (12 if a.turbo else min(10, cpu - 2))   # acima de ~12 não rende mais (medido) e alguns travam
+    livre = commit_livre_gb()
+    cabe = max(2, int((livre - GB_RESERVA) / GB_POR_NAVEGADOR))
+    if workers > cabe:
+        print(f"memória: {livre:.0f} GB livres → {cabe} navegadores em vez de {workers}", flush=True)
+        workers = cabe
+    ext = "jpg" if captura == "jpeg" else "png"
+    base = dict(comp=a.comp, scale=scale, w=1080, h=1920, cols=a.cols, gpu=not a.sem_gpu, captura=captura, ext=ext)
+    meta, erros = info(base)
+    base.update(w=int(meta.get("w", 1080)), h=int(meta.get("h", 1920)))
+    if a.stills:
+        return stills(base, [float(x) for x in a.stills.split(",")], a.out)
+    dur = float(meta.get("dur", 10)); ate = a.ate if a.ate is not None else dur
+    out = Path(a.out).resolve(); out.parent.mkdir(parents=True, exist_ok=True)
+    f0, f1 = round(a.de * a.fps), round(ate * a.fps)
+    job = dict(base, fps=a.fps, dur=dur, n=workers, shutter=shutter, samples=a.samples, gap=a.gap, smin=a.smin, smax=a.smax, retomar=a.retomar)
+    modo = "prévia" if a.previa else ("turbo" if a.turbo else "normal")
+    print(f"{f1 - f0} quadros · {modo} · {workers} navegadores · escala {scale:g} · obturador {shutter:g}° · captura {captura}"
+          f" · GPU {'sim' if base['gpu'] else 'não'} · erros na carga: {erros[:2] or 'nenhum'}", flush=True)
+    t0 = time.time()
+    rel = {"fps": a.fps, "shutter": shutter, "scale": scale, "captura": captura, "gpu": base["gpu"], "workers": workers,
+           "modo": modo, "quadros": f1 - f0}
+
+    if a.trechos > 0:
+        N = max(1, round(a.trechos * a.fps))
+        cfg = f"{a.fps}qps-{scale:g}x-obt{shutter:g}-{captura}-crf{crf}-{base['w']}x{base['h']}"
+        cache = out.parent / "_trechos" / cfg
+        cache.mkdir(parents=True, exist_ok=True)
+        segs = [(max(s, f0), min(s + N, f1)) for s in range((f0 // N) * N, f1, N)]
+        if a.refazer:   # atalho: quem mexeu diz onde; sem digitais (o .sha desses trechos fica sem valer)
+            ra, rb = (float(x) for x in a.refazer.split(","))
+            fa, fb = math.floor(ra * a.fps), math.ceil(rb * a.fps)
+            dig = None
+        else:
+            dig = digitais(job, f0, f1, out.parent / ("_digitais-" + out.stem))
+        t_dig = time.time() - t0
+        tot, lista, mudou = {"capturas": 0, "parados": 0, "cortes": 0}, [], []
+        for s, e in segs:
+            mp4, sha = cache / f"t{s:05d}-{e:05d}.mp4", cache / f"t{s:05d}-{e:05d}.sha"
+            lista.append(mp4)
+            tem = mp4.exists() and mp4.stat().st_size > 0
+            if dig is None:
+                if not tem or (e > fa and s <= fb):
+                    mudou.append((s, e, mp4))
+                    sha.unlink(missing_ok=True)
+                    sha.with_suffix(".novo").write_text("")
+                continue
+            novo = hashlib.sha1("|".join(dig[f] for f in range(s, e)).encode()).hexdigest()
+            if not (tem and sha.exists() and sha.read_text().strip() == novo):
+                mudou.append((s, e, mp4))
+                sha.with_suffix(".novo").write_text(novo)
+        feitos, reaproveitados = len(mudou), len(segs) - len(mudou)
+        print(f"{len(segs)} trechos de {a.trechos:g} s · {feitos} mudaram, {reaproveitados} vêm do cache "
+              f"(digitais em {t_dig:.0f} s)", flush=True)
+        pasta = cache / "_quadros"
+        lote = []
+        for i, (s, e, mp4) in enumerate(mudou):          # lotes de até ~900 quadros: um pool só por lote
+            lote.append((s, e, mp4))
+            if i == len(mudou) - 1 or sum(b - a_ for a_, b, _ in lote) + (mudou[i + 1][1] - mudou[i + 1][0]) > 900:
+                shutil.rmtree(pasta, ignore_errors=True)
+                r = renderizar(job, 0, 0, pasta, lista=[f for s_, e_, _ in lote for f in range(s_, e_)])
+                for k in tot:
+                    tot[k] += r[k]
+                for s_, e_, mp4_ in lote:
+                    codificar(pasta, s_, e_, ext, a.fps, mp4_, crf, preset)
+                    nv = mp4_.with_suffix(".novo")
+                    if nv.read_text():
+                        os.replace(nv, mp4_.with_suffix(".sha"))   # só depois do mp4 pronto
+                    else:
+                        nv.unlink()
+                lote = []
+        shutil.rmtree(pasta, ignore_errors=True)
+        lst = cache / "_lista.txt"
+        lst.write_text("".join(f"file '{m.as_posix()}'\n" for m in lista), encoding="utf-8")
+        tmp = out.with_name(out.stem + "._junta.mp4")
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-f", "concat", "-safe", "0", "-i", str(lst), "-c", "copy", str(tmp)], check=True)
+        cmd = ["ffmpeg", "-v", "error", "-y", "-i", str(tmp)]
+        if a.audio:
+            cmd += ["-ss", f"{a.de:.3f}", "-i", a.audio, "-map", "0:v", "-map", "1:a", "-af", "apad", "-c:a", "aac", "-b:a", "256k", "-shortest"]
+        cmd += ["-c:v", "copy", "-movflags", "+faststart"]
+        subprocess.run(cmd + [str(out)], check=True)
+        tmp.unlink()
+        seg = time.time() - t0
+        print(f"{len(segs)} trechos de {a.trechos:g} s: {feitos} refeitos, {reaproveitados} do cache · digitais {t_dig:.0f} s · total {seg:.0f} s")
+        rel.update(trechos=len(segs), refeitos=feitos, reaproveitados=reaproveitados, segundos_digitais=round(t_dig, 1), **tot)
+    else:
+        fr = out.parent / ("_quadros-" + out.stem)
+        if not a.retomar:
+            shutil.rmtree(fr, ignore_errors=True)
+        tot = renderizar(job, f0, f1, fr)
+        print(f"{tot['capturas']} capturas, {tot['parados']} quadros parados, {tot['cortes']} cortes mantidos secos, "
+              f"{time.time() - t0:.0f} s; erros: {tot['erros'][:3] or 'nenhum'}")
+        codificar(fr, f0, f1, ext, a.fps, out, crf, preset, a.audio, a.de)
+        if not a.manter_quadros:
+            shutil.rmtree(fr, ignore_errors=True)
+        seg = time.time() - t0
+        rel.update(capturas=tot["capturas"], parados=tot["parados"], cortes=tot["cortes"],
+                   amostras_por_quadro={str(k): tot["hist"][k] for k in sorted(tot["hist"])})
+    rel["segundos"] = round(seg, 1)
+    json.dump(rel, open(out.with_suffix(".render.json"), "w"), indent=1)
+    print(f"ok: {out} ({seg:.0f} s)")
+
+
+if __name__ == "__main__":
+    main()