mixdog 1.0.3 → 1.0.5

package/src/runtime/office/authoring/pdf-html-runner.mjs

@@ -0,0 +1,317 @@
+// The `author` action's PDF route: a local Chrome/Edge lays an HTML document
+// out under its own @page rules and prints it. Before printing, the document
+// is laid out at the printable width and read for what print would silently
+// cut or move — a block wider than the page, a picture that never loaded —
+// so the file lands only when it holds. Designed pages (section.slide on the
+// sheet) are measured and gated as a deck first (pdf-author-action.mjs) and
+// printed here one page per sheet.
+import { readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { PDFDict, PDFDocument, PDFHexString, PDFName } from 'pdf-lib';
+
+import { htmlFailure, launchHtmlBrowser, runInBrowser } from './html-browser.mjs';
+import { applyDocumentProperties } from '../pdf/pdf-writer.mjs';
+import { iconTable, injectIcons } from './pptx-html-measure.mjs';
+import { drawDataCharts } from './pdf-html-charts.mjs';
+
+// Runs inside the page: every h1-h3 as the browser names it in the outline (its text with the line
+// breaks dropped) and as a reader sees it (a <br> read as a space).
+function headingTitles() {
+  return [...document.querySelectorAll('h1, h2, h3')].map((heading) => ({
+    raw: heading.textContent || '',
+    shown: (heading.innerText || '').replace(/\s+/g, ' ').trim(),
+  }));
+}
+
+// The browser names a bookmark after its heading's text with the line breaks dropped, so a title set
+// on two lines ("…틀로<br>설계하고") reads "…틀로설계하고". Each such outline entry takes the heading
+// as shown. Returns how many titles changed.
+function repairOutlineTitles(document, headings) {
+  const key = (text) => String(text || '').replace(/\s+/g, '');
+  const shown = new Map();
+  for (const heading of headings) if (heading.shown) shown.set(key(heading.raw), heading.shown);
+  const outlines = document.catalog.lookupMaybe(PDFName.of('Outlines'), PDFDict);
+  let changed = 0;
+  const seen = new Set();
+  const walk = (node) => {
+    while (node && !seen.has(node)) {
+      seen.add(node);
+      const title = node.get(PDFName.of('Title'));
+      const text = typeof title?.decodeText === 'function' ? title.decodeText() : '';
+      const fixed = shown.get(key(text));
+      if (fixed && fixed !== text) {
+        node.set(PDFName.of('Title'), PDFHexString.fromText(fixed));
+        changed += 1;
+      }
+      walk(node.lookupMaybe(PDFName.of('First'), PDFDict));
+      node = node.lookupMaybe(PDFName.of('Next'), PDFDict);
+    }
+  };
+  walk(outlines?.lookupMaybe(PDFName.of('First'), PDFDict));
+  return changed;
+}
+
+/** The HTML as laid out, kept beside the PDF so relative <img> paths resolve and a re-author starts from it. */
+export function pdfHtmlSourcePath(target) {
+  return `${target}.mixdog-source.html`;
+}
+
+// CSS px per unit (96 px to the inch) and the named sheets in millimetres, portrait.
+const PX_PER_UNIT = { px: 1, in: 96, cm: 96 / 2.54, mm: 96 / 25.4, q: 96 / 101.6, pt: 96 / 72, pc: 16 };
+const NAMED_SHEETS_MM = {
+  a3: [297, 420],
+  a4: [210, 297],
+  a5: [148, 210],
+  b4: [250, 353],
+  b5: [176, 250],
+  letter: [215.9, 279.4],
+  legal: [215.9, 355.6],
+  ledger: [279.4, 431.8],
+};
+
+function lengthPx(token, what) {
+  const match = /^(-?\d*\.?\d+)([a-z]+)?$/i.exec(String(token).trim());
+  const unit = (match?.[2] || (Number(match?.[1]) === 0 ? 'px' : '')).toLowerCase();
+  if (!match || !PX_PER_UNIT[unit]) {
+    throw new Error(`@page ${what} "${token}" is not a length; write it in mm, cm, in, pt, or px.`);
+  }
+  return Number(match[1]) * PX_PER_UNIT[unit];
+}
+
+/** The printable area in CSS px from the @page size and margins the document declared. */
+export function printableArea(rule) {
+  const tokens = String(rule?.size || '')
+    .trim()
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+  if (!tokens.length || tokens[0] === 'auto') {
+    throw new Error(
+      'The document declares no @page size; open the stylesheet with `@page { size: A4; margin: 18mm }` (or letter, A5 landscape, 148mm 210mm).'
+    );
+  }
+  let landscape = false;
+  const lengths = [];
+  let named = null;
+  for (const token of tokens) {
+    if (token === 'landscape') landscape = true;
+    else if (token === 'portrait') landscape = false;
+    else if (NAMED_SHEETS_MM[token]) named = NAMED_SHEETS_MM[token].map((mm) => mm * PX_PER_UNIT.mm);
+    else lengths.push(lengthPx(token, 'size'));
+  }
+  let [width, height] = named || [lengths[0], lengths[1] ?? lengths[0]];
+  if (!(width > 0 && height > 0)) throw new Error(`@page size "${rule.size}" names no sheet.`);
+  if (named && landscape) [width, height] = [height, width];
+  const margin = Object.fromEntries(
+    ['top', 'right', 'bottom', 'left'].map((side) => [
+      side,
+      rule.margin?.[side] ? lengthPx(rule.margin[side], `margin-${side}`) : 0,
+    ])
+  );
+  return {
+    sheet: { width, height },
+    margin,
+    width: width - margin.left - margin.right,
+    height: height - margin.top - margin.bottom,
+  };
+}
+
+// Runs inside the page: the unnamed @page rules that apply to print, later declarations winning.
+export function readPageRule() {
+  const out = { size: '', margin: {} };
+  const visit = (list) => {
+    for (const rule of list) {
+      if (rule instanceof CSSPageRule && !rule.selectorText) {
+        const size = rule.style.getPropertyValue('size');
+        if (size) out.size = size;
+        for (const side of ['top', 'right', 'bottom', 'left']) {
+          const value = rule.style.getPropertyValue(`margin-${side}`);
+          if (value) out.margin[side] = value;
+        }
+      } else if (rule instanceof CSSMediaRule && window.matchMedia(rule.conditionText).matches) {
+        visit(rule.cssRules);
+      }
+    }
+  };
+  for (const sheet of document.styleSheets) {
+    try {
+      visit(sheet.cssRules);
+    } catch {}
+  }
+  return out;
+}
+
+/**
+ * The canvas of a PDF's designed pages (the deck contract, pptx-html-measure.mjs): the sheet the document
+ * declares, printed full-bleed, in CSS px at 96 to the inch. Runs on the page the measure has loaded.
+ */
+export async function frameCanvas(page) {
+  await page.emulateMediaType('print');
+  const area = printableArea(await page.evaluate(readPageRule));
+  if (Object.values(area.margin).some((margin) => margin > 0.5)) {
+    throw new Error(
+      'Designed pages print full-bleed: declare `@page { size: A4; margin: 0 }` and give each section.slide the whole sheet (width: 210mm; height: 297mm), with the margins inside it.'
+    );
+  }
+  // The viewport takes whole px; the working deck is sized from those same px so 1 px stays exactly
+  // 0.75 pt (A4's 793.7 px rounded to 794 is 0.2 pt wider, and a 22 pt title stays 22 pt).
+  const width = Math.round(area.sheet.width);
+  const height = Math.round(area.sheet.height);
+  return { width, height, inchWidth: width / 96, inchHeight: height / 96 };
+}
+
+// Designed pages print one section.slide per sheet whatever the screen CSS does; speaker notes stay off the page.
+const FRAME_PRINT_CSS = `section.slide { break-after: page; break-inside: avoid; }
+section.slide:last-of-type { break-after: auto; }
+aside.notes { display: none !important; }`;
+
+// Runs inside the page, laid out at the printable width under print media.
+// Errors refuse the document; warnings ride on the result. Designed pages
+// are measured on their canvas before printing, so only their pictures are read here.
+function measurePrintLayout(area, frame) {
+  const describe = (element) => {
+    const id = element.id ? `#${element.id}` : '';
+    const className = typeof element.className === 'string' ? element.className.trim() : '';
+    const classes = className ? `.${className.split(/\s+/).join('.')}` : '';
+    const text = (element.textContent || '').replace(/\s+/g, ' ').trim().slice(0, 40);
+    return `<${element.localName}${id}${classes}>${text ? ` "${text}"` : ''}`;
+  };
+  const px = (value) => Math.round(value);
+  const findings = [];
+  for (const image of document.images) {
+    const src = image.getAttribute('src') || '';
+    if (/^(?:https?:)?\/\//i.test(src)) {
+      findings.push({
+        code: 'remote_image',
+        severity: 'error',
+        element: describe(image),
+        message: `${src} is a web address; save the picture beside the document or inline it as a data: URI.`,
+      });
+    } else if (!image.complete || image.naturalWidth === 0) {
+      findings.push({
+        code: 'image_missing',
+        severity: 'error',
+        element: describe(image),
+        message: `${src || '(no src)'} did not load; the path resolves from the PDF's folder.`,
+      });
+    }
+  }
+  if (frame) return { findings };
+  const clipped = (element) => {
+    for (let parent = element.parentElement; parent && parent !== document.body; parent = parent.parentElement) {
+      if (getComputedStyle(parent).overflowX !== 'visible') return true;
+    }
+    return false;
+  };
+  const outside = (box) => box.right > area.width + 1 || box.left < -1;
+  const tall = new Set();
+  for (const element of document.body.querySelectorAll('*')) {
+    const style = getComputedStyle(element);
+    if (style.display === 'none' || style.position === 'fixed') continue;
+    const box = element.getBoundingClientRect();
+    if (!box.width && !box.height) continue;
+    const parent = element.parentElement;
+    if (
+      outside(box) &&
+      !clipped(element) &&
+      !(parent && parent !== document.body && outside(parent.getBoundingClientRect()))
+    ) {
+      findings.push({
+        code: 'overflow_x',
+        severity: 'error',
+        element: describe(element),
+        message: `spans ${px(box.left)}–${px(box.right)} px of a ${px(area.width)} px printable width; print cuts what lies past the margin.`,
+      });
+    }
+    const unbreakable =
+      ['img', 'svg', 'canvas', 'video'].includes(element.localName) ||
+      ['avoid', 'avoid-page'].includes(style.breakInside);
+    if (unbreakable && box.height > area.height + 1) {
+      let ancestor = element.parentElement;
+      while (ancestor && !tall.has(ancestor)) ancestor = ancestor.parentElement;
+      tall.add(element);
+      if (!ancestor) {
+        findings.push({
+          code: 'unbreakable_too_tall',
+          severity: 'warning',
+          element: describe(element),
+          message: `is ${px(box.height)} px tall and may not break, but a page holds ${px(area.height)} px; print splits it anyway. Shorten it or let it break.`,
+        });
+      }
+    }
+  }
+  return { findings };
+}
+
+/**
+ * Lays out and prints an HTML document to `output`.
+ * @param {string} html the document
+ * @param {string} output where the PDF is written (a staging file beside the target)
+ * @param {{ sourcePath: string, properties?: object, frame?: boolean, timeoutMs?: number, signal?: AbortSignal }} options
+ *   frame: designed pages (section.slide on the sheet, already measured): one page per sheet, icons drawn
+ * @returns {Promise<object>} `{ ok:true, output, bytes, pageCount, area, warnings }`, or
+ *   `{ ok:false, error }` / `{ ok:false, layout }` when the browser failed or the layout check refused it
+ */
+export async function printHtmlPdf(
+  html,
+  output,
+  { sourcePath, properties = {}, frame = false, timeoutMs = 90_000, signal = null }
+) {
+  const startedAt = performance.now();
+  await writeFile(sourcePath, html, 'utf8');
+  await rm(output, { force: true });
+  let browser;
+  try {
+    browser = await launchHtmlBrowser('pdf-html-browser');
+  } catch (error) {
+    return htmlFailure(error, startedAt);
+  }
+  const work = async () => {
+    const page = await browser.newPage();
+    await page.emulateMediaType('print');
+    await page.goto(pathToFileURL(sourcePath).href, { waitUntil: 'load' });
+    const area = printableArea(await page.evaluate(readPageRule));
+    if (frame) {
+      await page.evaluate(injectIcons, iconTable().table, '0 0 24 24');
+      await page.addStyleTag({ content: FRAME_PRINT_CSS });
+    }
+    await page.setViewport({ width: Math.round(area.width), height: Math.round(area.height), deviceScaleFactor: 1 });
+    await page.evaluate(() => document.fonts.ready);
+    // Charts are drawn at the size print lays them out, before the layout is read for what print would cut.
+    const charts = await page.evaluate(drawDataCharts);
+    const measured = await page.evaluate(measurePrintLayout, { width: area.width, height: area.height }, frame);
+    const errors = measured.findings.filter((finding) => finding.severity === 'error');
+    if (errors.length) return { refused: errors, area };
+    const headings = await page.evaluate(headingTitles);
+    await page.pdf({ path: output, preferCSSPageSize: true, printBackground: true, tagged: true, outline: true });
+    return {
+      area,
+      headings,
+      charts: charts.drawn,
+      warnings: [...charts.warnings, ...measured.findings.filter((finding) => finding.severity !== 'error')],
+    };
+  };
+  let printed;
+  try {
+    printed = await runInBrowser(browser, { signal, timeoutMs }, work);
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return htmlFailure(error, startedAt);
+  }
+  if (printed.refused)
+    return htmlFailure(new Error('layout check refused the document'), startedAt, { layout: printed.refused });
+  const document = await PDFDocument.load(await readFile(output));
+  const described = ['title', 'author', 'subject', 'keywords'].some((key) => properties?.[key] != null);
+  if (described) applyDocumentProperties(document, properties);
+  if (repairOutlineTitles(document, printed.headings) || described) await writeFile(output, await document.save());
+  return {
+    ok: true,
+    output,
+    bytes: (await stat(output)).size,
+    pageCount: document.getPageCount(),
+    area: { width: Math.round(printed.area.width), height: Math.round(printed.area.height) },
+    ...(printed.charts ? { charts: printed.charts } : {}),
+    warnings: printed.warnings,
+    elapsedMs: Math.round(performance.now() - startedAt),
+  };
+}

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

@@ -1,4 +1,5 @@
-import { rm } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
 import { render } from '../core/office-actions.mjs';
 import { documentFormat, officeSessionForDocument } from '../core/office-core.mjs';
 import { createAuthoredSession, fullPath, validatePptxAuthorMode } from '../core/office-sessions.mjs';
@@ -7,14 +8,22 @@ import {
   exists,
   landStagedDeck,
   releaseExistingSession,
+  releaseStagingTarget,
   reusableAuthoredSession,
   stagingTarget,
   swapAuthoredDocument,
   throwIfAuthoringCancelled,
 } from './pptx-author-session.mjs';
 import { runPptxAuthoringScript } from './pptx-script-runner.mjs';
-import { htmlBriefScript, measureHtmlDrift, runPptxHtmlAuthoring, writeHtmlComparisons } from './pptx-html-runner.mjs';
+import {
+  htmlArtifacts,
+  htmlBriefScript,
+  measureHtmlDrift,
+  runPptxHtmlAuthoring,
+  writeHtmlComparisons,
+} from './pptx-html-runner.mjs';
 import { factsGate, parseAuthoringBrief, planGate } from './pptx-brief.mjs';
+import { editsReplacedByAuthor, markAuthoredFromHtml } from './html-source-drift.mjs';
 import { readCompositionReceipt } from './pptx-review-artifacts.mjs';
 import { receiptForDelivery } from './pptx-receipt.mjs';
 import { snapshotPortableOoxml } from '../portable/portable-ooxml.mjs';
@@ -22,10 +31,10 @@ import { snapshotPortableOoxml } from '../portable/portable-ooxml.mjs';
 /** The design guide lives in the built-in `pptx` skill; the tool never
  *  serves it so one copy stays authoritative and user-overridable. */
 const PPTX_AUTHOR_NEEDS_SOURCE =
-  'author requires script: HTML slides or a pptxgenjs script. Load the `pptx` Skill first (Skill name:"pptx"): it carries the authoring workflow, the HTML contract, the composition grammar, and the device kit, then call author again with path and script.';
+  'author requires script: HTML slides or a pptxgenjs script (without one it re-authors from <deck>.pptx.mixdog-source.html, and none is there). Load the `pptx` Skill first (Skill name:"pptx"): it carries the authoring workflow, the HTML contract, the composition grammar, and the device kit, then call author again with path and script.';
 
 // HTML opens with markup (a doctype, a comment, an element); a pptxgenjs script never does.
-function isHtmlSource(source) {
+export function isHtmlSource(source) {
   return /^\s*</.test(String(source || ''));
 }
 
@@ -33,7 +42,7 @@ function isHtmlSource(source) {
 // will hold it; a package the reader cannot open is left to qa, never turned
 // into a refusal. One snapshot answers both: the figures against the fact
 // sheet, then the pages against the plan that was written before them.
-async function gateStagedDeck(path, brief) {
+export async function gateStagedDeck(path, brief) {
   if (!brief.present) return { blocked: false };
   let document;
   try {
@@ -44,7 +53,8 @@ async function gateStagedDeck(path, brief) {
   const facts = factsGate(document, brief);
   if (facts.blocked) return { ...facts, gate: 'facts' };
   const plan = planGate(document, brief);
-  return plan.blocked ? { ...plan, gate: 'plan' } : { blocked: false };
+  // The snapshot rides on a pass so a caller can read the same deck further (a PDF's design read).
+  return plan.blocked ? { ...plan, gate: 'plan' } : { blocked: false, document };
 }
 
 function describePlanSlide(entry) {
@@ -53,7 +63,7 @@ function describePlanSlide(entry) {
   return `slide ${entry.slide}`;
 }
 
-function planGateResult(target, gate, run) {
+export function planGateResult(target, gate, run) {
   const listed = gate.slides.map(describePlanSlide).join('; ');
   const nextAction = {
     plan_missing:
@@ -73,7 +83,7 @@ function planGateResult(target, gate, run) {
   };
 }
 
-function factsGateResult(target, brief, gate, run) {
+export function factsGateResult(target, brief, gate, run) {
   const listed = gate.slides.map((entry) => `slide ${entry.slide}: ${entry.figures.join(', ')}`).join('; ');
   return {
     ok: false,
@@ -91,7 +101,7 @@ function factsGateResult(target, brief, gate, run) {
 
 // The HTML's own geometry, read in the browser before anything lands: a declared relation that does not
 // hold, or a near miss no declaration covers (pptx-html-geometry.mjs).
-function geometryGateResult(target, run) {
+export function geometryGateResult(target, run) {
   const listed = run.geometry
     .map((page) => `slide ${page.slide}: ${page.findings.map((finding) => finding.message).join('; ')}`)
     .join(' | ');
@@ -107,11 +117,12 @@ function geometryGateResult(target, run) {
 }
 
 function resolveAuthorTarget(args, cwd) {
-  if (!String(args.script || '').trim()) throw new Error(PPTX_AUTHOR_NEEDS_SOURCE);
   const requestedPath = String(args.path || args.output || '').trim();
-  if (!requestedPath) throw new Error('author requires path');
+  // A bare author (no path, no script) is a call made before reading the skill: it is pointed there.
+  if (!requestedPath)
+    throw new Error(String(args.script || '').trim() ? 'author requires path' : PPTX_AUTHOR_NEEDS_SOURCE);
   const target = fullPath(requestedPath, cwd);
-  if (documentFormat(target) !== 'pptx') throw new Error('author writes .pptx targets only');
+  if (documentFormat(target) !== 'pptx') throw new Error('author writes .pptx and .pdf targets only');
   return { target, mode: validatePptxAuthorMode(args.mode) };
 }
 
@@ -182,10 +193,10 @@ async function finishAuthoredDeck(session, { args, cwd, target, run, signal, rep
 // swaps its deck; an existing session hands its audit rounds on. A re-author
 // replaces the session, but the audit fix rounds belong to the deck: the loop
 // keeps counting across passes on the same path.
-async function authoringSessionState(target, mode, args) {
+async function authoringSessionState(target, mode, args, fromSource) {
   const reusable = reusableAuthoredSession(target, mode);
   const existing = officeSessionForDocument(target);
-  if (!reusable && !existing && (await exists(target)) && args.overwrite !== true) {
+  if (!reusable && !existing && !fromSource && (await exists(target)) && args.overwrite !== true) {
     throw new Error(`author target already exists: ${target}; pass overwrite:true to replace it`);
   }
   return { reusable, priorAudit: reusable ? null : existing?.inlineAudit || null };
@@ -193,14 +204,21 @@ async function authoringSessionState(target, mode, args) {
 
 export async function authorPptx(args, { cwd, dataDir, signal = null }) {
   const { target, mode } = resolveAuthorTarget(args, cwd);
+  // Without a script the deck is authored again from the HTML kept beside it, as a PDF or Word document is: a fix
+  // is an edit to that file, not the whole deck sent again.
+  const sourcePath = htmlArtifacts(target).source;
+  const fromSource = !String(args.script || '').trim();
+  if (fromSource && !(await exists(sourcePath))) throw new Error(PPTX_AUTHOR_NEEDS_SOURCE);
+  const script = fromSource ? await readFile(sourcePath, 'utf8') : String(args.script);
   throwIfAuthoringCancelled(signal);
-  const { reusable, priorAudit } = await authoringSessionState(target, mode, args);
+  const replacedEdits = editsReplacedByAuthor(officeSessionForDocument(target));
+  const { reusable, priorAudit } = await authoringSessionState(target, mode, args, fromSource);
   // The script always writes beside the target: a failed script or a refused
   // deck leaves the file on disk and the session holding the previous deck
   // untouched.
-  const staging = stagingTarget(target);
-  const html = isHtmlSource(args.script);
-  const brief = parseAuthoringBrief(html ? htmlBriefScript(args.script) : args.script);
+  const staging = await stagingTarget(target);
+  const html = isHtmlSource(script);
+  const brief = parseAuthoringBrief(html ? htmlBriefScript(script) : script);
   let run;
   let session = null;
   let reusedSession = false;
@@ -209,8 +227,8 @@ export async function authorPptx(args, { cwd, dataDir, signal = null }) {
   try {
     throwIfAuthoringCancelled(signal);
     run = html
-      ? await runPptxHtmlAuthoring(args.script, staging, { target, signal })
-      : await runPptxAuthoringScript(args.script, staging);
+      ? await runPptxHtmlAuthoring(script, staging, { target, signal })
+      : await runPptxAuthoringScript(script, staging, { cwd: dirname(target) });
     throwIfAuthoringCancelled(signal);
     if (!run.ok) return scriptFailedResult(target, run, html);
     if (run.geometry?.length) return geometryGateResult(target, run);
@@ -236,11 +254,15 @@ export async function authorPptx(args, { cwd, dataDir, signal = null }) {
     if (signal?.aborted || error?.name === 'AbortError') discardStaging = true;
     throw error;
   } finally {
-    if (discardStaging) await rm(staging, { force: true }).catch(() => {});
+    if (discardStaging) await releaseStagingTarget(staging).catch(() => {});
   }
   session.authoredBrief = brief;
+  // A deck from HTML counts the batch edits that land past its kept source; a pptxgenjs deck keeps no source.
+  markAuthoredFromHtml(session, run.htmlSource || null);
   if (priorAudit && !session.inlineAudit) session.inlineAudit = { ...priorAudit };
-  return finishAuthoredDeck(session, { args, cwd, target, run, signal, replacedSession, reusedSession });
+  const result = await finishAuthoredDeck(session, { args, cwd, target, run, signal, replacedSession, reusedSession });
+  if (replacedEdits) result.replacedEdits = replacedEdits;
+  return result;
 }
 
 const UNRENDERED_NEXT_ACTION =

package/src/runtime/office/authoring/pptx-author-session.mjs

@@ -1,6 +1,6 @@
-import { access, copyFile, rm } from 'node:fs/promises';
+import { access, copyFile, mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { constants as fsConstants } from 'node:fs';
-import { basename, dirname, extname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { callMicrosoftOffice } from '../com/com-adapter.mjs';
 import { closeSession } from '../core/office-actions.mjs';
 import { emptyOfficeDesignState, officeSessionForDocument, releaseOfficeSession } from '../core/office-core.mjs';
@@ -54,10 +54,16 @@ export function reusableAuthoredSession(target, mode = 'auto') {
   return reusable ? existing : null;
 }
 
-// The script writes beside the target, not over it, so a failed script leaves both the file on disk
-// and the open session holding the previous deck untouched.
-export function stagingTarget(target) {
-  return join(dirname(target), `.${basename(target, extname(target))}.authoring${extname(target)}`);
+// Each call owns a directory on the target's filesystem. A failed author must
+// never consume an existing neighbor or another call's staged document.
+export async function stagingTarget(target) {
+  await mkdir(dirname(target), { recursive: true });
+  const directory = await mkdtemp(join(dirname(target), '.mixdog-authoring-'));
+  return join(directory, basename(target));
+}
+
+export async function releaseStagingTarget(staging) {
+  await rm(dirname(staging), { recursive: true, force: true });
 }
 
 export async function swapAuthoredDocument(session, source, signal, { callOffice = callMicrosoftOffice } = {}) {

package/src/runtime/office/authoring/pptx-html-build.mjs

@@ -1,7 +1,7 @@
 // The HTML authoring path, second half: the measurement pptx-html-measure.mjs
 // read from the browser becomes a deck of native PowerPoint objects — text
 // boxes that keep the browser's line breaks, shapes, lines, tables, charts,
-// and pictures — on the 13.333 × 7.5 in wide layout.
+// and pictures — on the 13.333 × 7.5 in wide layout, or the sheet the measure names.
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
@@ -24,9 +24,23 @@ const MIDDLE_LIFT = 0.09; // em a middle-anchored single line sits above the bro
 const middleBaseline = (spacing) => 1.02 * spacing - 0.09; // the same, for a middle-anchored block
 const EDGE = 24; // px: text slack never carries a box past this margin
 
+// The deck canvas lands on the 13.333 in wide layout; a measured sheet (a PDF's designed pages) carries its own inches.
+const WIDE_INCHES = 13.333;
+const pageInches = (measure) => ({
+  width: measure.inchWidth || WIDE_INCHES,
+  height: measure.inchHeight || (WIDE_INCHES * (measure.height || 1080)) / measure.width,
+});
+
 function units(measure) {
-  const K = 13.333 / measure.width; // inches per CSS px
-  return { K, PT: 0.5 * (1920 / measure.width), inch: (v) => v * K, W: measure.width, H: measure.height || 1080 };
+  const inches = pageInches(measure).width;
+  const K = inches / measure.width; // inches per CSS px
+  return {
+    K,
+    PT: 0.5 * (1920 / measure.width) * (inches / WIDE_INCHES),
+    inch: (v) => v * K,
+    W: measure.width,
+    H: measure.height || 1080,
+  };
 }
 
 // The page clips what runs past it (section.slide is overflow: hidden); PowerPoint would keep the part past
@@ -586,7 +600,12 @@ export async function buildPptxFromMeasure(measure, output) {
   const PptxGenJS = require('pptxgenjs');
   const sharp = require('sharp');
   const pres = new PptxGenJS();
-  pres.layout = 'LAYOUT_WIDE';
+  const page = pageInches(measure);
+  if (page.width === WIDE_INCHES && Math.abs(page.height - 7.5) < 0.01) pres.layout = 'LAYOUT_WIDE';
+  else {
+    pres.defineLayout({ name: 'MIXDOG_SHEET', width: page.width, height: page.height });
+    pres.layout = 'MIXDOG_SHEET';
+  }
   const u = units(measure);
   for (const measured of measure.slides) {
     const slide = pres.addSlide();