@stll/folio-core 0.64.1 → 0.66.0

package/dist/docx/sdtProperties.js

@@ -69,8 +69,7 @@ const W15_LOCAL_NAMES = /* @__PURE__ */ new Set(["repeatingSection", "repeatingS
 * would produce invalid XML in the saved DOCX — Word refuses files
 * with unresolved namespace prefixes.
 *
-* Heuristics, since fast-xml-parser does not surface namespace URIs in
-* preserveOrder mode:
+* Heuristics, from when the XML reader did not surface namespace URIs:
 *
 * 1. If the captured wrapper element itself uses a non-`w` prefix, that
 *    prefix is taken to be bound to the WP URI (the source DOCX would

package/dist/docx/selectedXmlIdentityScan.d.ts

@@ -1,4 +1,4 @@
-import { scanStreamingXmlElements } from "./streamingXmlParser.js";
+import { scanStreamingXmlElements } from "@stll/docx-core/xml";
 /** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */
 export declare const scanSelectedStreamingXmlElements: (xml: string, visitor: Parameters<typeof scanStreamingXmlElements>[1]) => {
   status: "unsupported";

package/dist/docx/selectedXmlIdentityScan.js

@@ -1,5 +1,5 @@
-import { scanStreamingXmlElements } from "./streamingXmlParser.js";
 import { NAMESPACES, getLocalName, getNamespaceUri, selectAlternateContentBranch } from "./xmlParser.js";
+import { scanStreamingXmlElements } from "@stll/docx-core/xml";
 // src/docx/selectedXmlIdentityScan.ts
 const isCompatibilityElement = (element, name) => getNamespaceUri(element) === NAMESPACES.mc && getLocalName(element.name) === name;
 /** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */

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/selectiveXmlPatch.js

@@ -1,11 +1,11 @@
 import { patchBreaksCommentRangeBalance } from "./commentRangeIntegrity.js";
 import { resolveParagraphIdentities } from "./paraIdAttribute.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
-import { scanStreamingXmlElements } from "./streamingXmlParser.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { PARAGRAPH_SCAN_NAMES, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, resolveSelectiveScanPrefixes, splicesAsCanonical } from "./wordprocessingPrefixes.js";
-import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
 import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findAttributeByNamespaceUri, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
+import { scanStreamingXmlElements } from "@stll/docx-core/xml";
+import { resolveNamespaceUri } from "@stll/docx-core/xml/namespaces";
 // src/docx/selectiveXmlPatch.ts
 /**
 * Selective XML Patch Module

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

@@ -1,5 +1,5 @@
-import { XmlResourceLimits } from "../xmlResourceLimits.js";
 import { TaggedErrorClass } from "better-result";
+import { XmlResourceLimits } from "@stll/docx-core/xml/limits";
 export declare const DOCX_MAX_ENTRY_BYTES: number;
 export declare const DOCX_MAX_TOTAL_BYTES: number;
 export declare const DOCX_MAX_ENTRIES = 4096;
@@ -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;