@bendyline/squisq-formats 2.0.0 → 2.1.0

package/src/infer/index.ts

@@ -16,7 +16,7 @@
  */
 
 import type { CustomTemplateDefinition, Theme } from '@bendyline/squisq/schemas';
-import { openPackage } from '../ooxml/reader.js';
+import { openPackage, throwIfOoxmlAborted } from '../ooxml/reader.js';
 import type { OoxmlOpenOptions } from '../ooxml/reader.js';
 import type { OoxmlPackage } from '../ooxml/types.js';
 import { ConversionError } from '../registry/errors.js';
@@ -53,7 +53,8 @@ export interface InferredFileTheme {
   warnings: string[];
 }
 
-async function looksLikePdf(data: ArrayBuffer | Blob): Promise<boolean> {
+async function looksLikePdf(data: ArrayBuffer | Blob, signal?: AbortSignal): Promise<boolean> {
+  throwIfOoxmlAborted(signal);
   // Duck-typed (not instanceof): buffers routinely cross realms in test
   // environments and web workers. Blobs carry `size`; ArrayBuffers carry
   // `byteLength`.
@@ -64,16 +65,39 @@ async function looksLikePdf(data: ArrayBuffer | Blob): Promise<boolean> {
     typeof blob.slice === 'function' &&
     typeof blob.arrayBuffer === 'function'
   ) {
-    head = new Uint8Array(await blob.slice(0, 5).arrayBuffer());
+    head = new Uint8Array(await waitForAbortable(blob.slice(0, 5).arrayBuffer(), signal));
   } else if (typeof (data as ArrayBuffer).byteLength === 'number') {
     const buf = data as ArrayBuffer;
     head = new Uint8Array(buf, 0, Math.min(5, buf.byteLength));
   }
+  throwIfOoxmlAborted(signal);
   if (!head || head.length < 4) return false;
   // '%PDF'
   return head[0] === 0x25 && head[1] === 0x50 && head[2] === 0x44 && head[3] === 0x46;
 }
 
+function waitForAbortable<T>(work: Promise<T>, signal?: AbortSignal): Promise<T> {
+  throwIfOoxmlAborted(signal);
+  if (!signal) return work;
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const finish = (complete: () => void): void => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener('abort', handleAbort);
+      complete();
+    };
+    const handleAbort = (): void =>
+      finish(() => reject(signal.reason ?? new Error('OOXML operation was cancelled')));
+    signal.addEventListener('abort', handleAbort, { once: true });
+    if (signal.aborted) handleAbort();
+    work.then(
+      (value) => finish(() => resolve(value)),
+      (error: unknown) => finish(() => reject(error)),
+    );
+  });
+}
+
 /**
  * Classify an opened package from its already-parsed content types.
  * (Deliberately not the registry's byte sniffer — that re-parses the zip
@@ -110,7 +134,8 @@ export async function inferThemeFromFile(
   data: ArrayBuffer | Blob,
   options: InferThemeOptions = {},
 ): Promise<InferredFileTheme> {
-  if (await looksLikePdf(data)) {
+  throwIfOoxmlAborted(options.signal);
+  if (await looksLikePdf(data, options.signal)) {
     throw new ConversionError(
       'unsupported-input',
       'PDF theme inference is not supported — PDF files carry no theme color/font tables.',
@@ -122,6 +147,7 @@ export async function inferThemeFromFile(
   try {
     pkg = await openPackage(data, options);
   } catch (err: unknown) {
+    if (options.signal?.aborted) throw options.signal.reason ?? err;
     throw new ConversionError(
       'invalid-input',
       'Could not read this file as a Word, PowerPoint, or Excel document.',
@@ -130,6 +156,7 @@ export async function inferThemeFromFile(
   }
 
   const format = options.format ?? sniffOoxmlFormat(pkg);
+  throwIfOoxmlAborted(options.signal);
   if (!format) {
     throw new ConversionError(
       'invalid-input',
@@ -138,6 +165,7 @@ export async function inferThemeFromFile(
   }
 
   const extraction = await EXTRACTORS[format](pkg);
+  throwIfOoxmlAborted(options.signal);
   if (!extraction) {
     throw new ConversionError('invalid-input', 'No theme part found in this file.', { format });
   }
@@ -145,6 +173,7 @@ export async function inferThemeFromFile(
   const { theme, warnings: mapWarnings } = compileExtractedTheme(extraction, {
     nameHint: options.nameHint,
   });
+  throwIfOoxmlAborted(options.signal);
   const warnings = [...extraction.warnings, ...mapWarnings];
 
   let layouts: CustomTemplateDefinition[] | undefined;
@@ -155,6 +184,7 @@ export async function inferThemeFromFile(
       const { analyzePptxLayouts } = await import('../pptx/layouts.js');
       const analysis = await analyzePptxLayouts(pkg, {
         colors: colorHintsFromExtraction(extraction),
+        signal: options.signal,
       });
       warnings.push(...analysis.warnings);
       const defs = analysis.layouts
@@ -164,5 +194,6 @@ export async function inferThemeFromFile(
     }
   }
 
+  throwIfOoxmlAborted(options.signal);
   return { theme, extraction, ...(layouts ? { layouts } : {}), warnings };
 }

package/src/ooxml/namespaces.ts

@@ -59,6 +59,18 @@ export const REL_IMAGE =
 export const REL_FOOTNOTES =
   'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes';
 
+/** Relationship type: Endnotes */
+export const REL_ENDNOTES =
+  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes';
+
+/** Relationship type: Header */
+export const REL_HEADER =
+  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header';
+
+/** Relationship type: Footer */
+export const REL_FOOTER =
+  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer';
+
 /** Relationship type: Theme */
 export const REL_THEME =
   'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme';
@@ -156,6 +168,15 @@ export const CONTENT_TYPE_DOCX_FONT_TABLE =
 export const CONTENT_TYPE_DOCX_FOOTNOTES =
   'application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml';
 
+export const CONTENT_TYPE_DOCX_ENDNOTES =
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml';
+
+export const CONTENT_TYPE_DOCX_HEADER =
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml';
+
+export const CONTENT_TYPE_DOCX_FOOTER =
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml';
+
 export const CONTENT_TYPE_PPTX_PRESENTATION =
   'application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml';
 

package/src/ooxml/reader.ts

@@ -5,8 +5,8 @@
  * structural metadata: [Content_Types].xml, relationships, and
  * core properties.
  *
- * Uses bounded JSZip member streams and a platform DOMParser (with an xmldom
- * fallback in bare Node/SSR) to parse XML.
+ * Uses bounded JSZip member streams and a platform DOMParser (with the
+ * package-owned xmldom parser in Node/SSR) to parse XML.
  */
 
 import { DOMParser as XmldomDOMParser } from '@xmldom/xmldom';
@@ -26,21 +26,44 @@ type DomParserLike = new () => {
 
 /** Safe read sessions for opaque packages opened by this module. */
 const packageArchives = new WeakMap<OoxmlPackage, BoundedZipArchive>();
+const packageSignals = new WeakMap<OoxmlPackage, AbortSignal>();
 const MAX_CONTENT_TYPES_BYTES = 1024 * 1024;
 const MAX_RELATIONSHIPS_BYTES = 4 * 1024 * 1024;
+const CANCELLATION_CHECKPOINT_INTERVAL = 256;
+
+/** Preserve the caller's exact cancellation reason across OOXML traversal. */
+export function throwIfOoxmlAborted(signal?: AbortSignal): void {
+  if (!signal?.aborted) return;
+  throw signal.reason ?? new Error('OOXML operation was cancelled');
+}
+
+async function cancellationCheckpoint(index: number, signal?: AbortSignal): Promise<void> {
+  throwIfOoxmlAborted(signal);
+  if (index > 0 && index % CANCELLATION_CHECKPOINT_INTERVAL === 0) {
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    throwIfOoxmlAborted(signal);
+  }
+}
 
 /**
- * Parse XML in browsers and bare Node. Browser DOMParser is preferred; the
- * pure-JS xmldom implementation is the package-owned fallback for Node/SSR.
+ * Parse XML in browsers and Node. Test runners and SSR hosts can install a
+ * partial browser DOMParser whose namespace behavior differs from browsers,
+ * so Node always uses the package-owned, namespace-aware xmldom parser.
  */
-function parseXml(source: string): Document {
-  const nativeParser = (globalThis as { DOMParser?: DomParserLike }).DOMParser;
+function parseXml(source: string, signal?: AbortSignal): Document {
+  throwIfOoxmlAborted(signal);
+  const runtime = globalThis as {
+    DOMParser?: DomParserLike;
+    process?: { versions?: { node?: string } };
+  };
+  const nativeParser = runtime.process?.versions?.node ? undefined : runtime.DOMParser;
   const Parser = nativeParser ?? (XmldomDOMParser as unknown as DomParserLike);
   const doc = new Parser().parseFromString(source, 'application/xml') as Document;
   const parserErrors = doc.getElementsByTagName('parsererror');
   if (parserErrors.length > 0) {
     throw new Error(`Invalid OOXML XML part: ${parserErrors[0]?.textContent ?? 'parse error'}`);
   }
+  throwIfOoxmlAborted(signal);
   return doc;
 }
 
@@ -61,15 +84,18 @@ export async function openPackage(
   data: ArrayBuffer | Blob,
   limits: OoxmlOpenOptions = {},
 ): Promise<OoxmlPackage> {
+  throwIfOoxmlAborted(limits.signal);
   const archive = await openBoundedZipArchive(data, limits);
-  const contentTypes = await parseContentTypes(archive);
-  const rootRelationships = await parseRelationships(archive, '');
+  const contentTypes = await parseContentTypes(archive, limits.signal);
+  const rootRelationships = await parseRelationships(archive, '', limits.signal);
+  throwIfOoxmlAborted(limits.signal);
 
   const pkg = {
     contentTypes,
     rootRelationships,
   } as unknown as OoxmlPackage;
   packageArchives.set(pkg, archive);
+  if (limits.signal) packageSignals.set(pkg, limits.signal);
   return pkg;
 }
 
@@ -80,17 +106,21 @@ export async function openPackage(
 /**
  * Parse [Content_Types].xml from the archive.
  */
-async function parseContentTypes(archive: BoundedZipArchive): Promise<ContentTypeMap> {
+async function parseContentTypes(
+  archive: BoundedZipArchive,
+  signal?: AbortSignal,
+): Promise<ContentTypeMap> {
   const overrides = new Map<string, string>();
   const defaults = new Map<string, string>();
 
   const text = await archive.readText('[Content_Types].xml', MAX_CONTENT_TYPES_BYTES);
   if (text === null) return { overrides, defaults };
-  const doc = parseXml(text);
+  const doc = parseXml(text, signal);
 
   // Parse <Default Extension="rels" ContentType="..." />
   const defaultEls = doc.getElementsByTagName('Default');
   for (let i = 0; i < defaultEls.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const el = defaultEls[i];
     const ext = el.getAttribute('Extension');
     const ct = el.getAttribute('ContentType');
@@ -100,6 +130,7 @@ async function parseContentTypes(archive: BoundedZipArchive): Promise<ContentTyp
   // Parse <Override PartName="/word/document.xml" ContentType="..." />
   const overrideEls = doc.getElementsByTagName('Override');
   for (let i = 0; i < overrideEls.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const el = overrideEls[i];
     const partName = el.getAttribute('PartName');
     const ct = el.getAttribute('ContentType');
@@ -128,7 +159,7 @@ export async function getPartRelationships(
   pkg: OoxmlPackage,
   partPath: string,
 ): Promise<Relationship[]> {
-  return parseRelationships(pkg, partPath);
+  return parseRelationships(pkg, partPath, packageSignals.get(pkg));
 }
 
 /**
@@ -140,13 +171,14 @@ export async function getPartRelationships(
 async function parseRelationships(
   source: OoxmlPackage | BoundedZipArchive,
   partPath: string,
+  signal?: AbortSignal,
 ): Promise<Relationship[]> {
   const relsPath = partPath === '' ? '_rels/.rels' : buildRelsPath(partPath);
 
   const bytes = await readArchivePart(source, relsPath, MAX_RELATIONSHIPS_BYTES);
   if (!bytes) return [];
   const text = new TextDecoder().decode(bytes);
-  const doc = parseXml(text);
+  const doc = parseXml(text, signal);
   const result: Relationship[] = [];
 
   const els = doc.getElementsByTagNameNS(NS_RELATIONSHIPS, 'Relationship');
@@ -154,6 +186,7 @@ async function parseRelationships(
   const fallbackEls = els.length > 0 ? els : doc.getElementsByTagName('Relationship');
 
   for (let i = 0; i < fallbackEls.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const el = fallbackEls[i];
     const id = el.getAttribute('Id');
     const type = el.getAttribute('Type');
@@ -200,8 +233,10 @@ function buildRelsPath(partPath: string): string {
  * @returns Parsed XML Document, or null if the part doesn't exist
  */
 export async function getPartXml(pkg: OoxmlPackage, partPath: string): Promise<Document | null> {
+  const signal = packageSignals.get(pkg);
+  throwIfOoxmlAborted(signal);
   const bytes = await readPackagePart(pkg, partPath);
-  return bytes ? parseXml(new TextDecoder().decode(bytes)) : null;
+  return bytes ? parseXml(new TextDecoder().decode(bytes), signal) : null;
 }
 
 /**
@@ -215,6 +250,7 @@ export async function getPartBinary(
   pkg: OoxmlPackage,
   partPath: string,
 ): Promise<ArrayBuffer | null> {
+  throwIfOoxmlAborted(packageSignals.get(pkg));
   const bytes = await readPackagePart(pkg, partPath);
   return bytes ? bytes.slice().buffer : null;
 }
@@ -234,6 +270,7 @@ async function readPackagePart(
   path: string,
   maxBytes?: number,
 ): Promise<Uint8Array | null> {
+  throwIfOoxmlAborted(packageSignals.get(pkg));
   const archive = packageArchives.get(pkg);
   if (!archive) {
     throw new TypeError('Invalid OoxmlPackage: create packages with openPackage().');
@@ -252,6 +289,8 @@ async function readPackagePart(
  * @returns Parsed core properties (all fields optional)
  */
 export async function getCoreProperties(pkg: OoxmlPackage): Promise<CoreProperties> {
+  const signal = packageSignals.get(pkg);
+  throwIfOoxmlAborted(signal);
   const doc = await getPartXml(pkg, 'docProps/core.xml');
   if (!doc) return {};
 
@@ -263,7 +302,7 @@ export async function getCoreProperties(pkg: OoxmlPackage): Promise<CoreProperti
     return undefined;
   }
 
-  return {
+  const properties = {
     title: getText(NS_DC, 'title'),
     subject: getText(NS_DC, 'subject'),
     creator: getText(NS_DC, 'creator'),
@@ -274,4 +313,6 @@ export async function getCoreProperties(pkg: OoxmlPackage): Promise<CoreProperti
     created: getText(NS_DCTERMS, 'created'),
     modified: getText(NS_DCTERMS, 'modified'),
   };
+  throwIfOoxmlAborted(signal);
+  return properties;
 }

package/src/pptx/layouts.ts

@@ -24,7 +24,12 @@ import type {
   TextLayer,
   TextStyle,
 } from '@bendyline/squisq/schemas';
-import { getPartRelationships, getPartXml, openPackage } from '../ooxml/reader.js';
+import {
+  getPartRelationships,
+  getPartXml,
+  openPackage,
+  throwIfOoxmlAborted,
+} from '../ooxml/reader.js';
 import type { OoxmlOpenOptions } from '../ooxml/reader.js';
 import type { OoxmlPackage } from '../ooxml/types.js';
 import {
@@ -162,6 +167,7 @@ const DEFAULT_SLIDE_SIZE = { cx: 12192000, cy: 6858000 };
 const CHROME_PH_TYPES = new Set(['dt', 'ftr', 'sldNum', 'hdr']);
 const MAX_INFERRED_TEMPLATES = 12;
 const MAX_DECORATIONS = 4;
+const CANCELLATION_CHECKPOINT_INTERVAL = 128;
 /** Decorative rects smaller than this share of the slide are clutter. */
 const MIN_DECORATION_AREA_PCT = 2;
 
@@ -173,6 +179,14 @@ const DEFAULT_TITLE_PT = 44;
 const DEFAULT_SUBTITLE_PT = 24;
 const DEFAULT_BODY_PT = 22;
 
+async function cancellationCheckpoint(index: number, signal?: AbortSignal): Promise<void> {
+  throwIfOoxmlAborted(signal);
+  if (index > 0 && index % CANCELLATION_CHECKPOINT_INTERVAL === 0) {
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    throwIfOoxmlAborted(signal);
+  }
+}
+
 // ── Small helpers ────────────────────────────────────────────────────
 
 function firstPml(parent: Element | Document, local: string): Element | null {
@@ -316,7 +330,12 @@ interface MasterIndex {
   bodyStyle?: PlaceholderTextStyle;
 }
 
-async function readMasterIndex(pkg: OoxmlPackage, masterPath: string): Promise<MasterIndex> {
+async function readMasterIndex(
+  pkg: OoxmlPackage,
+  masterPath: string,
+  signal?: AbortSignal,
+): Promise<MasterIndex> {
+  throwIfOoxmlAborted(signal);
   const index: MasterIndex = { name: '', exact: new Map(), baseIdx: new Map(), base: new Map() };
   const doc = await getPartXml(pkg, masterPath);
   if (!doc) return index;
@@ -333,6 +352,7 @@ async function readMasterIndex(pkg: OoxmlPackage, masterPath: string): Promise<M
 
   const shapes = doc.getElementsByTagNameNS(NS_PML, 'sp');
   for (let i = 0; i < shapes.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const sp = shapes[i]!;
     const ph = firstPml(sp, 'ph');
     if (!ph) continue;
@@ -425,7 +445,9 @@ async function extractLayout(
   pxPerPt: number,
   hints: PptxColorHints,
   masterCache: Map<string, Promise<MasterIndex>>,
+  signal?: AbortSignal,
 ): Promise<ExtractedSlideLayout | null> {
+  throwIfOoxmlAborted(signal);
   const doc = await getPartXml(pkg, layoutPath);
   if (!doc) return null;
 
@@ -440,7 +462,7 @@ async function extractLayout(
     masterPath = resolveTarget(baseDirOf(layoutPath), masterRel.target);
     let cached = masterCache.get(masterPath);
     if (!cached) {
-      cached = readMasterIndex(pkg, masterPath);
+      cached = readMasterIndex(pkg, masterPath, signal);
       masterCache.set(masterPath, cached);
     }
     master = await cached;
@@ -451,6 +473,7 @@ async function extractLayout(
 
   const shapes = doc.getElementsByTagNameNS(NS_PML, 'sp');
   for (let i = 0; i < shapes.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const sp = shapes[i]!;
     const ph = firstPml(sp, 'ph');
 
@@ -1003,7 +1026,11 @@ function resolveVerdict(
 
 // ── Deck-level analysis ──────────────────────────────────────────────
 
-async function readSlideSize(pkg: OoxmlPackage): Promise<{ cx: number; cy: number }> {
+async function readSlideSize(
+  pkg: OoxmlPackage,
+  signal?: AbortSignal,
+): Promise<{ cx: number; cy: number }> {
+  throwIfOoxmlAborted(signal);
   const pres = await getPartXml(pkg, 'ppt/presentation.xml');
   const sldSz = pres ? firstPml(pres, 'sldSz') : null;
   const cx = intAttr(sldSz, 'cx');
@@ -1012,7 +1039,11 @@ async function readSlideSize(pkg: OoxmlPackage): Promise<{ cx: number; cy: numbe
   return { ...DEFAULT_SLIDE_SIZE };
 }
 
-async function orderedSlidePathsForLayouts(pkg: OoxmlPackage): Promise<string[]> {
+async function orderedSlidePathsForLayouts(
+  pkg: OoxmlPackage,
+  signal?: AbortSignal,
+): Promise<string[]> {
+  throwIfOoxmlAborted(signal);
   const pres = await getPartXml(pkg, 'ppt/presentation.xml');
   if (!pres) return [];
   const rels = await getPartRelationships(pkg, 'ppt/presentation.xml');
@@ -1020,6 +1051,7 @@ async function orderedSlidePathsForLayouts(pkg: OoxmlPackage): Promise<string[]>
   const out: string[] = [];
   const ids = pres.getElementsByTagNameNS(NS_PML, 'sldId');
   for (let i = 0; i < ids.length; i++) {
+    await cancellationCheckpoint(i, signal);
     const rid = attrNS(ids[i]!, NS_R, 'id', 'r:id');
     const target = rid ? relById.get(rid) : undefined;
     if (target) out.push(resolveTarget('ppt', target));
@@ -1043,20 +1075,23 @@ export async function analyzePptxLayouts(
   pkg: OoxmlPackage,
   options: AnalyzePptxLayoutsOptions = {},
 ): Promise<PptxLayoutInference> {
+  throwIfOoxmlAborted(options.signal);
   const warnings: string[] = [];
   const hints = options.colors ?? {};
   const maxTemplates = options.maxTemplates ?? MAX_INFERRED_TEMPLATES;
 
-  const sldSz = await readSlideSize(pkg);
+  const sldSz = await readSlideSize(pkg, options.signal);
   const viewport = viewportFor(sldSz);
   const pxPerPt = viewport.height / (sldSz.cy / 12700);
 
   // Layouts used by slides, in first-use order, with usage counts.
-  const slidePaths = await orderedSlidePathsForLayouts(pkg);
+  const slidePaths = await orderedSlidePathsForLayouts(pkg, options.signal);
   const layoutPathBySlide = new Map<string, string>();
   const usage = new Map<string, number>();
   const orderedLayoutPaths: string[] = [];
-  for (const slidePath of slidePaths) {
+  for (let slideIndex = 0; slideIndex < slidePaths.length; slideIndex++) {
+    await cancellationCheckpoint(slideIndex, options.signal);
+    const slidePath = slidePaths[slideIndex]!;
     const rels = await getPartRelationships(pkg, slidePath);
     const layoutRel = findRelByType(rels, REL_SLIDE_LAYOUT);
     if (!layoutRel) continue;
@@ -1068,7 +1103,9 @@ export async function analyzePptxLayouts(
 
   if (options.includeUnused) {
     const unused: string[] = [];
+    let partIndex = 0;
     for (const [partPath, contentType] of pkg.contentTypes.overrides) {
+      await cancellationCheckpoint(partIndex++, options.signal);
       if (contentType === CONTENT_TYPE_PPTX_SLIDE_LAYOUT && !usage.has(partPath)) {
         unused.push(partPath);
       }
@@ -1082,8 +1119,17 @@ export async function analyzePptxLayouts(
   const layouts: AnalyzedLayout[] = [];
   const usedNames = new Set<string>();
   for (let i = 0; i < orderedLayoutPaths.length; i++) {
+    await cancellationCheckpoint(i, options.signal);
     const layoutPath = orderedLayoutPaths[i]!;
-    const extracted = await extractLayout(pkg, layoutPath, sldSz, pxPerPt, hints, masterCache);
+    const extracted = await extractLayout(
+      pkg,
+      layoutPath,
+      sldSz,
+      pxPerPt,
+      hints,
+      masterCache,
+      options.signal,
+    );
     if (!extracted) {
       warnings.push(`layout ${layoutPath} could not be read; its slides import plain`);
       continue;
@@ -1108,7 +1154,10 @@ export async function analyzePptxLayouts(
   const customs = layouts.filter((l) => l.verdict.kind === 'custom');
   if (customs.length > maxTemplates) {
     const ranked = [...customs].sort((a, b) => b.extracted.slideCount - a.extracted.slideCount);
-    for (const layout of ranked.slice(maxTemplates)) {
+    const excess = ranked.slice(maxTemplates);
+    for (let index = 0; index < excess.length; index++) {
+      await cancellationCheckpoint(index, options.signal);
+      const layout = excess[index]!;
       layout.verdict = { kind: 'plain' };
       layout.notes.push('dropped: more inferred layouts than the template cap');
     }
@@ -1118,6 +1167,7 @@ export async function analyzePptxLayouts(
   }
 
   const byLayoutPath = new Map(layouts.map((l) => [l.extracted.partPath, l]));
+  throwIfOoxmlAborted(options.signal);
   return { slideSize: sldSz, layouts, byLayoutPath, layoutPathBySlide, warnings };
 }
 
@@ -1148,11 +1198,15 @@ export async function inspectPptxLayouts(
   data: ArrayBuffer | Blob,
   options: InspectPptxLayoutsOptions = {},
 ): Promise<{ layouts: PptxLayoutSummary[]; slideSize: { cx: number; cy: number } }> {
+  throwIfOoxmlAborted(options.signal);
   const pkg = await openPackage(data, options);
   const analysis = await analyzePptxLayouts(pkg, options);
-  const layouts = analysis.layouts.map((l, i): PptxLayoutSummary => {
+  const layouts: PptxLayoutSummary[] = [];
+  for (let i = 0; i < analysis.layouts.length; i++) {
+    await cancellationCheckpoint(i, options.signal);
+    const l = analysis.layouts[i]!;
     const { extracted, verdict, notes } = l;
-    return {
+    layouts.push({
       layoutPath: extracted.partPath,
       name: extracted.name || `Layout ${i + 1}`,
       ...(extracted.masterName ? { masterName: extracted.masterName } : {}),
@@ -1162,7 +1216,7 @@ export async function inspectPptxLayouts(
       ...(verdict.kind === 'builtin' ? { builtinTemplate: verdict.template } : {}),
       ...(verdict.kind === 'custom' ? { customTemplate: verdict.def } : {}),
       ...(notes.length > 0 ? { notes } : {}),
-    };
-  });
+    });
+  }
   return { layouts, slideSize: analysis.slideSize };
 }