@stll/folio-core 0.64.1 → 0.65.0

package/dist/docx/selectiveSave.js

@@ -1,4 +1,4 @@
-import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
+import { decodeText } from "../utils/textEncoding.js";
 import { parseCommentsExtended } from "./commentParser.js";
 import { withoutExhaustedComments, withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
@@ -18,7 +18,7 @@ import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
 import { buildStructuralDocumentPatch } from "./structuralXmlPatch.js";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
-import { writeZipPart } from "@stll/docx-core/zip";
+import { ZipArchive } from "@stll/docx-core/zip";
 // src/docx/selectiveSave.ts
 /**
 * Splice edited footnote/endnote paragraphs into their parts and return the
@@ -39,22 +39,22 @@ async function patchNoteParts(zip, doc, candidateIds, updates) {
 	const remainingIds = new Set(candidateIds);
 	if (footnotes.length === 0 && endnotes.length === 0) return remainingIds;
 	const findPart = (conventionalLowerPath) => {
-		const direct = zip.file(conventionalLowerPath);
+		const direct = zip.entry(conventionalLowerPath);
 		if (direct) return direct;
-		for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === conventionalLowerPath) return file;
+		for (const [path, file] of zip.entries().map((archiveEntry) => [archiveEntry.path, archiveEntry])) if (path.toLowerCase() === conventionalLowerPath) return file;
 		return null;
 	};
 	const patchPart = async (conventionalLowerPath, serialize) => {
 		const file = findPart(conventionalLowerPath);
 		if (!file) return true;
-		const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+		const originalXml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const originalIds = collectParaIds(originalXml);
 		const partIds = /* @__PURE__ */ new Set();
 		for (const id of remainingIds) if (originalIds.has(id)) partIds.add(id);
 		if (partIds.size === 0) return true;
 		const patched = buildPatchedNoteXml(originalXml, serialize(), partIds);
 		if (patched === null) return false;
-		updates.set(file.name, patched);
+		updates.set(file.path, patched);
 		for (const id of partIds) remainingIds.delete(id);
 		return true;
 	};
@@ -63,9 +63,9 @@ async function patchNoteParts(zip, doc, candidateIds, updates) {
 	return remainingIds;
 }
 const findZipEntryCaseInsensitive = (zip, lowerPath) => {
-	const direct = zip.file(lowerPath);
+	const direct = zip.entry(lowerPath);
 	if (direct) return direct;
-	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === lowerPath) return file;
+	for (const [path, file] of zip.entries().map((archiveEntry) => [archiveEntry.path, archiveEntry])) if (path.toLowerCase() === lowerPath) return file;
 	return null;
 };
 const commentsExtendedInfoEqual = (a, b) => {
@@ -94,9 +94,9 @@ async function patchCommentsExtended(zip, plan, updates) {
 	const desiredXml = serializeCommentsExtended(plan);
 	const existing = findZipEntryCaseInsensitive(zip, COMMENTS_EXTENDED_PART_LOWER);
 	if (!desiredXml) return existing === null;
-	const baselineInfo = existing ? parseCommentsExtended(await existing.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))) : /* @__PURE__ */ new Map();
+	const baselineInfo = existing ? parseCommentsExtended(await existing.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }))) : /* @__PURE__ */ new Map();
 	if (commentsExtendedInfoEqual(parseCommentsExtended(desiredXml), baselineInfo)) return true;
-	updates.set(existing?.name ?? "word/commentsExtended.xml", desiredXml);
+	updates.set(existing?.path ?? "word/commentsExtended.xml", desiredXml);
 	return ensureCommentsExtendedPackaging(zip, updates);
 }
 /**
@@ -107,12 +107,12 @@ async function patchCommentsExtended(zip, plan, updates) {
 */
 async function ensureCommentsExtendedPackaging(zip, updates) {
 	const ctPath = "[Content_Types].xml";
-	const ctXml = updates.get(ctPath) ?? await zip.file(ctPath)?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const ctXml = updates.get(ctPath) ?? await zip.entry(ctPath)?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (ctXml === void 0) return false;
 	const nextCt = addCommentsExtendedOverride(ctXml);
 	if (nextCt !== ctXml) updates.set(ctPath, nextCt);
 	const relsPath = "word/_rels/document.xml.rels";
-	const relsXml = updates.get(relsPath) ?? await zip.file(relsPath)?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const relsXml = updates.get(relsPath) ?? await zip.entry(relsPath)?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (relsXml === void 0) return false;
 	const nextRels = addCommentsExtendedRelationship(relsXml);
 	if (nextRels !== relsXml) updates.set(relsPath, nextRels);
@@ -139,15 +139,15 @@ async function patchNumberingPart(zip, doc, updates) {
 	const numbering = doc.package.numbering;
 	if (!numbering || numbering.abstractNums.length === 0 && numbering.nums.length === 0) return true;
 	const conventionalLowerPath = "word/numbering.xml";
-	let file = zip.file(conventionalLowerPath);
+	let file = zip.entry(conventionalLowerPath);
 	if (!file) {
-		for (const [path, entry] of Object.entries(zip.files)) if (!entry.dir && path.toLowerCase() === conventionalLowerPath) {
+		for (const [path, entry] of zip.entries().map((archiveEntry) => [archiveEntry.path, archiveEntry])) if (path.toLowerCase() === conventionalLowerPath) {
 			file = entry;
 			break;
 		}
 	}
 	if (!file) return false;
-	const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const originalXml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const baselineXml = serializeNumberingXml(parseNumbering(originalXml).definitions);
 	const currentXml = serializeNumberingXml(numbering);
 	if (currentXml === baselineXml) return true;
@@ -157,7 +157,7 @@ async function patchNumberingPart(zip, doc, updates) {
 		currentXml
 	});
 	if (patched === null) return false;
-	if (patched !== originalXml) updates.set(file.name, patched);
+	if (patched !== originalXml) updates.set(file.path, patched);
 	return true;
 }
 /**
@@ -175,10 +175,10 @@ async function patchNumberingPart(zip, doc, updates) {
 * same package for the same source.
 */
 const queueSettingsUpdates = async (zip, updates) => {
-	const settingsFile = zip.file("word/settings.xml");
+	const settingsFile = zip.entry("word/settings.xml");
 	if (!settingsFile) return;
-	const relsFile = zip.file("word/_rels/settings.xml.rels");
-	const filtered = withoutAttachedTemplate(await settingsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), await relsFile?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })));
+	const relsFile = zip.entry("word/_rels/settings.xml.rels");
+	const filtered = withoutAttachedTemplate(await settingsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })), await relsFile?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })));
 	if (filtered.settingsXml !== void 0) updates.set("word/settings.xml", filtered.settingsXml);
 	if (filtered.relsXml !== void 0) updates.set("word/_rels/settings.xml.rels", filtered.relsXml);
 };
@@ -206,21 +206,17 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 	const ownsCommentsPart = hasOwnedCommentsPart(doc);
 	const commentPlan = planCommentParts(comments);
 	try {
-		const zip = await (await import("jszip")).default.loadAsync(originalBuffer);
+		const zip = await ZipArchive.read(originalBuffer);
 		if (await hasUnmaterializedHyperlinkBindings(doc, zip)) return null;
-		for (const [path, file] of Object.entries(zip.files)) if (!file.dir && isUnsafePackagePath(path)) return null;
+		for (const path of zip.paths()) if (isUnsafePackagePath(path)) return null;
 		if (originalBuffer !== doc.originalBuffer) {
 			const sourceParts = /* @__PURE__ */ new Map();
-			for (const [path, file] of Object.entries(zip.files)) {
+			for (const [path, file] of zip.entries().map((archiveEntry) => [archiveEntry.path, archiveEntry])) {
 				const lowerPath = path.toLowerCase();
-				if (file.dir || !lowerPath.startsWith("word/") || !lowerPath.endsWith(".xml")) continue;
-				sourceParts.set(path, await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })));
+				if (!lowerPath.startsWith("word/") || !lowerPath.endsWith(".xml")) continue;
+				sourceParts.set(path, await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })));
 			}
-			for (const [path, xml] of normalizeImportedNumericIds(sourceParts)) if (xml !== sourceParts.get(path)) writeZipPart({
-				zip,
-				path,
-				data: encodeUtf8(xml)
-			});
+			for (const [path, xml] of normalizeImportedNumericIds(sourceParts)) if (xml !== sourceParts.get(path)) zip.set(path, xml);
 		}
 		if (options.bodyAuthority === "canonical") await publishCanonicalImageResources({
 			document: doc,
@@ -229,9 +225,9 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		});
 		const updates = /* @__PURE__ */ new Map();
 		if (changedParaIds.size > 0 || structuralChange) {
-			const docXmlFile = zip.file("word/document.xml");
+			const docXmlFile = zip.entry("word/document.xml");
 			if (!docXmlFile) return null;
-			const originalDocXml = await docXmlFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+			const originalDocXml = await docXmlFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 			const serializedDocXml = serializeDocument(doc, readRootNamespaceBindings(originalDocXml), {
 				xml: originalDocXml,
 				bodyAuthority: options.bodyAuthority,
@@ -241,7 +237,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			const originalBodyParaIds = structuralChange ? collectParaIds(originalDocXml) : void 0;
 			if (structuralChange && doc.package.numbering) {
 				const numberingFile = findZipEntryCaseInsensitive(zip, "word/numbering.xml");
-				const baselineNumbering = numberingFile ? serializeNumberingXml(parseNumbering(await numberingFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))).definitions) : "";
+				const baselineNumbering = numberingFile ? serializeNumberingXml(parseNumbering(await numberingFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }))).definitions) : "";
 				const added = collectAddedNumberingDefs(baselineNumbering, serializeNumberingXml(doc.package.numbering));
 				if (added.abstractNums.size > 0 || added.nums.size > 0) return null;
 			}
@@ -264,23 +260,23 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			}
 		}
 		const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
-		const commentsPartPath = sourceCommentsFile?.name ?? "word/comments.xml";
-		const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })) : void 0;
+		const commentsPartPath = sourceCommentsFile?.path ?? "word/comments.xml";
+		const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })) : void 0;
 		const commentsUnchanged = sourceCommentsXml !== void 0 && canReplayCommentsPart(doc, sourceCommentsXml);
 		if (!commentsUnchanged && (hasComments || ownsCommentsPart || sourceCommentsFile)) {
 			const commentsXml = serializeComments(commentPlan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
 			if (commentsXml !== sourceCommentsXml) updates.set(commentsPartPath, commentsXml);
 		}
 		if (hasComments || ownsCommentsPart) {
-			const ctFile = zip.file("[Content_Types].xml");
+			const ctFile = zip.entry("[Content_Types].xml");
 			if (ctFile) {
-				const ctXml = await ctFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+				const ctXml = await ctFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 				if (!ctXml.toLowerCase().includes("/word/comments.xml")) updates.set("[Content_Types].xml", ctXml.replace("</Types>", `<Override PartName="/${commentsPartPath}" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`));
 			}
 			const relsPath = "word/_rels/document.xml.rels";
-			const relsFile = zip.file(relsPath);
+			const relsFile = zip.entry(relsPath);
 			if (relsFile) {
-				const relsXml = await relsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+				const relsXml = await relsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 				if (!relsXml.toLowerCase().includes("comments.xml")) {
 					const maxId = findMaxRId(relsXml);
 					updates.set(relsPath, relsXml.replace("</Relationships>", `<Relationship Id="rId${maxId + 1}" Type="${RELATIONSHIP_TYPES.comments}" Target="${commentsPartPath.slice(5)}"/></Relationships>`));
@@ -308,16 +304,16 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			onDiagnostic: options.onDiagnostic
 		})) updates.set(path, xml);
 		await queueSettingsUpdates(zip, updates);
-		const corePropsFile = zip.file("docProps/core.xml");
+		const corePropsFile = zip.entry("docProps/core.xml");
 		if (corePropsFile) {
-			const corePropsXml = await corePropsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+			const corePropsXml = await corePropsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 			updates.set("docProps/core.xml", updateCoreProperties(corePropsXml, { updateModifiedDate: true }));
 		}
 		if ([...updates.keys()].some((path) => {
 			const lowerPath = path.toLowerCase();
 			return lowerPath.startsWith("word/") && (lowerPath.endsWith(".xml") || lowerPath.endsWith(".rels"));
 		})) {
-			const sourceDocumentXml = await findZipEntryCaseInsensitive(zip, "word/document.xml")?.async("text");
+			const sourceDocumentXml = await findZipEntryCaseInsensitive(zip, "word/document.xml")?.text();
 			if (detectDocxConformanceClass(sourceDocumentXml ?? null) === DOCX_CONFORMANCE_CLASSES.STRICT) return null;
 		}
 		return await applyUpdatesToZip(zip, updates);

package/dist/docx/selectiveSaveFlags.d.ts

@@ -11,7 +11,7 @@
  * - `selectiveSaveTripwire` — run selective + full and compare bytes for CI
  *   observability. Never blocks the user-visible save.
  * - `selectiveSaveMaxBytes` — refuse the selective path for original buffers
- *   above this size, since holding them in memory plus the JSZip overhead is
+ *   above this size, since holding them in memory plus the archive overhead is
  *   the dominant cost.
  */
 export type FolioSelectiveSaveFlags = {

package/dist/docx/selectiveSaveTripwire.js

@@ -1,4 +1,5 @@
 import { panic } from "better-result";
+import { ZipArchive } from "@stll/docx-core/zip";
 // src/docx/selectiveSaveTripwire.ts
 /**
 * Selective Save Tripwire
@@ -16,17 +17,10 @@ import { panic } from "better-result";
 */
 const IGNORED_PATHS = /* @__PURE__ */ new Set(["docProps/core.xml"]);
 async function listEntries(buffer) {
-	const zip = await (await import("jszip")).default.loadAsync(buffer);
-	const paths = [];
-	for (const [path, entry] of Object.entries(zip.files)) {
-		if (entry.dir) continue;
-		if (IGNORED_PATHS.has(path)) continue;
-		paths.push(path);
-	}
-	paths.sort();
+	const zip = await ZipArchive.read(buffer);
 	return {
 		zip,
-		paths
+		paths: zip.paths().filter((path) => !IGNORED_PATHS.has(path)).toSorted()
 	};
 }
 function bytesEqual(a, b) {
@@ -35,9 +29,9 @@ function bytesEqual(a, b) {
 	return true;
 }
 function readEntryBytes(zip, path, side) {
-	const entry = zip.file(path);
+	const entry = zip.entry(path);
 	if (!entry) panic(`Missing ${side} zip entry: ${path}`);
-	return entry.async("uint8array");
+	return entry.bytes();
 }
 function readCommonEntryBytes(selectiveZip, fullZip) {
 	return Promise.all(selectiveZip.paths.map(async (path) => {

package/dist/docx/server/applyDocxXmlPatchProposal.js

@@ -1,11 +1,9 @@
-import { encodeUtf8 } from "../../utils/textEncoding.js";
 import { loadDocxArchive } from "./boundedArchive.js";
 import { FOLIO_DOCX_XML_PATCH_PROPOSAL_PROFILE, InvalidFolioDocxXmlPatchProposalError, evaluateDocxXmlPatchProposal, parseFolioDocxXmlPatchProposal } from "./evaluateDocxXmlPatchProposal.js";
 import { FOLIO_DOCX_CONFORMANCE_PROFILE, validateDocxConformance } from "./validateDocxConformance.js";
 import { TaggedError, panic } from "better-result";
 import { createHash } from "node:crypto";
-import JSZip from "jszip";
-import { writeZipPart } from "@stll/docx-core/zip";
+import { ZipArchive } from "@stll/docx-core/zip";
 // src/docx/server/applyDocxXmlPatchProposal.ts
 const FOLIO_DOCX_XML_PATCH_APPLICATION_VERSION = 1;
 const FOLIO_DOCX_XML_PATCH_APPLICATION_PROFILE = "folio-xml-patch-application-v1";
@@ -60,29 +58,26 @@ const verifyArchiveContents = async (bytes, options) => {
 			cause
 		});
 	}
-	for (const entry of archive.entryMetadata.toSorted(({ path: left }, { path: right }) => left < right ? -1 : Number(left > right))) {
-		if (entry.directory) continue;
-		try {
-			if (await archive.readEntryUint8(entry.path) === null) throw new FolioDocxXmlPatchApplicationError({
-				message: "An archive entry disappeared during verification.",
-				stage: "verify",
-				part: entry.path
-			});
-		} catch (cause) {
-			if (cause instanceof FolioDocxXmlPatchApplicationError) throw cause;
-			throw new FolioDocxXmlPatchApplicationError({
-				message: "An archive entry could not be verified within the configured limits.",
-				stage: "verify",
-				part: entry.path,
-				cause
-			});
-		}
+	for (const entry of archive.entryMetadata.toSorted(({ path: left }, { path: right }) => left < right ? -1 : Number(left > right))) try {
+		if (await archive.readEntryUint8(entry.path) === null) throw new FolioDocxXmlPatchApplicationError({
+			message: "An archive entry disappeared during verification.",
+			stage: "verify",
+			part: entry.path
+		});
+	} catch (cause) {
+		if (cause instanceof FolioDocxXmlPatchApplicationError) throw cause;
+		throw new FolioDocxXmlPatchApplicationError({
+			message: "An archive entry could not be verified within the configured limits.",
+			stage: "verify",
+			part: entry.path,
+			cause
+		});
 	}
 };
 const applyReplacements = async ({ bytes, proposal }) => {
 	let zip;
 	try {
-		zip = await JSZip.loadAsync(bytes);
+		zip = await ZipArchive.read(bytes);
 	} catch (cause) {
 		throw new FolioDocxXmlPatchApplicationError({
 			message: "The evaluated package could not be loaded for replacement.",
@@ -91,31 +86,15 @@ const applyReplacements = async ({ bytes, proposal }) => {
 		});
 	}
 	for (const replacement of proposal.replacements) {
-		const current = zip.file(replacement.path);
-		if (current === null) throw new FolioDocxXmlPatchApplicationError({
+		const current = zip.entry(replacement.path);
+		if (current === void 0) throw new FolioDocxXmlPatchApplicationError({
 			message: "An evaluated package part was unavailable during replacement.",
 			stage: "replace"
 		});
-		writeZipPart({
-			zip,
-			path: replacement.path,
-			data: encodeUtf8(replacement.replacementXml),
-			options: {
-				date: current.date,
-				comment: current.comment,
-				unixPermissions: current.unixPermissions,
-				dosPermissions: current.dosPermissions,
-				compression: "DEFLATE",
-				compressionOptions: { level: 6 }
-			}
-		});
+		zip.set(replacement.path, replacement.replacementXml, { modified: current.modified });
 	}
 	try {
-		return await zip.generateAsync({
-			type: "uint8array",
-			compression: "DEFLATE",
-			compressionOptions: { level: 6 }
-		});
+		return await zip.generate({ level: 6 });
 	} catch (cause) {
 		throw new FolioDocxXmlPatchApplicationError({
 			message: "The replacement package could not be generated.",

package/dist/docx/server/boundedArchive.d.ts

@@ -37,8 +37,7 @@ export type DocxArchiveOptions = {
 };
 export type DocxArchiveEntry = {
   readonly path: string;
-  readonly directory: boolean;
-  readonly declaredUncompressedBytes: number | null;
+  readonly declaredUncompressedBytes: number;
 };
 export type DocxArchiveReadOptions = {
   maxBytes?: number;

package/dist/docx/server/boundedArchive.js

@@ -1,8 +1,8 @@
 import { decodeText } from "../../utils/textEncoding.js";
-import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits } from "../archiveInflation.js";
+import { DOCX_COMPRESSION_RATIO_GRACE_BYTES, isRatioBoundedPart } from "../archiveInflation.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "../xmlResourceLimits.js";
-import { TaggedError } from "better-result";
-import JSZip from "jszip";
+import { Result, TaggedError } from "better-result";
+import { ZipArchive, ZipError } from "@stll/docx-core/zip";
 // src/docx/server/boundedArchive.ts
 const DOCX_MAX_ENTRY_BYTES = 134217728;
 const DOCX_MAX_TOTAL_BYTES = 268435456;
@@ -11,27 +11,42 @@ const DOCX_MAX_INPUT_BYTES = 52428800;
 const DocxArchiveErrorBase = TaggedError("DocxArchiveError");
 /** Error raised when a DOCX archive cannot be loaded within configured limits. */
 var DocxArchiveError = class extends DocxArchiveErrorBase {};
-const readLimitError = ({ limit, path, maxEntryBytes, maxTotalBytes, maxCompressionRatio }) => {
-	switch (limit) {
-		case "declared-size": return new DocxArchiveError({
-			message: `DOCX entry "${path}" inflated past its declared size`,
-			reason: "entry-too-large"
+/** The archive error for a read the ZIP reader refused. */
+const archiveErrorFor = (error, { maxEntryBytes, maxTotalBytes, maxEntries, maxCompressionRatio }) => {
+	const entry = error.path === void 0 ? "" : ` "${error.path}"`;
+	switch (error.reason) {
+		case "too-many-entries": return new DocxArchiveError({
+			message: `DOCX archive holds more than ${maxEntries} entries`,
+			reason: "too-many-entries"
 		});
-		case "compression-ratio": return new DocxArchiveError({
-			message: `DOCX entry "${path}" exceeded the ${maxCompressionRatio}:1 compression ratio limit`,
-			reason: "compression-ratio-exceeded"
+		case "entry-too-large": return new DocxArchiveError({
+			message: `DOCX entry${entry} declares more than ${maxEntryBytes} bytes`,
+			reason: "entry-too-large"
 		});
-		case "entry": return new DocxArchiveError({
-			message: `DOCX entry "${path}" exceeded the ${maxEntryBytes}-byte limit`,
+		case "declared-size-exceeded": return new DocxArchiveError({
+			message: `DOCX entry${entry} inflated past its declared size`,
 			reason: "entry-too-large"
 		});
-		case "total":
-		case "aborted": return new DocxArchiveError({
-			message: `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`,
+		case "total-too-large": return new DocxArchiveError({
+			message: `DOCX archive declares more than ${maxTotalBytes} cumulative bytes`,
 			reason: "total-too-large"
 		});
+		case "compression-ratio": return new DocxArchiveError({
+			message: error.path === void 0 ? `DOCX archive declares more than ${maxCompressionRatio} bytes per archive byte` : `DOCX entry${entry} declares more than ${maxCompressionRatio} bytes per compressed byte`,
+			reason: "compression-ratio-exceeded"
+		});
+		case "malformed":
+		case "unsupported":
+		case "invalid-entry-name":
+		case "duplicate-entry":
+		case "corrupt-entry": return new DocxArchiveError({
+			message: "Failed to parse DOCX archive",
+			reason: "load-failed",
+			cause: error
+		});
 	}
 };
+const toArchiveError = (cause, limits) => cause instanceof ZipError ? archiveErrorFor(cause, limits) : cause;
 const resolveByteLimit = ({ value, fallback, name }) => {
 	const limit = value ?? fallback;
 	if (!Number.isSafeInteger(limit) || limit < 0) throw new DocxArchiveError({
@@ -40,7 +55,6 @@ const resolveByteLimit = ({ value, fallback, name }) => {
 	});
 	return limit;
 };
-const asBytes = (bytes) => bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
 const loadDocxArchive = async (bytes, options = {}) => {
 	const maxInputBytes = resolveByteLimit({
 		value: options.maxInputBytes,
@@ -71,103 +85,68 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		message: `DOCX input contains ${bytes.byteLength} bytes (max ${maxInputBytes})`,
 		reason: "input-too-large"
 	});
-	if (countCentralDirectoryRecords(asBytes(bytes), maxEntries) > maxEntries) throw new DocxArchiveError({
-		message: `DOCX archive holds more than ${maxEntries} entries`,
-		reason: "too-many-entries"
-	});
-	let zip;
-	try {
-		zip = await JSZip.loadAsync(bytes);
-	} catch (cause) {
-		throw new DocxArchiveError({
-			message: "Failed to parse DOCX archive",
-			reason: "load-failed",
-			cause
-		});
-	}
-	const archiveEntries = Object.values(zip.files);
-	if (archiveEntries.length > maxEntries) throw new DocxArchiveError({
-		message: `DOCX archive declares ${archiveEntries.length} entries (max ${maxEntries})`,
-		reason: "too-many-entries"
-	});
-	let declaredTotalBytes = 0;
-	let declaredTotalKnown = true;
-	for (const entry of archiveEntries) {
-		if (entry.dir) continue;
-		const { compressedBytes, uncompressedBytes } = getZipEntrySizes(entry);
-		if (uncompressedBytes === null) {
-			declaredTotalKnown = false;
-			continue;
-		}
-		if (uncompressedBytes > maxEntryBytes) throw new DocxArchiveError({
-			message: `DOCX entry "${entry.name}" declares ${uncompressedBytes} bytes (max ${maxEntryBytes})`,
-			reason: "entry-too-large"
-		});
-		if (exceedsCompressionRatio({
-			inflatedBytes: uncompressedBytes,
-			compressedBytes,
-			maxRatio: compressionRatioLimitFor(entry.name, maxCompressionRatio)
-		})) throw new DocxArchiveError({
-			message: `DOCX entry "${entry.name}" declares more than ${maxCompressionRatio} bytes per compressed byte`,
-			reason: "compression-ratio-exceeded"
-		});
-		declaredTotalBytes += uncompressedBytes;
-	}
-	if (declaredTotalKnown && declaredTotalBytes > maxTotalBytes) throw new DocxArchiveError({
-		message: `DOCX archive declares ${declaredTotalBytes} cumulative bytes (max ${maxTotalBytes})`,
-		reason: "total-too-large"
-	});
-	if (exceedsCompressionRatio({
-		inflatedBytes: declaredTotalBytes,
-		compressedBytes: bytes.byteLength,
-		maxRatio: maxCompressionRatio
-	})) throw new DocxArchiveError({
-		message: `DOCX archive declares more than ${maxCompressionRatio} bytes per archive byte`,
-		reason: "compression-ratio-exceeded"
+	const limits = {
+		maxEntryBytes,
+		maxTotalBytes,
+		maxEntries,
+		maxCompressionRatio
+	};
+	const read = await Result.tryPromise({
+		try: async () => await ZipArchive.read(bytes, {
+			limits: {
+				maxEntries,
+				maxEntryBytes,
+				maxTotalBytes,
+				maxCompressionRatio,
+				compressionRatioGraceBytes: DOCX_COMPRESSION_RATIO_GRACE_BYTES
+			},
+			isCompressionRatioExempt: (path) => !isRatioBoundedPart(path)
+		}),
+		catch: (cause) => toArchiveError(cause, limits)
 	});
+	if (Result.isError(read)) throw read.error;
+	const zip = read.value;
+	const archiveEntries = zip.entries();
 	const xmlLimits = {
 		...FOLIO_XML_RESOURCE_LIMITS,
 		...options.xmlLimits
 	};
 	const xmlBudget = createXmlPackageBudget();
 	const countedParts = /* @__PURE__ */ new Set();
-	const inflationBudget = createInflationBudget(maxTotalBytes);
-	let readChain = Promise.resolve();
+	let readBytes = 0;
 	const readEntry = async (path, readOptions = {}) => {
 		const requestedMaxBytes = resolveByteLimit({
 			value: readOptions.maxBytes,
 			fallback: maxEntryBytes,
 			name: "DOCX entry read byte limit"
 		});
-		const work = async () => {
-			const entry = zip.file(path);
-			if (!entry) return null;
-			const entryLimit = Math.min(requestedMaxBytes, maxEntryBytes);
-			const result = await inflateEntryWithinLimits({
-				entry,
-				maxEntryBytes: entryLimit,
-				maxCompressionRatio: compressionRatioLimitFor(path, maxCompressionRatio),
-				budget: inflationBudget
-			});
-			if (!result.ok) throw readLimitError({
-				limit: result.limit,
-				path,
-				maxEntryBytes: entryLimit,
-				maxTotalBytes,
-				maxCompressionRatio
-			});
-			return result.bytes;
-		};
-		const next = readChain.then(work, work);
-		readChain = next.then(() => void 0, () => void 0);
-		return await next;
+		const entry = zip.entry(path);
+		if (!entry) return null;
+		const entryLimit = Math.min(requestedMaxBytes, maxEntryBytes);
+		if (entry.size > entryLimit) throw new DocxArchiveError({
+			message: `DOCX entry "${path}" exceeded the ${entryLimit}-byte limit`,
+			reason: "entry-too-large"
+		});
+		if (readBytes + entry.size > maxTotalBytes) throw new DocxArchiveError({
+			message: `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`,
+			reason: "total-too-large"
+		});
+		readBytes += entry.size;
+		const content = await Result.tryPromise({
+			try: async () => await entry.bytes(),
+			catch: (cause) => toArchiveError(cause, limits)
+		});
+		if (Result.isError(content)) {
+			readBytes -= entry.size;
+			throw content.error;
+		}
+		return content.value;
 	};
 	return {
-		entries: Object.freeze(archiveEntries.map(({ name }) => name)),
+		entries: Object.freeze(archiveEntries.map(({ path }) => path)),
 		entryMetadata: Object.freeze(archiveEntries.map((entry) => ({
-			path: entry.name,
-			directory: entry.dir,
-			declaredUncompressedBytes: getZipEntrySizes(entry).uncompressedBytes
+			path: entry.path,
+			declaredUncompressedBytes: entry.size
 		}))),
 		async readEntryString(path) {
 			const content = await readEntry(path);

package/dist/docx/server/inspectDocxPackage.d.ts

@@ -30,7 +30,7 @@ export type FolioDocxPackagePart = {
   readonly path: string;
   readonly kind: FolioDocxPackagePartKind;
   readonly contentType: string | null;
-  readonly declaredUncompressedBytes: number | null;
+  readonly declaredUncompressedBytes: number;
 };
 export type FolioDocxInspectedXmlPart = {
   readonly path: string;

package/dist/docx/server/inspectDocxPackage.js

@@ -200,7 +200,7 @@ const inspectDocxPackage = async (bytes, options = {}) => {
 	const archive = await loadDocxArchive(bytes, options.archive);
 	const contentTypesBytes = await archive.readEntryUint8(CONTENT_TYPES_PATH, { maxBytes: CONTENT_TYPES_READ_LIMIT });
 	const declarations = parseContentTypes(contentTypesBytes === null ? null : decodeXml(contentTypesBytes, CONTENT_TYPES_PATH));
-	const parts = archive.entryMetadata.filter(({ directory }) => !directory).map((entry) => toPackagePart(entry, declarations)).toSorted(({ path: left }, { path: right }) => comparePackagePaths(left, right));
+	const parts = archive.entryMetadata.map((entry) => toPackagePart(entry, declarations)).toSorted(({ path: left }, { path: right }) => comparePackagePaths(left, right));
 	const partsByPath = new Map(parts.map((part) => [part.path, part]));
 	validateRequestedParts({
 		requestedPaths,

package/dist/docx/unzip.d.ts

@@ -1,4 +1,4 @@
-import JSZip from "jszip";
+import { ZipArchive } from "@stll/docx-core/zip";
 export declare class DocxSecurityError extends Error {
   constructor(message: string);
 }
@@ -75,7 +75,7 @@ export type RawDocxContent = {
   media: Map<string, ArrayBuffer>;
   fonts: Map<string, ArrayBuffer>;
   allXml: Map<string, string>;
-  originalZip: JSZip;
+  originalZip: ZipArchive;
   originalBuffer: ArrayBuffer;
   warnings: string[];
   /** True when the input was a password-protected CFB container. */
@@ -100,7 +100,6 @@ export type UnzipDocxBehavior = {
 export declare function unzipDocx(buffer: ArrayBuffer, options?: DocxUnzipOptions, { verifyUnreadEntries }?: UnzipDocxBehavior): Promise<RawDocxContent>;
 /** Keep extracted projections and the source ZIP aligned after parser normalization. */
 export declare const replaceRawDocxXmlParts: (content: RawDocxContent, parts: ReadonlyMap<string, string>) => Promise<void>;
-export declare function getEntryUncompressedSize(file: JSZip.JSZipObject): number | null;
 /**
  * Get a list of all files in the DOCX
  *