@opengeni/artifact-tool 0.2.2

package/src/document-docx-packer.ts

@@ -0,0 +1,72 @@
+/**
+ * Narrow adapter around the pinned `docx` compiler.
+ *
+ * `docx`'s public Packer hard-codes DEFLATE, which can make valid repetitive
+ * text exceed our secure importer's 100:1 ceiling. Its pinned compiler already
+ * produces a JSZip-compatible archive, so generate those exact OOXML parts as
+ * STORE. If that controlled runtime contract changes, fail closed instead of
+ * silently shipping a second ZIP implementation or masking the incompatibility.
+ */
+
+const DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+
+type GeneratedDocxZip = {
+  forEach(callback: (relativePath: string, entry: { date: Date }) => void): void;
+  generateAsync(options: {
+    type: "uint8array";
+    mimeType: string;
+    compression: "STORE";
+  }): Promise<Uint8Array>;
+};
+
+type DocxCompilerAdapter = {
+  compile(
+    file: unknown,
+    prettify?: undefined,
+    overrides?: readonly DocxXmlOverride[],
+  ): GeneratedDocxZip;
+};
+
+export type DocxXmlOverride = { path: string; data: string };
+
+export class DocxExportCompatibilityError extends Error {
+  readonly name = "DocxExportCompatibilityError";
+  readonly code = "incompatible_docx_runtime" as const;
+}
+
+export async function packDocxWithBoundedCompression(
+  file: unknown,
+  packer: unknown,
+  overrides: readonly DocxXmlOverride[] = [],
+): Promise<Uint8Array> {
+  if ((typeof packer !== "object" && typeof packer !== "function") || packer === null) {
+    throw incompatibleRuntime();
+  }
+  const compiler = Reflect.get(packer, "compiler") as Partial<DocxCompilerAdapter> | undefined;
+  if (!compiler || typeof compiler.compile !== "function") throw incompatibleRuntime();
+  const archive = compiler.compile(file, undefined, overrides);
+  if (
+    !archive ||
+    typeof archive.generateAsync !== "function" ||
+    typeof archive.forEach !== "function"
+  )
+    throw incompatibleRuntime();
+  archive.forEach((_path, entry) => {
+    // ZIP stores local wall-clock fields. Local 1980-01-01 is the portable DOS
+    // epoch and therefore encodes identically regardless of host timezone.
+    entry.date = new Date(1980, 0, 1, 0, 0, 0, 0);
+  });
+  const bytes = await archive.generateAsync({
+    type: "uint8array",
+    mimeType: DOCX_MIME_TYPE,
+    compression: "STORE",
+  });
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0) throw incompatibleRuntime();
+  return bytes;
+}
+
+function incompatibleRuntime(): DocxExportCompatibilityError {
+  return new DocxExportCompatibilityError(
+    "The pinned DOCX runtime no longer exposes the verified bounded-compression compiler adapter",
+  );
+}

package/src/document-docx-state.ts

@@ -0,0 +1,59 @@
+import type { Document } from "./document";
+import {
+  DOCX_MEDIA_TYPE,
+  type DocumentFidelityIssue,
+  type DocumentLossPreservationEnvelope,
+  type DocumentOpaqueContent,
+} from "./document-docx-api";
+
+export type DocumentLossPreservationState = {
+  sourceBytes: Uint8Array;
+  sourceDigest: string;
+  importedRevision: number;
+  opaqueContent: DocumentOpaqueContent;
+  modelDigest: string;
+};
+
+export const DOCUMENT_LOSS_PRESERVATION = new WeakMap<Document, DocumentLossPreservationState>();
+
+export function documentFidelityReport(document: Document): readonly DocumentFidelityIssue[] {
+  const envelope = DOCUMENT_LOSS_PRESERVATION.get(document);
+  if (!envelope) return [];
+  const changed = document.revision !== envelope.importedRevision;
+  return [
+    {
+      code: changed ? "content-will-be-discarded" : "content-preserved-in-source",
+      severity: changed ? "error" : "warning",
+      feature: "opaque-ooxml",
+      message: changed
+        ? "The imported DOCX contains bounded inert OOXML outside the editable model; the document changed, so regenerating DOCX would discard it"
+        : "The imported DOCX contains bounded inert OOXML outside the editable model; unchanged export returns the original package byte-for-byte",
+      parts: [...envelope.opaqueContent.parts],
+      relationships: envelope.opaqueContent.relationships.map((relationship) => ({
+        ...relationship,
+      })),
+      contentTypes: envelope.opaqueContent.contentTypes.map((contentType) => ({ ...contentType })),
+    },
+  ];
+}
+
+export function documentLossPreservationEnvelope(
+  document: Document,
+): DocumentLossPreservationEnvelope | null {
+  const envelope = DOCUMENT_LOSS_PRESERVATION.get(document);
+  if (!envelope) return null;
+  return {
+    version: 1,
+    mediaType: DOCX_MEDIA_TYPE,
+    sourceBytes: envelope.sourceBytes.slice(),
+    sourceDigest: envelope.sourceDigest,
+    opaqueContent: {
+      parts: [...envelope.opaqueContent.parts],
+      relationships: envelope.opaqueContent.relationships.map((relationship) => ({
+        ...relationship,
+      })),
+      contentTypes: envelope.opaqueContent.contentTypes.map((contentType) => ({ ...contentType })),
+    },
+    modelDigest: envelope.modelDigest,
+  };
+}