@bendyline/squisq-formats 2.0.0 → 2.0.1

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 };
 }

package/src/registry/convert.ts

@@ -22,12 +22,22 @@ import type {
   FormatId,
   FormatRegistry,
   NormalizedInput,
+  PreparedConversion,
+  PreparedExportOptions,
 } from './types.js';
 
 function markdownFormatOptions(options: ConvertOptions): BuiltinFormatOptions['md'] {
   return (options.formatOptions?.md ?? {}) as BuiltinFormatOptions['md'];
 }
 
+function throwIfAborted(signal?: AbortSignal): void {
+  if (!signal?.aborted) return;
+  if (signal.reason !== undefined) throw signal.reason;
+  const error = new Error('Document conversion was cancelled.');
+  error.name = 'AbortError';
+  throw error;
+}
+
 // ── Byte sniffing ───────────────────────────────────────────────────
 
 function hasPrefix(bytes: Uint8Array, prefix: number[]): boolean {
@@ -274,39 +284,30 @@ async function applyTransformStyle(
   return [];
 }
 
-// ── convert() ───────────────────────────────────────────────────────
+// ── prepare / convert ───────────────────────────────────────────────
 
-/**
- * Convert a source document to a target format.
- *
- * @param source - A bytes / markdown / doc source.
- * @param to - The target format id (must be registered and support export).
- * @param options - Conversion options (registry, theme, transform, …).
- * @throws {@link ConversionError} on any failure, with a stable `code`.
- */
-export async function convert(
+/** Normalize and transform a source once, then safely export that snapshot many times. */
+export async function prepareConversion(
   source: ConvertSource,
-  to: FormatId,
   options: ConvertOptions = {},
-): Promise<ConversionResult> {
-  const registry = options.registry ?? defaultRegistry();
+): Promise<PreparedConversion> {
+  return prepareConversionInternal(source, options);
+}
 
-  const target: FormatDefinition | undefined = registry.get(to);
-  if (!target) {
-    throw new ConversionError('unknown-format', `Unknown target format "${to}".`, { format: to });
-  }
-  if (!target.exportDoc) {
-    throw new ConversionError(
-      'unsupported-output',
-      `Format "${target.label}" does not support export.`,
-      { format: to, hint: 'This format is import-only.' },
-    );
-  }
+async function prepareConversionInternal(
+  source: ConvertSource,
+  options: ConvertOptions,
+  failureFormat?: FormatId,
+): Promise<PreparedConversion> {
+  throwIfAborted(options.signal);
+  const registry = options.registry ?? defaultRegistry();
 
   let normalized: Normalized;
   try {
     normalized = await normalize(source, options, registry);
+    throwIfAborted(options.signal);
   } catch (err: unknown) {
+    throwIfAborted(options.signal);
     if (err instanceof ConversionError) throw err;
     const message = err instanceof Error ? err.message : String(err);
     throw new ConversionError('invalid-input', message, {
@@ -321,7 +322,6 @@ export async function convert(
     input.doc = { ...input.doc, themeId: options.themeId };
   }
 
-  let result: ConversionResult;
   try {
     if (options.transformStyle) {
       warnings.push(
@@ -332,18 +332,102 @@ export async function convert(
           options.transformRegistry,
         )),
       );
+      throwIfAborted(options.signal);
     }
-    result = await target.exportDoc(input, options);
   } catch (err: unknown) {
+    throwIfAborted(options.signal);
     if (err instanceof ConversionError) throw err;
     const message = err instanceof Error ? err.message : String(err);
-    throw new ConversionError('conversion-failed', message, { format: to, cause: err });
+    throw new ConversionError('conversion-failed', message, {
+      format: failureFormat,
+      cause: err,
+    });
   }
 
-  const ext = target.extensions[0]?.replace(/^\.+/, '') ?? to;
+  const preparedWarnings = Object.freeze([...warnings]);
+  const preparedInput = { ...input };
+  return Object.freeze({
+    async convert(to: FormatId, targetOptions: PreparedExportOptions = {}) {
+      const target = requireExportTarget(registry, to);
+      const exportOptions = mergePreparedExportOptions(options, targetOptions);
+      throwIfAborted(exportOptions.signal);
+      let result: ConversionResult;
+      try {
+        result = await target.exportDoc!({ ...preparedInput }, exportOptions);
+        throwIfAborted(exportOptions.signal);
+      } catch (err: unknown) {
+        throwIfAborted(exportOptions.signal);
+        if (err instanceof ConversionError) throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new ConversionError('conversion-failed', message, { format: to, cause: err });
+      }
+
+      const ext = target.extensions[0]?.replace(/^\.+/, '') ?? to;
+      return {
+        ...result,
+        suggestedFilename: `${preparedInput.baseName}.${ext}`,
+        warnings: [...preparedWarnings, ...result.warnings],
+      };
+    },
+  });
+}
+
+function requireExportTarget(registry: FormatRegistry, to: FormatId): FormatDefinition {
+  const target = registry.get(to);
+  if (!target) {
+    throw new ConversionError('unknown-format', `Unknown target format "${to}".`, { format: to });
+  }
+  if (!target.exportDoc) {
+    throw new ConversionError(
+      'unsupported-output',
+      `Format "${target.label}" does not support export.`,
+      { format: to, hint: 'This format is import-only.' },
+    );
+  }
+  return target;
+}
+
+function mergePreparedExportOptions(
+  prepared: ConvertOptions,
+  target: PreparedExportOptions,
+): ConvertOptions {
   return {
-    ...result,
-    suggestedFilename: `${input.baseName}.${ext}`,
-    warnings: [...warnings, ...result.warnings],
+    ...prepared,
+    signal: mergeAbortSignals(prepared.signal, target.signal),
+    title: target.title ?? prepared.title,
+    resolvePlayerScript: target.resolvePlayerScript ?? prepared.resolvePlayerScript,
+    formatOptions:
+      target.formatOptions === undefined
+        ? prepared.formatOptions
+        : { ...(prepared.formatOptions ?? {}), ...target.formatOptions },
   };
 }
+
+function mergeAbortSignals(
+  preparedSignal?: AbortSignal,
+  targetSignal?: AbortSignal,
+): AbortSignal | undefined {
+  if (!preparedSignal) return targetSignal;
+  if (!targetSignal || preparedSignal === targetSignal) return preparedSignal;
+  return AbortSignal.any([preparedSignal, targetSignal]);
+}
+
+/**
+ * Convert a source document to a target format.
+ *
+ * @param source - A bytes / markdown / doc source.
+ * @param to - The target format id (must be registered and support export).
+ * @param options - Conversion options (registry, theme, transform, …).
+ * @throws {@link ConversionError} on any failure, with a stable `code`.
+ */
+export async function convert(
+  source: ConvertSource,
+  to: FormatId,
+  options: ConvertOptions = {},
+): Promise<ConversionResult> {
+  throwIfAborted(options.signal);
+  const registry = options.registry ?? defaultRegistry();
+  requireExportTarget(registry, to);
+  const prepared = await prepareConversionInternal(source, { ...options, registry }, to);
+  return prepared.convert(to);
+}

package/src/registry/defaultFormats.ts

@@ -399,9 +399,12 @@ export function defaultFormats(): FormatDefinition[] {
       const { zipToContainer } = await import('../container/index.js');
       return zipToContainer(data, optionsFor(options, 'dbk'));
     },
-    async exportDoc(input): Promise<ConversionResult> {
+    async exportDoc(input, options): Promise<ConversionResult> {
       const { containerToZip } = await import('../container/index.js');
-      const blob = await containerToZip(await snapshotContainerWithDocument(input));
+      const blob = await containerToZip(
+        await snapshotContainerWithDocument(input),
+        optionsFor(options, 'dbk'),
+      );
       return ok(await toBytes(blob), MIME.zip);
     },
   };

package/src/registry/index.ts

@@ -30,6 +30,8 @@ export type {
   BuiltinFormatOptions,
   MarkdownFormatOptions,
   DbkFormatOptions,
+  PreparedConversion,
+  PreparedExportOptions,
 } from './types.js';
 export { BUILTIN_FORMAT_IDS } from './types.js';
 
@@ -38,4 +40,4 @@ export type { ConversionErrorCode, ConversionErrorOptions } from './errors.js';
 
 export { createRegistry, defaultRegistry } from './registry.js';
 export { defaultFormats } from './defaultFormats.js';
-export { convert } from './convert.js';
+export { convert, prepareConversion } from './convert.js';

package/src/registry/types.ts

@@ -25,6 +25,7 @@ import type { PdfImportOptions } from '../pdf/import.js';
 import type { HtmlExportOptions } from '../html/htmlTemplate.js';
 import type { HtmlImportOptions } from '../html/import.js';
 import type { EpubExportOptions } from '../epub/export.js';
+import type { ContainerToZipOptions } from '../container/index.js';
 import type { ZipSafetyLimits } from '../shared/zipSafety.js';
 
 /** A format identifier (e.g. `'docx'`). Strings so hosts can register their own. */
@@ -62,7 +63,7 @@ export interface MarkdownFormatOptions {
 }
 
 /** Resource limits applied when importing a DBK/ZIP container. */
-export type DbkFormatOptions = ZipSafetyLimits;
+export type DbkFormatOptions = ZipSafetyLimits & ContainerToZipOptions;
 
 /**
  * Strongly typed option bags for built-in formats. Import and export options
@@ -97,6 +98,8 @@ export interface NormalizedInput {
 
 /** Options threaded through `convert()` and into every format method. */
 export interface ConvertOptions {
+  /** Cancel normalization, transformation, or export at the next bounded work boundary. */
+  signal?: AbortSignal;
   /** Registry to resolve formats against. Defaults to `defaultRegistry()`. */
   registry?: FormatRegistry;
   /** Explicit source format id (skips extension/byte sniffing). */
@@ -119,6 +122,20 @@ export interface ConvertOptions {
   formatOptions?: Partial<BuiltinFormatOptions> & Record<FormatId, unknown>;
 }
 
+/** Target-only options accepted after a source has already been normalized and transformed. */
+export type PreparedExportOptions = Pick<
+  ConvertOptions,
+  'signal' | 'title' | 'resolvePlayerScript' | 'formatOptions'
+>;
+
+/**
+ * An opaque normalized conversion snapshot. The source and transform pipeline
+ * has already completed; each call exports that same snapshot to one target.
+ */
+export interface PreparedConversion {
+  convert(to: FormatId, options?: PreparedExportOptions): Promise<ConversionResult>;
+}
+
 /** Describes how a single format imports to / exports from the squisq model. */
 export interface FormatDefinition {
   id: FormatId;

package/src/shared/boundedZipArchive.ts

@@ -8,6 +8,7 @@ import {
   compressionRatioError,
   entryTooLargeError,
   resolveZipSafetyLimits,
+  throwIfZipAborted,
   validateZipArchive,
   tooManyEntriesError,
   ZipSafetyError,
@@ -19,7 +20,7 @@ import {
 import { declaredZipEntryCount, prepareZipInput, type ZipInput } from './zipEntryCount.js';
 
 interface ActiveZipRead {
-  stop(error: ZipSafetyError): void;
+  stop(error: unknown): void;
 }
 
 interface ZipChunkStream {
@@ -58,15 +59,22 @@ class JsZipBoundedArchive implements BoundedZipArchive {
 
   private readonly limits: ResolvedZipSafetyLimits;
   private readonly entriesByPath: ReadonlyMap<string, ValidatedZipEntry>;
+  private readonly signal?: AbortSignal;
   private readonly reads = new Map<string, Promise<Uint8Array>>();
   private readonly activeReads = new Set<ActiveZipRead>();
   private terminalError?: ZipSafetyError;
   private emittedBytes = 0;
 
-  constructor(zip: JSZip, entries: readonly ValidatedZipEntry[], limits: ResolvedZipSafetyLimits) {
+  constructor(
+    zip: JSZip,
+    entries: readonly ValidatedZipEntry[],
+    limits: ResolvedZipSafetyLimits,
+    signal?: AbortSignal,
+  ) {
     this.zip = zip;
     this.entries = entries;
     this.limits = limits;
+    this.signal = signal;
     this.entriesByPath = new Map(entries.map((entry) => [entry.path, entry]));
   }
 
@@ -77,6 +85,7 @@ class JsZipBoundedArchive implements BoundedZipArchive {
 
   /** Read and cache one member, returning null when it does not exist. */
   async read(path: string, maxBytes?: number): Promise<Uint8Array | null> {
+    throwIfZipAborted(this.signal);
     this.throwIfFailed();
     if (maxBytes !== undefined) assertNonNegativeFinite('member read limit', maxBytes);
     const entry = this.entriesByPath.get(path);
@@ -87,7 +96,16 @@ class JsZipBoundedArchive implements BoundedZipArchive {
       pending = this.streamEntry(entry, maxBytes);
       this.reads.set(path, pending);
     }
-    const bytes = await pending;
+    let bytes: Uint8Array;
+    try {
+      bytes = await pending;
+    } catch (error: unknown) {
+      // Cancellation is scoped to the current operation, not archive
+      // corruption. Do not leave a cancelled read cached for a later caller.
+      if (this.reads.get(path) === pending && !this.terminalError) this.reads.delete(path);
+      throw error;
+    }
+    throwIfZipAborted(this.signal);
     if (maxBytes !== undefined && bytes.byteLength > maxBytes) {
       const error = entryTooLargeError(path, bytes.byteLength, maxBytes);
       this.failArchive(error);
@@ -108,6 +126,7 @@ class JsZipBoundedArchive implements BoundedZipArchive {
   }
 
   private streamEntry(metadata: ValidatedZipEntry, readLimit?: number): Promise<Uint8Array> {
+    throwIfZipAborted(this.signal);
     const { path, entry, declaredSize, crc32: expectedCrc } = metadata;
     const effectiveEntryLimit = Math.min(
       this.limits.maxEntryUncompressedBytes,
@@ -129,12 +148,17 @@ class JsZipBoundedArchive implements BoundedZipArchive {
       let settled = false;
       let written = 0;
       let crc = 0xffffffff;
+      const removeAbortListener = (): void =>
+        this.signal?.removeEventListener('abort', handleAbort);
+      const handleAbort = (): void =>
+        controller.stop(this.signal?.reason ?? new Error('ZIP operation was cancelled'));
 
       const controller: ActiveZipRead = {
         stop: (error) => {
           if (settled) return;
           settled = true;
           this.activeReads.delete(controller);
+          removeAbortListener();
           // Public JSZip cancellation is cooperative. It prevents another
           // compressed-input tick; data already emitted synchronously by the
           // current tick is ignored because `settled` is now true.
@@ -148,19 +172,28 @@ class JsZipBoundedArchive implements BoundedZipArchive {
         },
       };
       this.activeReads.add(controller);
+      if (this.signal) {
+        this.signal.addEventListener('abort', handleAbort, { once: true });
+        if (this.signal.aborted) {
+          handleAbort();
+          return;
+        }
+      }
 
       stream
         .on('data', (chunk: Uint8Array) => {
           if (settled) return;
           const nextWritten = written + chunk.byteLength;
           try {
+            throwIfZipAborted(this.signal);
             this.assertChunkAllowed(metadata, nextWritten, chunk.byteLength, effectiveEntryLimit);
             output = growOutput(output, nextWritten, declaredSize, effectiveEntryLimit);
             output.set(chunk, written);
             written = nextWritten;
             crc = updateCrc32(crc, chunk);
           } catch (error: unknown) {
-            this.failArchive(asZipSafetyError(error, path));
+            if (this.signal?.aborted) controller.stop(error);
+            else this.failArchive(asZipSafetyError(error, path));
           }
         })
         .on('error', (error: unknown) => {
@@ -200,6 +233,7 @@ class JsZipBoundedArchive implements BoundedZipArchive {
 
           settled = true;
           this.activeReads.delete(controller);
+          removeAbortListener();
           resolve(output.byteLength === written ? output : output.slice(0, written));
         })
         .resume();
@@ -260,13 +294,16 @@ export async function openBoundedZipArchive(
   data: ZipInput,
   limits: ZipSafetyLimits = {},
 ): Promise<BoundedZipArchive> {
+  throwIfZipAborted(limits.signal);
   const resolved = resolveZipSafetyLimits(limits);
   let prepared: { input: ZipInput; bytes?: Uint8Array };
   try {
-    prepared = await prepareZipInput(data);
+    prepared = await prepareZipInput(data, limits.signal);
   } catch (error: unknown) {
+    if (limits.signal?.aborted) throw limits.signal.reason ?? error;
     throw invalidArchiveError(error);
   }
+  throwIfZipAborted(limits.signal);
   if (prepared.bytes) {
     const declaredEntries = declaredZipEntryCount(prepared.bytes);
     if (declaredEntries !== undefined && declaredEntries > resolved.maxEntries) {
@@ -277,9 +314,11 @@ export async function openBoundedZipArchive(
   try {
     zip = await JSZip.loadAsync(prepared.input);
   } catch (error: unknown) {
+    if (limits.signal?.aborted) throw limits.signal.reason ?? error;
     throw invalidArchiveError(error);
   }
-  return createBoundedZipArchive(zip, resolved);
+  throwIfZipAborted(limits.signal);
+  return createBoundedZipArchive(zip, limits);
 }
 
 function invalidArchiveError(cause: unknown): ZipSafetyError {
@@ -291,9 +330,11 @@ export function createBoundedZipArchive(
   zip: JSZip,
   limits: ZipSafetyLimits = {},
 ): BoundedZipArchive {
+  throwIfZipAborted(limits.signal);
   const resolved = resolveZipSafetyLimits(limits);
-  const entries = validateZipArchive(zip, resolved);
-  return new JsZipBoundedArchive(zip, entries, resolved);
+  const entries = validateZipArchive(zip, limits);
+  throwIfZipAborted(limits.signal);
+  return new JsZipBoundedArchive(zip, entries, resolved, limits.signal);
 }
 
 function asZipSafetyError(error: unknown, path: string): ZipSafetyError {