@veryfront/ext-document-kreuzberg 0.1.988 → 0.1.990

package/esm/extensions/ext-document-kreuzberg/src/index.d.ts

@@ -7,21 +7,26 @@
  * @module extensions/ext-document-kreuzberg
  */
 import "../../../_dnt.polyfills.js";
-import type { ExtensionFactory } from "veryfront/extensions";
-import type { DocumentExtractor, KreuzbergExtractor } from "veryfront/extensions/compat";
+import type { ExtensionFactory, ExtensionLogger } from "veryfront/extensions";
+import type { DocumentExtractionOptions, DocumentExtractor, KreuzbergExtractor } from "veryfront/extensions/compat";
 /** Maximum time to wait for fallback worker extraction before aborting. */
 export declare const EXTRACTION_TIMEOUT_MS = 120000;
+export declare const NATIVE_PROGRESS_IDLE_TIMEOUT_MS = 120000;
+export declare const NATIVE_PROGRESS_HARD_TIMEOUT_MS: number;
 declare function extractInWorkerDeno(buffer: ArrayBuffer, mimeType: string): Promise<string>;
 export interface KreuzbergDocumentExtractorDeps {
     isDenoRuntime?: boolean;
     loadNativeKreuzberg?: () => Promise<KreuzbergExtractor>;
     extractInWorkerDeno?: typeof extractInWorkerDeno;
+    extractWithNativeProgressDeno?: typeof extractWithNativeProgressDeno;
+    logger?: Pick<ExtensionLogger, "warn">;
 }
+declare function extractWithNativeProgressDeno(buffer: ArrayBuffer, mimeType: string, options: DocumentExtractionOptions): Promise<string>;
 export declare class KreuzbergDocumentExtractor implements DocumentExtractor {
     private readonly deps;
     constructor(deps?: KreuzbergDocumentExtractorDeps);
     importKreuzberg(): Promise<KreuzbergExtractor>;
-    extractInWorker(buffer: ArrayBuffer, mimeType: string): Promise<string>;
+    extractInWorker(buffer: ArrayBuffer, mimeType: string, options?: DocumentExtractionOptions): Promise<string>;
 }
 declare const extDocumentKreuzberg: ExtensionFactory;
 export default extDocumentKreuzberg;

package/esm/extensions/ext-document-kreuzberg/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-document-kreuzberg/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,4BAA4B,CAAC;AAKpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAIrG,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAE7C,iBAAS,mBAAmB,CAC1B,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CA0CjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACxD,mBAAmB,CAAC,EAAE,OAAO,mBAAmB,CAAC;CAClD;AAgBD,qBAAa,0BAA2B,YAAW,iBAAiB;IACtD,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,GAAE,8BAAmC;IAEtE,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIxC,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CA2B9E;AAED,QAAA,MAAM,oBAAoB,EAAE,gBAkB3B,CAAC;AAEF,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-document-kreuzberg/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,4BAA4B,CAAC;AAKpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC1F,OAAO,KAAK,EACV,yBAAyB,EAEzB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAIjD,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAC7C,eAAO,MAAM,+BAA+B,SAAU,CAAC;AACvD,eAAO,MAAM,+BAA+B,QAAc,CAAC;AAE3D,iBAAS,mBAAmB,CAC1B,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CA0CjB;AAED,MAAM,WAAW,8BAA8B;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACxD,mBAAmB,CAAC,EAAE,OAAO,mBAAmB,CAAC;IACjD,6BAA6B,CAAC,EAAE,OAAO,6BAA6B,CAAC;IACrE,MAAM,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;CACxC;AAuCD,iBAAS,6BAA6B,CACpC,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,MAAM,CAAC,CAgFjB;AAED,qBAAa,0BAA2B,YAAW,iBAAiB;IACtD,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,GAAE,8BAAmC;IAEtE,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIxC,eAAe,CACnB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,MAAM,CAAC;CAgDnB;AAED,QAAA,MAAM,oBAAoB,EAAE,gBAiB3B,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/esm/extensions/ext-document-kreuzberg/src/index.js

@@ -12,6 +12,8 @@ import { isMissingPackageError, loadKreuzberg, loadKreuzbergNative } from "./kre
 import { isDeno } from "./runtime.js";
 /** Maximum time to wait for fallback worker extraction before aborting. */
 export const EXTRACTION_TIMEOUT_MS = 120_000;
+export const NATIVE_PROGRESS_IDLE_TIMEOUT_MS = 120_000;
+export const NATIVE_PROGRESS_HARD_TIMEOUT_MS = 10 * 60_000;
 function extractInWorkerDeno(buffer, mimeType) {
     return new Promise((resolve, reject) => {
         // The worker ships as raw TypeScript in the compiled binary and from source
@@ -49,11 +51,98 @@ function extractInWorkerDeno(buffer, mimeType) {
 function isPdfMimeType(mimeType) {
     return mimeType.toLowerCase().split(";")[0]?.trim() === "application/pdf";
 }
+function normalizeMimeType(mimeType) {
+    return mimeType.toLowerCase().split(";")[0]?.trim() ?? "";
+}
+function isNativeProgressMimeType(mimeType) {
+    const normalized = normalizeMimeType(mimeType);
+    return normalized === "application/pdf" ||
+        normalized === "application/vnd.ms-powerpoint" ||
+        normalized === "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+}
 async function extractWithNativeKreuzberg(buffer, mimeType, loadNative) {
     const { extractBytes } = await loadNative();
     const result = await extractBytes(new Uint8Array(buffer), mimeType);
     return result.content;
 }
+function warningDetails(mimeType, error) {
+    return {
+        mimeType,
+        error: error instanceof Error ? error.message : String(error),
+    };
+}
+function extractWithNativeProgressDeno(buffer, mimeType, options) {
+    return new Promise((resolve, reject) => {
+        const workerFile = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url.endsWith(".ts")
+            ? "./native-progress-extraction-worker.ts"
+            : "./native-progress-extraction-worker.js";
+        const workerUrl = new URL(workerFile, globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+        const worker = new Worker(workerUrl, { type: "module" });
+        const idleTimeoutMs = options.idleTimeoutMs ?? NATIVE_PROGRESS_IDLE_TIMEOUT_MS;
+        const hardTimeoutMs = options.hardTimeoutMs ?? NATIVE_PROGRESS_HARD_TIMEOUT_MS;
+        let settled = false;
+        let idleTimer;
+        const clearIdleTimer = () => {
+            if (!idleTimer)
+                return;
+            clearTimeout(idleTimer);
+            idleTimer = undefined;
+        };
+        const cleanup = () => {
+            settled = true;
+            clearIdleTimer();
+            clearTimeout(hardTimer);
+            worker.terminate();
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            cleanup();
+            reject(error);
+        };
+        const resetIdleTimer = () => {
+            clearIdleTimer();
+            idleTimer = dntShim.setTimeout(() => {
+                fail(new Error(`Text extraction made no progress for ${idleTimeoutMs / 1000}s. ` +
+                    "The file may be corrupted or unsupported"));
+            }, idleTimeoutMs);
+        };
+        const hardTimer = dntShim.setTimeout(() => {
+            fail(new Error(`Text extraction exceeded the hard timeout after ${hardTimeoutMs / 1000}s. ` +
+                "The file may be corrupted or unsupported"));
+        }, hardTimeoutMs);
+        resetIdleTimer();
+        worker.onmessage = async (event) => {
+            if (settled)
+                return;
+            const message = event.data;
+            if (message.type === "progress") {
+                clearIdleTimer();
+                try {
+                    await options.onProgress?.(message.event);
+                }
+                catch (error) {
+                    fail(error instanceof Error ? error : new Error(String(error)));
+                    return;
+                }
+                if (!settled)
+                    resetIdleTimer();
+                return;
+            }
+            if (message.type === "error") {
+                fail(new Error(message.error));
+                return;
+            }
+            cleanup();
+            resolve(message.content);
+        };
+        worker.onerror = (event) => {
+            fail(new Error(`Text extraction worker failed: ${event.message ?? "unknown"}`));
+        };
+        const requestBuffer = buffer.slice(0);
+        worker.postMessage({ buffer: requestBuffer, mimeType }, [requestBuffer]);
+    });
+}
 export class KreuzbergDocumentExtractor {
     deps;
     constructor(deps = {}) {
@@ -62,7 +151,7 @@ export class KreuzbergDocumentExtractor {
     importKreuzberg() {
         return loadKreuzberg();
     }
-    async extractInWorker(buffer, mimeType) {
+    async extractInWorker(buffer, mimeType, options = {}) {
         const isDenoRuntime = this.deps.isDenoRuntime ?? isDeno;
         const extractWithWorker = this.deps.extractInWorkerDeno ?? extractInWorkerDeno;
         // Node/Bun extract in-process via @kreuzberg/node. Deno keeps the isolated
@@ -73,6 +162,23 @@ export class KreuzbergDocumentExtractor {
             const result = await extractBytes(new Uint8Array(buffer), mimeType);
             return result.content;
         }
+        if (options.onProgress && isNativeProgressMimeType(mimeType)) {
+            try {
+                return await (this.deps.extractWithNativeProgressDeno ?? extractWithNativeProgressDeno)(buffer, mimeType, options);
+            }
+            catch (error) {
+                // Keep progress opportunistic: if page/slide extraction cannot handle a
+                // document, fall back to the previous opaque extraction path.
+                const message = "[ext-document-kreuzberg] native progress extraction failed; falling back to opaque extraction";
+                const details = warningDetails(mimeType, error);
+                if (this.deps.logger) {
+                    this.deps.logger.warn(message, details);
+                }
+                else {
+                    console.warn(message, details);
+                }
+            }
+        }
         if (isPdfMimeType(mimeType)) {
             try {
                 return await extractWithNativeKreuzberg(buffer, mimeType, this.deps.loadNativeKreuzberg ?? loadKreuzbergNative);
@@ -86,7 +192,6 @@ export class KreuzbergDocumentExtractor {
     }
 }
 const extDocumentKreuzberg = () => {
-    const extractor = new KreuzbergDocumentExtractor();
     return {
         name: "ext-document-kreuzberg",
         version: "0.1.0",
@@ -97,6 +202,7 @@ const extDocumentKreuzberg = () => {
             { type: "fs:read" },
         ],
         setup(ctx) {
+            const extractor = new KreuzbergDocumentExtractor({ logger: ctx.logger });
             ctx.provide("DocumentExtractor", extractor);
             ctx.logger.info("[ext-document-kreuzberg] document extraction registered");
         },

package/esm/extensions/ext-document-kreuzberg/src/native-progress-extraction-worker.js

@@ -0,0 +1,161 @@
+import { PDFDocument } from "pdf-lib";
+import JSZip from "jszip";
+import { loadKreuzbergNative } from "./kreuzberg.js";
+function postProgress(event) {
+  self.postMessage({ type: "progress", event });
+}
+function normalizeMimeType(mimeType) {
+  return mimeType.toLowerCase().split(";")[0]?.trim() ?? "";
+}
+function isPdfMimeType(mimeType) {
+  return normalizeMimeType(mimeType) === "application/pdf";
+}
+function isPptxMimeType(mimeType) {
+  return normalizeMimeType(mimeType) === "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+}
+function decodeXmlText(value) {
+  return value.replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))
+  ).replace(/&#(\d+);/g, (_, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10))).replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function extractPptxSlideText(xml) {
+  return Array.from(xml.matchAll(/<a:t(?:\s[^>]*)?>([\s\S]*?)<\/a:t>/g)).map((match) => decodeXmlText(match[1] ?? "").trim()).filter(Boolean).join(" ").trim();
+}
+function slideNumber(path) {
+  return Number(path.match(/\/slide(\d+)\.xml$/)?.[1] ?? 0);
+}
+function getXmlAttribute(tag, name) {
+  const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return tag.match(new RegExp(`\\s${escapedName}=(["'])(.*?)\\1`))?.[2];
+}
+function normalizeZipPath(path) {
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.join("/");
+}
+function normalizePresentationTarget(target) {
+  const path = target.split(/[?#]/)[0] ?? target;
+  if (path.startsWith("/")) return normalizeZipPath(path.slice(1));
+  if (path.startsWith("ppt/")) return normalizeZipPath(path);
+  return normalizeZipPath(`ppt/${path}`);
+}
+function presentationSlideRelationshipIds(xml) {
+  return Array.from(xml.matchAll(/<(?:\w+:)?sldId\b[^>]*>/g)).map((match) => getXmlAttribute(match[0], "r:id")).filter((id) => typeof id === "string" && id.length > 0);
+}
+function presentationRelationships(xml) {
+  const relationships = /* @__PURE__ */ new Map();
+  for (const match of xml.matchAll(/<Relationship\b[^>]*>/g)) {
+    const tag = match[0];
+    const id = getXmlAttribute(tag, "Id");
+    const target = getXmlAttribute(tag, "Target");
+    if (!id || !target) continue;
+    const path = normalizePresentationTarget(target);
+    if (/^ppt\/slides\/slide\d+\.xml$/.test(path)) {
+      relationships.set(id, path);
+    }
+  }
+  return relationships;
+}
+async function pptxSlidePaths(zip) {
+  const fallback = Object.keys(zip.files).filter((path) => /^ppt\/slides\/slide\d+\.xml$/.test(path)).sort((left, right) => slideNumber(left) - slideNumber(right));
+  const presentation = zip.file("ppt/presentation.xml");
+  const rels = zip.file("ppt/_rels/presentation.xml.rels");
+  if (!presentation || !rels) return fallback;
+  const [presentationXml, relsXml] = await Promise.all([
+    presentation.async("text"),
+    rels.async("text")
+  ]);
+  const relationships = presentationRelationships(relsXml);
+  const fallbackSet = new Set(fallback);
+  const ordered = [];
+  for (const id of presentationSlideRelationshipIds(presentationXml)) {
+    const path = relationships.get(id);
+    if (path && fallbackSet.has(path) && !ordered.includes(path)) {
+      ordered.push(path);
+    }
+  }
+  if (!ordered.length) return fallback;
+  return [
+    ...ordered,
+    ...fallback.filter((path) => !ordered.includes(path))
+  ];
+}
+async function extractPdfByPage(buffer) {
+  const { extractBytes } = await loadKreuzbergNative();
+  const source = await PDFDocument.load(buffer, { ignoreEncryption: true });
+  const total = source.getPageCount();
+  const pages = [];
+  for (let index = 0; index < total; index += 1) {
+    const singlePage = await PDFDocument.create();
+    const [page] = await singlePage.copyPages(source, [index]);
+    singlePage.addPage(page);
+    const bytes = await singlePage.save({ useObjectStreams: false });
+    const result = await extractBytes(new Uint8Array(bytes), "application/pdf");
+    const content = result.content.trim();
+    pages.push(content);
+    postProgress({
+      unit: "page",
+      current: index + 1,
+      total,
+      characters: content.length
+    });
+  }
+  return pages.filter(Boolean).join("\n\n");
+}
+async function extractPptxBySlide(buffer, mimeType) {
+  const zip = await JSZip.loadAsync(buffer);
+  const slidePaths = await pptxSlidePaths(zip);
+  if (!slidePaths.length) {
+    const { extractBytes } = await loadKreuzbergNative();
+    const result = await extractBytes(new Uint8Array(buffer), mimeType);
+    postProgress({ unit: "file", current: 1, total: 1, characters: result.content.length });
+    return result.content;
+  }
+  const slides = [];
+  for (const [index, path] of slidePaths.entries()) {
+    const file = zip.file(path);
+    const xml = file ? await file.async("text") : "";
+    const content = extractPptxSlideText(xml);
+    slides.push(content);
+    postProgress({
+      unit: "slide",
+      current: index + 1,
+      total: slidePaths.length,
+      characters: content.length
+    });
+  }
+  return slides.filter(Boolean).join("\n\n");
+}
+async function extractWholeFile(buffer, mimeType) {
+  const { extractBytes } = await loadKreuzbergNative();
+  const result = await extractBytes(new Uint8Array(buffer), mimeType);
+  postProgress({ unit: "file", current: 1, total: 1, characters: result.content.length });
+  return result.content;
+}
+self.onmessage = async (event) => {
+  if (event.origin && event.origin !== self.location.origin) {
+    self.postMessage(
+      {
+        type: "error",
+        error: "Rejected document extraction request from invalid origin"
+      }
+    );
+    return;
+  }
+  try {
+    const { buffer, mimeType } = event.data;
+    const content = isPdfMimeType(mimeType) ? await extractPdfByPage(buffer) : isPptxMimeType(mimeType) ? await extractPptxBySlide(buffer, mimeType) : await extractWholeFile(buffer, mimeType);
+    self.postMessage({ type: "done", content });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    self.postMessage({ type: "error", error: message });
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-document-kreuzberg",
-  "version": "0.1.988",
+  "version": "0.1.990",
   "description": "Veryfront first-party extension package for ext-document-kreuzberg",
   "keywords": [
     "veryfront",
@@ -50,10 +50,12 @@
     "@deno/shim-crypto": "~0.3.1",
     "@deno/shim-timers": "~0.1.0",
     "@kreuzberg/node": "4.4.2",
-    "@kreuzberg/wasm": "4.5.2"
+    "@kreuzberg/wasm": "4.5.2",
+    "jszip": "3.10.1",
+    "pdf-lib": "1.17.1"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.988"
+    "veryfront": "^0.1.990"
   },
   "type": "module",
   "types": "./esm/extensions/ext-document-kreuzberg/src/index.d.ts",