mixdog 1.0.4 → 1.0.5

package/src/runtime/office/authoring/html-browser.mjs

@@ -0,0 +1,61 @@
+// The browser session every HTML authoring route (pptx, pdf, docx, xlsx) lays its document out in: launch, the
+// deadline and abort wiring around the layout work, the failure result, and the photographs of captured elements.
+import { join } from 'node:path';
+
+import { buildPuppeteerLaunchArgs, resolveBrowserLaunchOptions } from '../../shared/browser-launch.mjs';
+import { startChildGuardian } from '../../shared/child-guardian.mjs';
+
+/** Launches the local browser the HTML is laid out in, under a guardian that reaps it with this process. */
+export async function launchHtmlBrowser(label) {
+  const puppeteer = (await import('puppeteer-core')).default;
+  const browser = await puppeteer.launch({
+    headless: true,
+    ...resolveBrowserLaunchOptions(),
+    args: buildPuppeteerLaunchArgs(['--font-render-hinting=none']),
+  });
+  try {
+    startChildGuardian({ childPid: browser.process?.()?.pid, label });
+  } catch {}
+  return browser;
+}
+
+/** Runs `work` against the browser under a deadline and an abort signal, and closes the browser afterwards. */
+export async function runInBrowser(browser, { signal, timeoutMs }, work) {
+  const abort = () => browser.close().catch(() => {});
+  signal?.addEventListener('abort', abort, { once: true });
+  let timer = null;
+  const running = work();
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`HTML layout exceeded ${timeoutMs} ms`)), timeoutMs);
+  });
+  try {
+    return await Promise.race([running, timeout]);
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', abort);
+    await browser.close().catch(() => {});
+  }
+}
+
+/** The result of a route whose browser or layout failed. */
+export function htmlFailure(error, startedAt, extra = {}) {
+  return {
+    ok: false,
+    error: { message: error?.message || String(error) },
+    elapsedMs: Math.round(performance.now() - startedAt),
+    ...extra,
+  };
+}
+
+/** Photographs each element the measure tagged `[attribute="1".."count"]` into `scratch`; index → png path. */
+export async function photographCaptures(page, attribute, count, scratch) {
+  const captures = new Map();
+  for (let index = 1; index <= count; index += 1) {
+    const element = await page.$(`[${attribute}="${index}"]`);
+    if (!element) continue;
+    const path = join(scratch, `capture-${index}.png`);
+    await element.screenshot({ path, omitBackground: true });
+    captures.set(index, path);
+  }
+  return captures;
+}

package/src/runtime/office/authoring/html-document-author.mjs

@@ -0,0 +1,181 @@
+// The `author` action for a Word or Excel target: an HTML document laid out by a local browser and written as native
+// Word (docx-html-runner.mjs) or Excel (xlsx-html-runner.mjs), landed over the target once it was written, then opened
+// as an authored document — measured by the inline audit, rendered, and reviewed beside the browser's own picture of
+// the same HTML: its print for a document, each sheet's section for a workbook.
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { render } from '../core/office-actions.mjs';
+import { documentFormat, officeSessionForDocument } from '../core/office-core.mjs';
+import { createAuthoredSession, exists, fullPath, validatePptxAuthorMode } from '../core/office-sessions.mjs';
+import { inlineOfficeAudit } from '../quality/inline-audit.mjs';
+import { parseAuthoringBrief } from './pptx-brief.mjs';
+import { htmlBriefScript } from './pptx-html-runner.mjs';
+import {
+  landStagedDeck,
+  releaseExistingSession,
+  releaseStagingTarget,
+  stagingTarget,
+  throwIfAuthoringCancelled,
+} from './pptx-author-session.mjs';
+import { runDocxHtmlAuthoring } from './docx-html-runner.mjs';
+import { runXlsxHtmlAuthoring } from './xlsx-html-runner.mjs';
+import { editsReplacedByAuthor, markAuthoredFromHtml } from './html-source-drift.mjs';
+
+const require = createRequire(import.meta.url);
+
+const KINDS = {
+  docx: {
+    run: runDocxHtmlAuthoring,
+    noun: 'a Word file',
+    skill: 'docx',
+    contract: '@page sheet, what becomes a paragraph, a table, a box',
+    left: 'the HTML as the browser printed it',
+    checks:
+      'reading order, page breaks, a box or table that lost its fill or width, type that changed size, a picture that moved',
+  },
+  xlsx: {
+    run: runXlsxHtmlAuthoring,
+    noun: 'an Excel workbook',
+    skill: 'xlsx',
+    contract: 'one <section data-sheet> per worksheet, data-formula, data-chart',
+    left: 'the sheet as the browser drew it',
+    checks:
+      'a card or box that lost its fill, a text cut by its column, a figure that should be a number or a formula, a chart off its place, the printed page',
+  },
+};
+
+// One image per page: the browser's picture of the HTML on the left, the Office render on the right, at one height.
+async function writeComparisons(target, htmlPages, officePages) {
+  const sharp = require('sharp');
+  const height = 1100;
+  const gap = 16;
+  const pairs = [];
+  const count = Math.max(htmlPages.length, officePages.length);
+  const scaled = async (image) => {
+    if (!image?.path) return null;
+    const data = await sharp(image.path).resize({ height }).png().toBuffer();
+    return { data, width: (await sharp(data).metadata()).width };
+  };
+  const blank = async (width) => ({
+    data: await sharp({ create: { width, height, channels: 3, background: '#FFFFFF' } })
+      .png()
+      .toBuffer(),
+    width,
+  });
+  for (let page = 1; page <= count; page += 1) {
+    const left = (await scaled(htmlPages.find((image) => image.page === page))) || (await blank(778));
+    const right =
+      (await scaled(officePages.find((image) => image.page === page && (image.pages?.length || 1) === 1))) ||
+      (await blank(left.width));
+    const path = `${target}.mixdog-compare-page-${page}.png`;
+    await sharp({ create: { width: left.width + right.width + gap, height, channels: 3, background: '#808080' } })
+      .composite([
+        { input: left.data, left: 0, top: 0 },
+        { input: right.data, left: left.width + gap, top: 0 },
+      ])
+      .png()
+      .toFile(path);
+    pairs.push({ page, path });
+  }
+  return pairs;
+}
+
+export async function authorHtmlDocument(args, { cwd, dataDir, signal = null }) {
+  const target = fullPath(String(args.path || args.output || '').trim(), cwd);
+  const format = documentFormat(target);
+  const kind = KINDS[format];
+  if (!kind) throw new Error('author writes .pptx, .pdf, .docx, and .xlsx targets only');
+  const sourcePath = `${target}.mixdog-source.html`;
+  // Without a script the document is authored again from the HTML kept beside it.
+  const fromSource = !String(args.script || '').trim();
+  if (fromSource && !(await exists(sourcePath))) {
+    throw new Error(
+      `author requires script: an HTML document for ${kind.noun} (without one it re-authors from ${sourcePath}, and none is there). Load the \`${kind.skill}\` Skill first (Skill name:"${kind.skill}"): it carries the HTML route (${kind.contract}), then call author again with path and script.`
+    );
+  }
+  const html = fromSource ? await readFile(sourcePath, 'utf8') : String(args.script);
+  if (!/^\s*</.test(html))
+    throw new Error(`author writes ${kind.noun} from an HTML document only (a source that opens with <).`);
+  const mode = validatePptxAuthorMode(args.mode);
+  const held = officeSessionForDocument(target);
+  const replacedEdits = editsReplacedByAuthor(held);
+  if ((await exists(target)) && !held && !fromSource && args.overwrite !== true) {
+    throw new Error(`author target already exists: ${target}; pass overwrite:true to replace it`);
+  }
+  const staging = await stagingTarget(target);
+  let run;
+  let session;
+  try {
+    throwIfAuthoringCancelled(signal);
+    run = await kind.run(html, staging, { target, signal });
+    throwIfAuthoringCancelled(signal);
+    if (!run.ok) {
+      return {
+        ok: false,
+        reason: 'html_failed',
+        output: target,
+        htmlSource: sourcePath,
+        error: run.error,
+        elapsedMs: run.elapsedMs,
+        nextAction: 'Fix the HTML the error names and call author again.',
+      };
+    }
+    await releaseExistingSession(target, signal);
+    await landStagedDeck(staging, target, signal);
+    session = await createAuthoredSession(
+      signal ? { ...args, mode, __signal: signal } : { ...args, mode },
+      cwd,
+      dataDir,
+      target
+    );
+  } finally {
+    await releaseStagingTarget(staging).catch(() => {});
+  }
+  markAuthoredFromHtml(session, sourcePath);
+  const brief = parseAuthoringBrief(htmlBriefScript(html));
+  if (brief.present) session.authoredBrief = brief;
+  const audit = args.audit === false ? null : await inlineOfficeAudit(session);
+  const result = {
+    ok: true,
+    session: session.id,
+    mode: session.mode,
+    backend: session.backend,
+    output: target,
+    bytes: run.bytes,
+    htmlSource: sourcePath,
+    logs: run.logs,
+    ...(replacedEdits ? { replacedEdits } : {}),
+    ...(audit ? { audit } : {}),
+    elapsedMs: run.elapsedMs,
+  };
+  if (args.render === false) {
+    result.nextAction =
+      audit?.status === 'fail'
+        ? audit.nextAction
+        : 'Written and measured, not visually reviewed: call action:render on this session for the page images and reviewToken, then inspect every page before finalizing.';
+    return result;
+  }
+  session.activeSignal = signal;
+  try {
+    const rendered = await render(session, { pages: args.pages, maxWidth: args.maxWidth }, cwd);
+    result.render = {
+      output: rendered.output,
+      pageCount: rendered.pageCount,
+      visualCoverage: rendered.visualCoverage,
+      images: rendered.images,
+      reviewToken: rendered.reviewToken,
+    };
+    result._images = Array.isArray(rendered._images) ? rendered._images : [];
+    if (run.htmlPages?.length) {
+      result.render.compare = await writeComparisons(target, run.htmlPages, rendered.images || []);
+      result.render.htmlPageCount = run.htmlPages.length;
+    }
+  } finally {
+    delete session.activeSignal;
+  }
+  result.nextAction =
+    audit?.status === 'fail'
+      ? `${audit.nextAction} The rendered pages are attached; the visual read starts once the audit passes.`
+      : `Inspect every rendered page beside its compare pair (${kind.left} on the left, the Office render on the right): ${kind.checks}. Fix the HTML (edit ${sourcePath} and call author with no script) for a material difference, or finalize with design: { reviewed: true, reviewToken, critique }.`;
+  return result;
+}

package/src/runtime/office/authoring/html-source-drift.mjs

@@ -0,0 +1,36 @@
+// A document authored from HTML keeps that HTML beside it (`<file>.mixdog-source.html`), and `author` with no script
+// rebuilds the file from it. An edit made to the file itself — a `batch` on the session — is not in that HTML, so
+// the next rebuild drops it without a word: a deck's spacing fixed by moving shapes came back the moment the deck
+// was authored again from its source. The session remembers which HTML it was built from and how many edits have
+// landed since; a batch says so when it changes the file, and the next author says what it replaced.
+
+/** Records the HTML a session's file was just authored from; edits counted from here. */
+export function markAuthoredFromHtml(session, sourcePath) {
+  if (!session) return;
+  session.htmlSource = sourcePath || null;
+  session.htmlSourceEdits = 0;
+}
+
+/** After a batch: counts the edits that landed and returns the notice for the batch result, or null. */
+export function noteBatchAgainstHtml(session, batch) {
+  if (!session?.htmlSource) return null;
+  const changed = Number(batch?.changeSummary?.changed) || 0;
+  if (!changed) return null;
+  session.htmlSourceEdits = (Number(session.htmlSourceEdits) || 0) + changed;
+  return {
+    path: session.htmlSource,
+    current: false,
+    editsSinceAuthor: session.htmlSourceEdits,
+    note: `These edits changed the file, not ${session.htmlSource}. author with no script rebuilds the file from that HTML and drops them: make the same change in the HTML too, or keep finishing this file with batch.`,
+  };
+}
+
+/** Before a re-author replaces the file: what the previous session had edited past its HTML, or null. */
+export function editsReplacedByAuthor(previous) {
+  const count = Number(previous?.htmlSourceEdits) || 0;
+  if (!count) return null;
+  return {
+    count,
+    note: `${count} edit${count === 1 ? '' : 's'} made with batch since the last author ${count === 1 ? 'was' : 'were'} in the replaced file, not in the HTML; the new file does not carry ${count === 1 ? 'it' : 'them'}. Check that the HTML now holds the same fixes.`,
+  };
+}

package/src/runtime/office/authoring/pdf-author-action.mjs

@@ -0,0 +1,266 @@
+// The `author` action for a .pdf target: an HTML document printed by a local
+// browser (pdf-html-runner.mjs), landed over the target only once it printed
+// and passed its checks, then opened as a created PDF for review.
+//
+// Two kinds of document. A flowing one (running text the browser paginates)
+// is checked for what print would cut. Designed pages — one <section
+// class="slide"> per sheet — go through the deck's own frame first: the same
+// browser measure, geometry gate, facts and plan gates, measured audit, and
+// composition receipt the pptx route runs, on a working deck built at the
+// sheet's size and discarded once read; then the browser prints the HTML
+// itself, and finalize asks for the deck's scored critique.
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { render } from '../core/office-actions.mjs';
+import { officeSessionForDocument } from '../core/office-core.mjs';
+import {
+  createAuthoredSession,
+  exists,
+  fullPath,
+  registerHtmlPdfSession,
+  releaseOverwrittenSession,
+} from '../core/office-sessions.mjs';
+import { snapshotPdf } from '../pdf/pdf-adapter.mjs';
+import { inlineOfficeAudit } from '../quality/inline-audit.mjs';
+import { factsGate, parseAuthoringBrief, reviewBriefPromises, reviewSourceGrounding } from './pptx-brief.mjs';
+import { editsReplacedByAuthor, markAuthoredFromHtml } from './html-source-drift.mjs';
+import { hasSlideSections, htmlBriefScript, runPptxHtmlAuthoring } from './pptx-html-runner.mjs';
+import {
+  landStagedDeck,
+  releaseExistingSession,
+  releaseStagingTarget,
+  stagingTarget,
+  throwIfAuthoringCancelled,
+} from './pptx-author-session.mjs';
+import { factsGateResult, gateStagedDeck, geometryGateResult, planGateResult } from './pptx-author-action.mjs';
+import { readCompositionReceipt } from './pptx-review-artifacts.mjs';
+import { receiptForDelivery } from './pptx-receipt.mjs';
+import { frameCanvas, pdfHtmlSourcePath, printHtmlPdf } from './pdf-html-runner.mjs';
+
+const PDF_AUTHOR_NEEDS_SOURCE =
+  'author requires script: an HTML document for a PDF (without one it re-authors from <file>.pdf.mixdog-source.html, and none is there). Load the `pdf` Skill first (Skill name:"pdf"): it carries the page contract (@page size and margins, page breaks, fonts), then call author again with path and script.';
+
+const RENDERED_NEXT_ACTION =
+  'Inspect every rendered page for reading order, page breaks (a heading left at a page foot, a table or figure split), clipping, and legibility; fix the HTML and author again for any defect, or finalize with design: { reviewed: true, reviewToken, critique: [one entry per page] }.';
+
+const UNRENDERED_NEXT_ACTION =
+  'Printed and laid out clean, not visually reviewed: call action:render on this session for the page images and reviewToken, then inspect every page before finalizing.';
+
+const FRAME_RENDERED_NEXT_ACTION =
+  'Inspect every rendered page for message visibility, relevant evidence, legibility, and grouping, then read the sequence for coherence; use the receipt to investigate possible defects. Change the HTML only for an observed problem, or finalize with design: { reviewed: true, reviewToken, critique: [one entry per page with page, verdict, hierarchy, balance, legibility, cohesion, evidence, note, fixes, checks] }.';
+
+const FRAME_UNRENDERED_NEXT_ACTION =
+  'Printed, gated, and measured clean, not visually reviewed: call action:render on this session for the page images and reviewToken, then inspect every page before finalizing with the scored critique.';
+
+// The browser that prints set every line of the PDF; the working deck's PowerPoint text metrics
+// (fit, clipping, box width) describe a renderer the reader never sees.
+const BROWSER_SET_TEXT = ['text_overflow', 'text_clipped', 'text_box_too_narrow'];
+
+// Designed pages through the deck's frame: measured on the sheet, gated, audited, and read into a
+// receipt. `{ refused }` carries the result to return when a gate holds; otherwise the audit and
+// receipt ride on to the printed PDF.
+async function frameDesignedPages(html, target, brief, { args, cwd, dataDir, signal, priorAudit }) {
+  const scratch = await mkdtemp(join(dirname(target), '.mixdog-pdf-frame-'));
+  const deck = join(scratch, 'frame.pptx');
+  try {
+    const run = await runPptxHtmlAuthoring(html, deck, { target, signal, prepare: frameCanvas });
+    throwIfAuthoringCancelled(signal);
+    if (!run.ok) {
+      return {
+        refused: {
+          ok: false,
+          reason: 'html_failed',
+          output: target,
+          error: run.error,
+          elapsedMs: run.elapsedMs,
+          nextAction: 'Fix the HTML the error names and call author again.',
+        },
+      };
+    }
+    if (run.geometry?.length) return { refused: geometryGateResult(target, run) };
+    const gate = await gateStagedDeck(deck, brief);
+    if (gate.blocked) {
+      return {
+        refused: gate.gate === 'plan' ? planGateResult(target, gate, run) : factsGateResult(target, brief, gate, run),
+      };
+    }
+    const shadow = await createAuthoredSession({ mode: 'portable' }, cwd, dataDir, deck);
+    shadow.authoredBrief = brief;
+    // The working deck's pages are paper: its audit holds them to the print type floors.
+    shadow.printSheet = true;
+    if (priorAudit) shadow.inlineAudit = { ...priorAudit };
+    const audit = args.audit === false ? null : await inlineOfficeAudit(shadow, { exclude: BROWSER_SET_TEXT });
+    const receipt = await readCompositionReceipt(shadow);
+    // The deck's design read against the brief, kept for the PDF's qa: the plan's page count and the
+    // facts' locators (the refusing readings already ran as gates).
+    const designIssues = gate.document
+      ? [...reviewBriefPromises(gate.document, brief), ...reviewSourceGrounding(brief)]
+      : [];
+    return { run, audit, receipt, designIssues, rounds: shadow.inlineAudit || null };
+  } finally {
+    await releaseExistingSession(deck, null).catch(() => {});
+    await rm(scratch, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+// A figure the pages show that the brief's facts line does not carry. The
+// gate that refuses a deck only reports here: the document still lands.
+// Page counters ("3 / 12") are chrome, not figures.
+async function factsWarning(target, brief) {
+  if (!brief.present || brief.factsMode === 'sample') return null;
+  const { pages } = await snapshotPdf(target, { maxChars: 100_000, outline: false });
+  const document = {
+    slides: pages.map((page) => ({
+      index: page.index,
+      shapes: [{ text: String(page.text || '').replace(/(^|\n)\s*\d+\s*\/\s*\d+\s*(?=\n|$)/g, '$1') }],
+    })),
+  };
+  const gate = factsGate(document, brief);
+  if (!gate.blocked) return null;
+  return {
+    code: gate.code,
+    pages: gate.slides.map((entry) => ({ page: entry.slide, figures: entry.figures })),
+    message:
+      gate.code === 'facts_missing'
+        ? 'The document shows figures but its BRIEF comment has no facts line; list each figure with its source (F1 <value> — <source>).'
+        : 'These figures appear on the pages but in no fact of the BRIEF comment; add each with its source, or correct the figure.',
+  };
+}
+
+export async function authorPdf(args, { cwd, dataDir, signal = null }) {
+  const target = fullPath(String(args.path || args.output || '').trim(), cwd);
+  // Without a script the PDF is authored again from the HTML kept beside it, so a fix is an edit to
+  // that file rather than the whole document sent again.
+  const fromSource = !String(args.script || '').trim();
+  if (fromSource && !(await exists(pdfHtmlSourcePath(target)))) throw new Error(PDF_AUTHOR_NEEDS_SOURCE);
+  const html = fromSource ? await readFile(pdfHtmlSourcePath(target), 'utf8') : String(args.script);
+  if (!/^\s*</.test(html))
+    throw new Error('author writes a PDF from an HTML document only (a source that opens with <).');
+  const targetExisted = await exists(target);
+  const held = officeSessionForDocument(target);
+  const replacedEdits = editsReplacedByAuthor(held);
+  // Its own source names its own output: re-authoring from it replaces the file without overwrite:true.
+  if (targetExisted && !held && !fromSource && args.overwrite !== true) {
+    throw new Error(`author target already exists: ${target}; pass overwrite:true to replace it`);
+  }
+  // The browser prints beside the target: a failed print or a refused layout
+  // leaves the file on disk and any session holding it untouched.
+  const staging = await stagingTarget(target);
+  const htmlSource = pdfHtmlSourcePath(target);
+  const brief = parseAuthoringBrief(htmlBriefScript(html));
+  const frame = hasSlideSections(html);
+  let framed = null;
+  let run;
+  let session;
+  try {
+    throwIfAuthoringCancelled(signal);
+    if (frame) {
+      framed = await frameDesignedPages(html, target, brief, {
+        args,
+        cwd,
+        dataDir,
+        signal,
+        priorAudit: held?.inlineAudit || null,
+      });
+      if (framed.refused) return framed.refused;
+    }
+    run = await printHtmlPdf(html, staging, { sourcePath: htmlSource, properties: args.properties, frame, signal });
+    throwIfAuthoringCancelled(signal);
+    if (run.ok && frame && run.pageCount !== framed.run.slideCount) {
+      return {
+        ok: false,
+        reason: 'html_failed',
+        output: target,
+        htmlSource,
+        error: {
+          message: `${framed.run.slideCount} section.slide pages printed onto ${run.pageCount} sheets: a page is taller than the sheet, or the CSS hides or stacks pages in print. Keep every section.slide exactly the sheet's size and displayed.`,
+        },
+        elapsedMs: run.elapsedMs,
+        nextAction: 'Fix the HTML the error names and call author again.',
+      };
+    }
+    if (!run.ok) {
+      return {
+        ok: false,
+        reason: run.layout ? 'layout_gate' : 'html_failed',
+        output: target,
+        htmlSource,
+        ...(run.layout ? { findings: run.layout } : { error: run.error }),
+        elapsedMs: run.elapsedMs,
+        nextAction: run.layout
+          ? 'Nothing landed: fix each finding in the HTML (its element and measure are named) and call author again.'
+          : 'Fix the HTML the error names and call author again.',
+      };
+    }
+    await releaseOverwrittenSession(target, true);
+    await landStagedDeck(staging, target, signal);
+    session = await registerHtmlPdfSession(args, dataDir, target, {
+      targetExisted,
+      receipt: { pageCount: run.pageCount, printableArea: run.area },
+    });
+  } finally {
+    await releaseStagingTarget(staging).catch(() => {});
+  }
+  if (brief.present) session.authoredBrief = brief;
+  markAuthoredFromHtml(session, htmlSource);
+  if (frame) {
+    // Designed pages are the author's deck on paper: reviewed and finalized as one.
+    session.authored = true;
+    session.authoredFrame = true;
+    session.frameAudit = framed.audit;
+    session.frameReceipt = framed.receipt;
+    session.frameDesignIssues = framed.designIssues;
+    if (framed.rounds) session.inlineAudit = framed.rounds;
+  }
+  // The facts gate already refused a designed page's unlisted figure; a flowing document only reports it.
+  const facts = frame ? null : await factsWarning(target, brief);
+  const result = {
+    ok: true,
+    session: session.id,
+    mode: session.mode,
+    backend: session.backend,
+    output: target,
+    bytes: run.bytes,
+    pageCount: run.pageCount,
+    printableArea: run.area,
+    ...(frame ? { designedPages: true } : {}),
+    htmlSource,
+    ...(replacedEdits ? { replacedEdits } : {}),
+    warnings: run.warnings,
+    ...(frame && framed.run.logs?.length ? { logs: framed.run.logs } : {}),
+    ...(facts ? { facts } : {}),
+    ...(framed?.audit ? { audit: framed.audit } : {}),
+    elapsedMs: run.elapsedMs + (framed?.run.elapsedMs || 0),
+  };
+  const auditFailed = framed?.audit?.status === 'fail';
+  if (args.render === false) {
+    if (framed?.receipt) result.receipt = receiptForDelivery(framed.receipt, session);
+    result.nextAction = auditFailed
+      ? framed.audit.nextAction
+      : frame
+        ? FRAME_UNRENDERED_NEXT_ACTION
+        : UNRENDERED_NEXT_ACTION;
+    return result;
+  }
+  session.activeSignal = signal;
+  try {
+    const rendered = await render(session, { pages: args.pages, maxWidth: args.maxWidth }, cwd);
+    result.render = {
+      output: rendered.output,
+      pageCount: rendered.pageCount,
+      visualCoverage: rendered.visualCoverage,
+      images: rendered.images,
+      reviewToken: rendered.reviewToken,
+    };
+    // Designed pages: the render read the printed pixels into the receipt and wrote the contact sheet.
+    if (rendered.contactSheet) result.render.contactSheet = rendered.contactSheet;
+    if (rendered.receipt) result.receipt = rendered.receipt;
+    result._images = Array.isArray(rendered._images) ? rendered._images : [];
+  } finally {
+    delete session.activeSignal;
+  }
+  if (auditFailed) {
+    result.nextAction = `${framed.audit.nextAction} The rendered pages are attached; the visual read starts once the audit passes.`;
+  } else result.nextAction = frame ? FRAME_RENDERED_NEXT_ACTION : RENDERED_NEXT_ACTION;
+  return result;
+}