让带公式的 Obsidian 笔记可靠地批量导出为 PDF

'use strict';
const fs=require('node:fs');
const {manifest}=require('./export-core.cjs');
// Read-only: prints JSON to stdout; creates no files and never connects to Obsidian.
try {
  if(process.argv.length!==3) throw Error('Usage: node preflight.cjs <config.json>');
  console.log(JSON.stringify(manifest(JSON.parse(fs.readFileSync(process.argv[2],'utf8').replace(/^\uFEFF/,''))),null,2));
} catch(e) {console.error(e.message);process.exitCode=1;}

'use strict';
const fs=require('node:fs'),path=require('node:path');
const {manifest,run}=require('./export-core.cjs');
const {createAdapter}=require('./obsidian-1.14.4-adapter.cjs');
// Import is inert. Caller supplies the live renderer and the actual Obsidian module.
function probe({app,window:host,obsidian,remote}) {
  if(!app?.vault || !host)throw Error('Not a live Obsidian context');
  // CLI eval does not necessarily expose require('obsidian'). Read the title
  // of this exact application window, and corroborate with CLI version before use.
  const title=remote.getCurrentWindow?.().getTitle();
  const titleVersion=title?.match(/ - Obsidian (\d+\.\d+\.\d+)$/)?.[1];
  const apiVersion=obsidian?.apiVersion;
  if(apiVersion && titleVersion && apiVersion!==titleVersion)throw Error('Conflicting live version evidence');
  const version=apiVersion || titleVersion;
  if(!version)throw Error('Live application version unavailable');
  const windows=remote.BrowserWindow.getAllWindows().filter(w=>!w.isDestroyed())
    .map(w=>({id:w.id,title:w.getTitle()}));
  const busy=!!(host.__calculusBatchRunning || host.__nativePdfAdapterOwner || host.__nativePdfRun);
  return {version,versionSource:apiVersion?'obsidian-api':'current-window-title',vault:app.vault.adapter.basePath,busy,windows,
    compatible:version==='1.14.4',needsWindowReview:windows.length!==1};
}
function start(env,config,{approved=false,stopAfter=null}={}) {
  const check=probe(env);
  if(!approved)throw Error('Explicit execution approval required');
  if(check.busy || check.needsWindowReview)throw Error('Desktop busy or extra windows need review');
  if(!check.compatible)throw Error('Unsupported live application version');
  const plan=manifest(config);
  if(fs.realpathSync(check.vault)!==plan.config.vault)throw Error('Wrong vault');
  if(stopAfter!==null && (!Number.isInteger(stopAfter)||stopAfter<1))throw Error('Invalid stopAfter');
  const host=env.window,adapter=createAdapter({...env,version:check.version});
  let completed=0;
  const original=adapter.exportNote.bind(adapter);
  adapter.exportNote=async(...args)=>{const result=await original(...args);completed++;return result;};
  const control={stop:false,started:new Date().toISOString(),output:plan.config.output,finished:false};
  host.__nativePdfRun=control;
  control.promise=run(config,adapter,{shouldStop:()=>control.stop||(stopAfter!==null&&completed>=stopAfter)})
    .then(state=>{control.status=state.status;return state;})
    .catch(error=>{control.status='failed-before-checkpoint';control.error=String(error);return {status:control.status,error:control.error};})
    .finally(()=>{control.finished=true;if(host.__nativePdfRun===control)delete host.__nativePdfRun;});
  return {started:true,notes:plan.records.length,output:plan.config.output,stopAfter};
}
function stop(env){
  const control=env.window.__nativePdfRun;
  if(!control)return {requested:false,reason:'No active entry-point batch'};
  control.stop=true;return {requested:true,mode:'next-note-boundary'};
}
module.exports={probe,start,stop};

'use strict';
const fs = require('node:fs');
const path = require('node:path');
const crypto = require('node:crypto');
const hash = p => crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex');
const inside = (parent, child) => {
  const rel = path.relative(parent, child);
  return rel === '' || (!rel.startsWith('..' + path.sep) && rel !== '..' && !path.isAbsolute(rel));
};
function resolved(p) {
  let existing = path.resolve(p), suffix = [];
  while (!fs.existsSync(existing)) {
    const parent = path.dirname(existing);
    if (parent === existing) throw Error('Cannot resolve path');
    suffix.unshift(path.basename(existing)); existing = parent;
  }
  return path.join(fs.realpathSync(existing), ...suffix);
}
function normalizedConfig(input) {
  const vault = resolved(input.vault);
  const source = resolved(path.resolve(vault, input.source));
  const output = resolved(path.resolve(vault, input.output));
  if (!fs.statSync(vault).isDirectory() || !inside(vault, source) || source === vault)
    throw Error('Source must be a named subdirectory of the vault');
  if (!fs.statSync(source).isDirectory()) throw Error('Source is not a directory');
  // This prototype deliberately confines writes to the vault.
  if (!inside(vault, output) || output === vault || inside(source, output) || inside(output, source))
    throw Error('Output must be a separate named directory within the vault');
  const o = input.options;
  if (!o || o.pageSize !== 'A4' || typeof o.landscape !== 'boolean' ||
      typeof o.includeName !== 'boolean' || !Number.isInteger(o.scalePercent) ||
      o.scalePercent < 10 || o.scalePercent > 200 || o.marginsType !== 0)
    throw Error('Explicit options required: A4, booleans, 10..200 scalePercent, marginsType=0');
  const timeoutMs = input.timeoutMs ?? 120000;
  if (!Number.isInteger(timeoutMs) || timeoutMs < 10 || timeoutMs > 600000)
    throw Error('Invalid timeoutMs');
  return {vault, source, output, recursive: input.recursive !== false,
    options: {pageSize:o.pageSize,landscape:o.landscape,includeName:o.includeName,
      scalePercent:o.scalePercent,marginsType:o.marginsType}, timeoutMs};
}
function manifest(input) {
  const config = normalizedConfig(input), records = [], outputs = new Set();
  function walk(dir) {
    for (const e of fs.readdirSync(dir, {withFileTypes:true}).sort((a,b)=>a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
      const p = path.join(dir, e.name);
      if (e.isSymbolicLink()) throw Error('Source symlinks are not supported: ' + p);
      if (e.isDirectory()) { if (config.recursive) walk(p); continue; }
      if (!e.isFile() || !/\.md$/i.test(e.name)) continue;
      const relative = path.relative(config.source, p);
      const output = path.join(config.output, relative.replace(/\.md$/i, '.pdf'));
      const key = output.toLowerCase();
      if (outputs.has(key)) throw Error('Case-insensitive output collision: ' + relative);
      outputs.add(key);
      const text = fs.readFileSync(p, 'utf8');
      records.push({source:p, relative, output, sourceSha256:hash(p), status:'pending',
        svgEmbeds:(text.match(/!\[\[[^\]\n]*\.svg(?:\|[^\]]*)?\]\]/gi)||[]).length,
        chemistrySyntax:/\\(?:ce|pu)\s*\{|MHC-N/.test(text),
        outputExists:fs.existsSync(output)});
    }
  }
  walk(config.source);
  if(input.files!==undefined) {
    if(!Array.isArray(input.files)||!input.files.length||input.files.some(x=>typeof x!=='string'))
      throw Error('files must be a nonempty array of source-relative Markdown paths');
    const selected=new Set(input.files.map(x=>x.replace(/\\/g,'/')));
    if(selected.size!==input.files.length)throw Error('Duplicate selected file');
    const found=records.filter(r=>selected.has(r.relative.split(path.sep).join('/')));
    if(found.length!==selected.size)throw Error('Selected file not found within source scope');
    records.splice(0,records.length,...found);
  }
  if (!records.length) throw Error('No Markdown notes selected');
  const identity = {source:config.source, output:config.output, recursive:config.recursive,
    options:config.options, records:records.map(r=>({relative:r.relative, sourceSha256:r.sourceSha256}))};
  const fingerprint = crypto.createHash('sha256').update(JSON.stringify(identity)).digest('hex');
  return {schemaVersion:1, config, fingerprint, records};
}
function atomicJson(file, value) {
  const temp = file + '.' + crypto.randomUUID() + '.tmp';
  fs.writeFileSync(temp, JSON.stringify(value, null, 2), {flag:'wx'});
  fs.renameSync(temp, file);
}
function canReuse(record, old) {
  return !!(old && old.status === 'exported' && old.sourceSha256 === record.sourceSha256 &&
    old.output === record.output && old.outputSha256 && old.resourceChecksPassed === true &&
    fs.existsSync(record.output) && fs.statSync(record.output).isFile() &&
    hash(record.output) === old.outputSha256);
}
async function withDeadline(task, ms, onTimeout) {
  let timer;
  try {
    return await Promise.race([Promise.resolve().then(task), new Promise((_, reject)=>{
      timer=setTimeout(()=>{ onTimeout(); reject(Object.assign(Error('NOTE_TIMEOUT'),{code:'NOTE_TIMEOUT'})); },ms);
    })]);
  } finally { clearTimeout(timer); }
}
// Adapter contract: exportNote(record, options, signal) resolves only after the
// native operation has settled; abortAndConfirm() resolves true only when no
// native writer can still touch the output. false/throw retains the disk lock.
async function run(input, adapter, controls = {}) {
  const plan = manifest(input), {config} = plan;
  if (!adapter || typeof adapter.exportNote !== 'function') throw Error('Adapter required');
  // Validate parent realpaths again at the point of write; reject linked output trees.
  for(const r of plan.records) {
    if(resolved(r.output)!==r.output) throw Error('Linked output path is not allowed');
  }
  fs.mkdirSync(config.output,{recursive:true});
  const statePath=path.join(config.output,'.native-pdf-state.json');
  const lockPath=path.join(config.output,'.native-pdf-lock.json');
  const lock=fs.openSync(lockPath,'wx');
  fs.writeFileSync(lock,JSON.stringify({pid:process.pid,started:new Date().toISOString()}));
  fs.closeSync(lock);
  let safeToUnlock=true, checkpointStarted=false;
  const state={...plan,status:'running',started:new Date().toISOString(),adapter:adapter.identity || 'unidentified'};
  const save=()=>atomicJson(statePath,state);
  let active;
  try {
    state.renderFingerprint=adapter.renderFingerprint?await adapter.renderFingerprint(state.records):null;
    const previous=fs.existsSync(statePath)?JSON.parse(fs.readFileSync(statePath,'utf8')):null;
    if(previous && previous.fingerprint !== plan.fingerprint) throw Error('Manifest/settings changed; choose a new output directory');
    if(previous && previous.renderFingerprint!==state.renderFingerprint) throw Error('Rendering dependencies changed; choose a new output directory');
    // Preflight every collision before starting any native work.
    for (const r of state.records) {
      if (!fs.existsSync(r.output)) continue;
      const old=previous?.records.find(x=>x.relative===r.relative);
      if (!canReuse(r,old)) throw Error('Unverified existing output: '+r.relative);
      Object.assign(r,old,{reused:true});
    }
    checkpointStarted=true;save();
    for(const r of state.records) {
      if(controls.shouldStop?.()) {state.status='stopped';break;}
      if(r.status==='exported') continue;
      if(adapter.renderFingerprint && await adapter.renderFingerprint(state.records)!==state.renderFingerprint)
        throw Error('Rendering dependencies changed during batch');
      if(hash(r.source)!==r.sourceSha256) throw Error('Source changed before export');
      active=r; r.status='rendering';save();
      const controller=new AbortController();
      const result=await withDeadline(()=>adapter.exportNote(r,config.options,controller.signal),
        config.timeoutMs,()=>{safeToUnlock=false;controller.abort();});
      if(!result || result.resourceChecksPassed!==true) throw Error('Resource readiness not verified');
      if(hash(r.source)!==r.sourceSha256) throw Error('Source changed during export');
      if(!fs.existsSync(r.output)||fs.statSync(r.output).size===0) throw Error('No output');
      // Only basic signature validation here. Full PDF inspection is a later stage.
      const fd=fs.openSync(r.output,'r'), header=Buffer.alloc(5);
      try {fs.readSync(fd,header,0,5,0);} finally {fs.closeSync(fd);}
      if(header.toString()!=='%PDF-') throw Error('Invalid PDF signature');
      Object.assign(r,{status:'exported',outputSha256:hash(r.output),bytes:fs.statSync(r.output).size,
        resourceChecksPassed:true,resourceEvidence:result.evidence || {},finished:new Date().toISOString()});
      active=null;save();
    }
    if(state.status==='running') state.status='exported-awaiting-audit';
  } catch(e) {
    if(active) active.status='needs-review';
    state.status=e.code==='NOTE_TIMEOUT'?'needs-review':'failed';
    state.error=String(e.stack || e);
    if(!safeToUnlock) {
      try {safeToUnlock=(await withDeadline(()=>adapter.abortAndConfirm?.(),2000,()=>{}))===true;}
      catch {safeToUnlock=false;}
    }
  } finally {
    try {
      state.renderDependenciesUnchanged=!adapter.renderFingerprint ||
        await adapter.renderFingerprint(state.records)===state.renderFingerprint;
    } catch(e) {state.renderDependenciesUnchanged=false;state.cleanupError=String(e);}
    if(!state.renderDependenciesUnchanged)state.status='needs-review';
    state.allSourcesUnchanged=state.records.every(r=>fs.existsSync(r.source)&&hash(r.source)===r.sourceSha256);
    if(!state.allSourcesUnchanged) state.status='needs-review';
    state.finished=new Date().toISOString();state.lockRetained=!safeToUnlock;
    if(checkpointStarted) save();
    else atomicJson(path.join(config.output,'.native-pdf-last-attempt.json'),state);
    if(safeToUnlock) fs.unlinkSync(lockPath);
  }
  return state;
}
module.exports={manifest,run,canReuse,withDeadline,hash};

'use strict';
const fs=require('node:fs'),path=require('node:path'),crypto=require('node:crypto');
const digest=x=>crypto.createHash('sha256').update(x).digest('hex');
function createAdapter(env) {
  const {app,window:host,version,remote}=env;
  if(version!=='1.14.4') throw Error('Unsupported Obsidian version: '+version);
  if(!app?.vault?.adapter?.basePath || !host || !remote?.BrowserWindow) throw Error('Missing desktop context');
  const proto=Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(app.setting)));
  if(typeof proto?.animateOpen!=='function'||typeof proto.open!=='function') throw Error('Modal prototype mismatch');
  const view=app.workspace.getLeavesOfType('markdown').map(l=>l.view).find(v=>typeof v.printToPdf==='function');
  if(!view) throw Error('No compatible Markdown view');
  if(host.__calculusBatchRunning || host.__nativePdfAdapterOwner) throw Error('Another export is active');
  const token=crypto.randomUUID(),ownerKey='__nativePdfAdapterOwner';
  let active=null;
  const root=fs.realpathSync(app.vault.adapter.basePath);
  const windowAlive=w=>!w.isDestroyed();
  const allWindows=()=>remote.BrowserWindow.getAllWindows().filter(windowAlive);
  function fingerprint() {
    // Session identity deliberately forbids reuse after app restart. Dependency and
    // settings hashes additionally detect changes inside the same renderer session.
    if(!host.__nativePdfSessionId) host.__nativePdfSessionId=crypto.randomUUID();
    const sheets=[...host.document.styleSheets].map(s=>[...s.cssRules].map(r=>r.cssText).join('\n'));
    return digest(JSON.stringify({version,session:host.__nativePdfSessionId,sheets,
      pdfSettings:app.vault.getConfig('pdfExportSettings')}));
  }
  // Called by the orchestrator with selected records. Resolve cached embeds
  // transitively; missing cache/links and remote resources fail closed.
  function dependencies(records) {
    const visited=new Set(),rows=[];
    function visit(relative) {
      if(visited.has(relative)) return;visited.add(relative);
      const file=app.vault.getAbstractFileByPath(relative);
      if(!file?.extension) throw Error('Missing embedded file: '+relative);
      const absolute=fs.realpathSync(path.join(root,relative));
      const rel=path.relative(root,absolute);
      if(rel.startsWith('..'+path.sep)||path.isAbsolute(rel)) throw Error('Embedded file outside vault');
      rows.push([relative,digest(fs.readFileSync(absolute))]);
      if(file.extension.toLowerCase()!=='md') return;
      const text=fs.readFileSync(absolute,'utf8');
      if(/<\s*(?:img|iframe|video|audio)\b|!\[[^\]]*\]\(\s*(?:https?:|data:|file:)/i.test(text))
        throw Error('Untracked external/HTML embed requires manual adaptation: '+relative);
      const cache=app.metadataCache.getFileCache(file);
      if(!cache) throw Error('Metadata cache not ready: '+relative);
      for(const embed of cache.embeds||[]) {
        const dest=app.metadataCache.getFirstLinkpathDest(embed.link.split('#')[0],relative);
        if(!dest) throw Error('Unresolved embed: '+embed.link);
        visit(dest.path);
      }
    }
    for(const r of records)visit(path.relative(root,r.source).split(path.sep).join('/'));
    return rows.sort((a,b)=>a[0]<b[0]?-1:a[0]>b[0]?1:0);
  }
  async function findOwned(ctx,doc) {
    doc.defaultView.__nativePdfWindowToken=ctx.token;
    const candidates=allWindows().filter(w=>!ctx.before.has(w.id));
    for(const w of candidates) {
      // Matching a random marker in the rendering document proves identity;
      // basename/title matching is deliberately not used.
      const match=await w.webContents.executeJavaScript('globalThis.__nativePdfWindowToken === '+JSON.stringify(ctx.token));
      if(match) ctx.owned.set(w.id,w);
    }
    if(ctx.owned.size!==1) throw Error('Cannot uniquely identify native print window');
  }
  async function exportNote(record,options,signal) {
    if(active || host.__nativePdfAdapterOwner || host.__calculusBatchRunning) throw Error('Another export is active');
    if(signal?.aborted) throw Error('Aborted before native export');
    const relative=path.relative(root,record.source).split(path.sep).join('/');
    if(relative.startsWith('../')||path.isAbsolute(relative)) throw Error('Source outside vault');
    const file=app.vault.getAbstractFileByPath(relative);
    if(!file || file.extension!=='md') throw Error('Markdown file unavailable');
    if(fs.existsSync(record.output)) throw Error('Output exists');
    const ctx={token:token+'-'+crypto.randomUUID(),before:new Set(allWindows().map(w=>w.id)),
      owned:new Map(),nativeStarted:false,settled:false,ready:false,errors:[],stage:record.output+'.'+crypto.randomUUID()+'.partial.pdf'};
    active=ctx;host[ownerKey]=ctx.token;
    let exporter,renderError;
    const check=()=>{if(signal?.aborted)throw Error('Export aborted');};
    try {
      const originalOpen=proto.open;
      try {
        proto.open=function(...args){
          if(this.file===file && typeof this.printToPdf==='function') {exporter=this;return;}
          return originalOpen.apply(this,args);
        };
        view.printToPdf.call({app,file});
      } finally {proto.open=originalOpen;}
      if(typeof exporter?.print!=='function') throw Error('Native exporter shape mismatch');
      const nativePrint=exporter.print;
      exporter.print=async function(container,component,includeName) {
        try {
          await nativePrint.call(this,container,component,includeName);check();
          const doc=container.ownerDocument;
          await findOwned(ctx,doc);check();
          container.getBoundingClientRect();
          const chemistry=record.chemistrySyntax || !!container.querySelector('.MHC-N');
          const faces=[...doc.fonts].filter(f=>/MJX|MathJax/i.test(f.family) && (f.family!=='MJX-MHC-N'||chemistry));
          await Promise.all(faces.map(f=>f.load()));check();
          await doc.fonts.ready;check();
          const images=[...container.querySelectorAll('img')];
          await Promise.all(images.map(i=>i.decode()));check();
          if(images.some(i=>!i.complete||!i.naturalWidth)) throw Error('Image not ready');
          if(faces.some(f=>f.status!=='loaded')) throw Error('Math font not loaded');
          container.getBoundingClientRect();
          await new Promise(r=>setTimeout(r,1500));check();
          ctx.evidence={fonts:faces.map(f=>({family:f.family,status:f.status})),
            images:images.map(i=>({complete:i.complete,width:i.naturalWidth})),
            mathCount:container.querySelectorAll('mjx-container').length,chemistry,
            windowIds:[...ctx.owned.keys()]};
          ctx.ready=true;
        } catch(e) {renderError=e;throw e;}
      };
      fs.mkdirSync(path.dirname(record.output),{recursive:true});
      try {
        ctx.nativeStarted=true;
        await exporter.printToPdf({includeName:options.includeName,pageSize:options.pageSize,
          landscape:options.landscape,marginsType:options.marginsType,
          scaleFactor:options.scalePercent,scale:options.scalePercent/100,open:false,filepath:ctx.stage});
      } finally {ctx.settled=true;}
      check();
      if(renderError)throw renderError;
      if(!ctx.ready)throw Error('Native renderer readiness hook was not completed');
      if(!fs.existsSync(ctx.stage)||!fs.statSync(ctx.stage).size)throw Error('Native export missing');
      // Publish without overwrite. A late native writer can only reach staging.
      fs.copyFileSync(ctx.stage,record.output,fs.constants.COPYFILE_EXCL);fs.unlinkSync(ctx.stage);
      return {resourceChecksPassed:true,evidence:ctx.evidence};
    } finally {
      // Close only marker-verified task-owned windows. No title-based cleanup.
      for(const w of ctx.owned.values()) if(windowAlive(w))w.destroy();
      if(ctx.settled || !ctx.nativeStarted) {
        if(host[ownerKey]===ctx.token)delete host[ownerKey];
        active=null;
      }
    }
  }
  return {
    identity:'obsidian-native-1.14.4-v1',
    renderFingerprint(records){return digest(JSON.stringify({runtime:fingerprint(),dependencies:dependencies(records)}));},
    exportNote,
    async abortAndConfirm(){
      if(!active)return true;
      for(const w of active.owned.values())if(windowAlive(w))w.destroy();
      // Destroying a window is not enough to prove an asynchronous writer stopped.
      return active.settled && [...active.owned.values()].every(w=>!windowAlive(w));
    }
  };
}
module.exports={createAdapter};

"""Read PDFs without modifying them; write a new audit/preview directory only."""
import argparse
import hashlib
import json
from pathlib import Path
import fitz


def audit(pdf):
    row = {"file": str(pdf), "sha256": hashlib.sha256(pdf.read_bytes()).hexdigest(), "issues": []}
    try:
        with fitz.open(pdf) as doc:
            row["pages"] = len(doc)
            row["bytes"] = pdf.stat().st_size
            if not len(doc):
                row["issues"].append({"type": "no-pages"})
            for p in doc:
                n = p.number + 1
                if abs(p.rect.width - 595.3) > 2 or abs(p.rect.height - 841.9) > 2:
                    row["issues"].append({"page": n, "type": "not-A4-portrait"})
                text = p.get_text()
                if not text.strip() and not p.get_images() and not p.get_drawings():
                    row["issues"].append({"page": n, "type": "blank"})
                if "\ufffd" in text:
                    row["issues"].append({"page": n, "type": "replacement-character"})
                if any(b[0] < -2 or b[1] < -2 or b[2] > p.rect.width + 2 or b[3] > p.rect.height + 2 for b in p.get_text("blocks")):
                    row["issues"].append({"page": n, "type": "out-of-page-text"})
    except Exception as e:
        row["issues"].append({"type": "unreadable", "error": str(e)})
    return row


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("source", type=Path)
    parser.add_argument("report_dir", type=Path)
    parser.add_argument("--preview", action="store_true", help="Render first/middle pages for manual review")
    parser.add_argument("--all-pages", action="store_true", help="Render every page for small-sample visual review")
    args = parser.parse_args()
    source = args.source.resolve(strict=True)
    dest = args.report_dir.resolve()
    if dest == source or source in dest.parents or dest in source.parents:
        parser.error("Report directory must be separate from PDF input")
    files = sorted(source.rglob("*.pdf")) if source.is_dir() else [source]
    if not files:
        parser.error("No PDFs selected")
    if any(p.is_symlink() for p in files):
        parser.error("Symlink inputs not supported")
    dest.mkdir(parents=True, exist_ok=False)
    rows = []
    for i, pdf in enumerate(files, 1):
        row = audit(pdf)
        if (args.preview or args.all_pages) and "pages" in row and row["pages"]:
            try:
                with fitz.open(pdf) as doc:
                    row["previews"] = []
                    for n in (range(len(doc)) if args.all_pages else sorted({0, len(doc) // 2})):
                        out = dest / f"{i:03}-page-{n+1:03}.png"
                        doc[n].get_pixmap(matrix=fitz.Matrix(1.2, 1.2)).save(out)
                        row["previews"].append(str(out))
            except Exception as e:
                row["issues"].append({"type": "preview-failed", "error": str(e)})
        rows.append(row)
    result = {"status": "needs-review" if any(r["issues"] for r in rows) else "structural-checks-passed",
              "files": len(rows), "pages": sum(r.get("pages", 0) for r in rows),
              "bytes": sum(r.get("bytes", 0) for r in rows), "visualReview": "not-performed",
              "limitations": "No source/resource coverage comparison; no proof of complete glyphs or layout. A4 portrait only.",
              "records": rows}
    (dest / "audit.json").write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps({k: v for k, v in result.items() if k != "records"}, ensure_ascii=False))
    return 1 if result["status"] == "needs-review" else 0


if __name__ == "__main__":
    raise SystemExit(main())