@echofiles/echo-pdf 0.4.3 → 0.6.0

package/dist/node/semantic-local.js

@@ -1,113 +0,0 @@
-const normalizeLine = (value) => value.replace(/\s+/g, " ").trim();
-const excerptFor = (value) => normalizeLine(value).slice(0, 160);
-const hasTocSuffix = (value) => /(?:\.{2,}|\s{2,}|\t)\d+$/.test(value);
-const hasTrailingPageNumber = (value) => /\s\d+$/.test(value);
-const isContentsHeading = (value) => {
-    const normalized = normalizeLine(value).toLowerCase();
-    return normalized === "contents" || normalized === "table of contents" || normalized === "目录";
-};
-const detectHeading = (line) => {
-    const normalized = normalizeLine(line);
-    if (!normalized || normalized.length > 120)
-        return null;
-    if (hasTocSuffix(normalized))
-        return null;
-    const numbered = normalized.match(/^(\d+(?:\.\d+){0,3})\s+(.+)$/);
-    if (numbered) {
-        const numberPath = numbered[1] || "";
-        const topLevelNumber = Number.parseInt(numberPath.split(".")[0] || "", 10);
-        const title = normalizeLine(numbered[2] || "");
-        const level = numberPath.split(".").length;
-        if (!title)
-            return null;
-        if (title.length < 2)
-            return null;
-        if (hasTrailingPageNumber(normalized))
-            return null;
-        if (!/^[A-Za-z\u4E00-\u9FFF第（(]/.test(title))
-            return null;
-        if (/^(GHz|MHz|Kbps|Mbps|Hz|kHz|mA|V|W)\b/i.test(title))
-            return null;
-        if (/[。；;：:]$/.test(title))
-            return null;
-        if (Number.isFinite(topLevelNumber) && topLevelNumber > 20)
-            return null;
-        if (/^[A-Z]+\d+$/.test(title))
-            return null;
-        if (level === 1 && title.length > 40)
-            return null;
-        if (level === 1 && /[，,×—]/.test(title))
-            return null;
-        return {
-            title: `${numberPath} ${title}`.trim(),
-            level,
-        };
-    }
-    const chinese = normalized.match(/^(第[0-9一二三四五六七八九十百]+)(章|节|部分)\s+(.+)$/);
-    if (chinese) {
-        const suffix = chinese[2] || "";
-        return {
-            title: normalized,
-            level: suffix === "节" ? 2 : 1,
-        };
-    }
-    const english = normalized.match(/^(Chapter|Section|Part|Appendix)\b[:\s-]*(.+)?$/i);
-    if (english) {
-        return {
-            title: normalized,
-            level: /section/i.test(english[1] || "") ? 2 : 1,
-        };
-    }
-    return null;
-};
-const toReadonlyTree = (node) => ({
-    ...node,
-    children: node.children.map(toReadonlyTree),
-});
-export const buildSemanticSectionTree = (pages) => {
-    const rootChildren = [];
-    const stack = [];
-    const emittedKeys = new Set();
-    let nextId = 1;
-    for (const page of pages) {
-        const lines = page.text
-            .split(/\r?\n/)
-            .map(normalizeLine)
-            .filter(Boolean);
-        if (lines.length === 0)
-            continue;
-        const contentsPage = isContentsHeading(lines[0] || "");
-        for (const line of lines) {
-            const heading = detectHeading(line);
-            if (!heading || contentsPage)
-                continue;
-            const emittedKey = `${heading.level}:${heading.title}`;
-            if (emittedKeys.has(emittedKey))
-                continue;
-            const node = {
-                id: `section-${nextId}`,
-                type: "section",
-                title: heading.title,
-                level: heading.level,
-                pageNumber: page.pageNumber,
-                pageArtifactPath: page.artifactPath,
-                excerpt: excerptFor(line),
-                children: [],
-            };
-            nextId += 1;
-            emittedKeys.add(emittedKey);
-            while (stack.length > 0 && (stack[stack.length - 1]?.level || 0) >= heading.level) {
-                stack.pop();
-            }
-            const parent = stack[stack.length - 1];
-            if (parent) {
-                parent.children.push(node);
-            }
-            else {
-                rootChildren.push(node);
-            }
-            stack.push(node);
-        }
-    }
-    return rootChildren.map(toReadonlyTree);
-};

package/dist/pdf-agent.d.ts

@@ -1,18 +0,0 @@
-import type { Env, FileStore } from "./types.js";
-import type { AgentTraceEvent, EchoPdfConfig, PdfOperationRequest } from "./pdf-types.js";
-interface RuntimeOptions {
-    readonly trace?: (event: AgentTraceEvent) => void;
-    readonly fileStore: FileStore;
-}
-export declare const ingestPdfFromPayload: (config: EchoPdfConfig, input: {
-    readonly fileId?: string;
-    readonly url?: string;
-    readonly base64?: string;
-    readonly filename?: string;
-}, opts: RuntimeOptions) => Promise<{
-    id: string;
-    filename: string;
-    bytes: Uint8Array;
-}>;
-export declare const runPdfAgent: (config: EchoPdfConfig, env: Env, request: PdfOperationRequest, opts: RuntimeOptions) => Promise<unknown>;
-export {};

package/dist/pdf-agent.js

@@ -1,217 +0,0 @@
-import { resolveModelForProvider, resolveProviderAlias } from "./agent-defaults.js";
-import { fromBase64, normalizeReturnMode, toDataUrl } from "./file-utils.js";
-import { badRequest, notFound, unprocessable } from "./http-error.js";
-import { extractPdfPageText, getPdfPageCount, renderPdfPageToPng, toBytes } from "./pdfium-engine.js";
-import { visionRecognize } from "./provider-client.js";
-const traceStep = (opts, phase, name, payload, level) => {
-    if (!opts.trace)
-        return;
-    opts.trace({ kind: "step", phase, name, payload, level });
-};
-const ensurePages = (pages, pageCount, maxPages) => {
-    if (pages.length === 0)
-        throw badRequest("PAGES_REQUIRED", "At least one page is required");
-    if (pages.length > maxPages) {
-        throw badRequest("TOO_MANY_PAGES", `Page count exceeds maxPagesPerRequest (${maxPages})`, {
-            maxPagesPerRequest: maxPages,
-            providedPages: pages.length,
-        });
-    }
-    for (const page of pages) {
-        if (!Number.isInteger(page) || page < 1 || page > pageCount) {
-            throw badRequest("PAGE_OUT_OF_RANGE", `Page ${page} out of range 1..${pageCount}`, {
-                page,
-                min: 1,
-                max: pageCount,
-            });
-        }
-    }
-    return [...new Set(pages)].sort((a, b) => a - b);
-};
-export const ingestPdfFromPayload = async (config, input, opts) => {
-    if (input.fileId) {
-        const existing = await opts.fileStore.get(input.fileId);
-        if (!existing) {
-            throw notFound("FILE_NOT_FOUND", `File not found: ${input.fileId}`, { fileId: input.fileId });
-        }
-        return {
-            id: existing.id,
-            filename: existing.filename,
-            bytes: existing.bytes,
-        };
-    }
-    let bytes = null;
-    let filename = input.filename ?? "document.pdf";
-    if (input.url) {
-        traceStep(opts, "start", "file.fetch.url", { url: input.url });
-        try {
-            bytes = await toBytes(input.url);
-        }
-        catch (error) {
-            throw badRequest("URL_FETCH_FAILED", `Unable to fetch PDF from url: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        try {
-            const u = new URL(input.url);
-            filename = decodeURIComponent(u.pathname.split("/").pop() || filename);
-        }
-        catch {
-            // ignore URL parse failure
-        }
-        traceStep(opts, "end", "file.fetch.url", { sizeBytes: bytes.byteLength });
-    }
-    else if (input.base64) {
-        traceStep(opts, "start", "file.decode.base64");
-        bytes = fromBase64(input.base64);
-        traceStep(opts, "end", "file.decode.base64", { sizeBytes: bytes.byteLength });
-    }
-    if (!bytes) {
-        throw badRequest("MISSING_FILE_INPUT", "Missing file input. Provide fileId, url or base64");
-    }
-    if (bytes.byteLength > config.service.maxPdfBytes) {
-        throw badRequest("PDF_TOO_LARGE", `PDF exceeds max size (${config.service.maxPdfBytes} bytes)`, {
-            maxPdfBytes: config.service.maxPdfBytes,
-            sizeBytes: bytes.byteLength,
-        });
-    }
-    const meta = await opts.fileStore.put({
-        filename,
-        mimeType: "application/pdf",
-        bytes,
-    });
-    traceStep(opts, "end", "file.stored", { fileId: meta.id, sizeBytes: meta.sizeBytes });
-    return {
-        id: meta.id,
-        filename: meta.filename,
-        bytes,
-    };
-};
-const resolveReturnMode = (value) => normalizeReturnMode(value);
-const stripCodeFences = (value) => {
-    const text = value.trim();
-    const fenced = text.match(/^```[a-zA-Z0-9_-]*\n([\s\S]*?)\n```$/);
-    return typeof fenced?.[1] === "string" ? fenced[1].trim() : text;
-};
-const extractTabularLatex = (value) => {
-    const text = stripCodeFences(value);
-    const blocks = text.match(/\\begin\{tabular\}[\s\S]*?\\end\{tabular\}/g);
-    if (!blocks || blocks.length === 0)
-        return "";
-    return blocks.map((b) => b.trim()).join("\n\n");
-};
-export const runPdfAgent = async (config, env, request, opts) => {
-    traceStep(opts, "start", "pdf.operation", { operation: request.operation });
-    const file = await ingestPdfFromPayload(config, request, opts);
-    const pageCount = await getPdfPageCount(config, file.bytes);
-    traceStep(opts, "log", "pdf.meta", { fileId: file.id, pageCount });
-    const pages = ensurePages(request.pages, pageCount, config.service.maxPagesPerRequest);
-    const scale = request.renderScale ?? config.service.defaultRenderScale;
-    const returnMode = resolveReturnMode(request.returnMode);
-    if (request.operation === "extract_pages") {
-        const images = [];
-        for (const page of pages) {
-            traceStep(opts, "start", "render.page", { page });
-            const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
-            if (returnMode === "file_id") {
-                const stored = await opts.fileStore.put({
-                    filename: `${file.filename}-p${page}.png`,
-                    mimeType: "image/png",
-                    bytes: rendered.png,
-                });
-                images.push({ page, mimeType: "image/png", fileId: stored.id });
-            }
-            else if (returnMode === "url") {
-                const stored = await opts.fileStore.put({
-                    filename: `${file.filename}-p${page}.png`,
-                    mimeType: "image/png",
-                    bytes: rendered.png,
-                });
-                images.push({
-                    page,
-                    mimeType: "image/png",
-                    fileId: stored.id,
-                    url: `/api/files/get?fileId=${encodeURIComponent(stored.id)}`,
-                });
-            }
-            else {
-                images.push({
-                    page,
-                    mimeType: "image/png",
-                    data: toDataUrl(rendered.png, "image/png"),
-                });
-            }
-            traceStep(opts, "end", "render.page", { page, width: rendered.width, height: rendered.height });
-        }
-        const result = { fileId: file.id, pageCount, returnMode, images };
-        traceStep(opts, "end", "pdf.operation", { operation: request.operation });
-        return result;
-    }
-    const providerAlias = resolveProviderAlias(config, request.provider);
-    const model = resolveModelForProvider(config, providerAlias, request.model);
-    if (!model) {
-        throw badRequest("MODEL_REQUIRED", "model is required for OCR or table extraction; set agent.defaultModel");
-    }
-    if (request.operation === "ocr_pages") {
-        const results = [];
-        for (const page of pages) {
-            traceStep(opts, "start", "ocr.page", { page });
-            const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
-            const imageDataUrl = toDataUrl(rendered.png, "image/png");
-            const fallbackText = await extractPdfPageText(config, file.bytes, page - 1);
-            const prompt = request.prompt?.trim() || config.agent.ocrPrompt;
-            const llmText = await visionRecognize({
-                config,
-                env,
-                providerAlias,
-                model,
-                prompt,
-                imageDataUrl,
-                runtimeApiKeys: request.providerApiKeys,
-            });
-            const text = stripCodeFences(llmText || fallbackText || "");
-            results.push({ page, text });
-            traceStep(opts, "end", "ocr.page", { page, chars: text.length });
-        }
-        const result = {
-            fileId: file.id,
-            pageCount,
-            provider: providerAlias,
-            model,
-            pages: results,
-        };
-        traceStep(opts, "end", "pdf.operation", { operation: request.operation });
-        return result;
-    }
-    const tables = [];
-    for (const page of pages) {
-        traceStep(opts, "start", "table.page", { page });
-        const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
-        const imageDataUrl = toDataUrl(rendered.png, "image/png");
-        const prompt = request.prompt?.trim() || config.agent.tablePrompt;
-        const rawLatex = await visionRecognize({
-            config,
-            env,
-            providerAlias,
-            model,
-            prompt,
-            imageDataUrl,
-            runtimeApiKeys: request.providerApiKeys,
-        });
-        const latex = extractTabularLatex(rawLatex);
-        if (!latex) {
-            throw unprocessable("TABLE_LATEX_MISSING", `table extraction did not return valid LaTeX tabular for page ${page}`, {
-                page,
-            });
-        }
-        tables.push({ page, latex });
-        traceStep(opts, "end", "table.page", { page, chars: latex.length });
-    }
-    const result = {
-        fileId: file.id,
-        pageCount,
-        provider: providerAlias,
-        model,
-        pages: tables,
-    };
-    traceStep(opts, "end", "pdf.operation", { operation: request.operation });
-    return result;
-};

package/dist/pdf-storage.d.ts

@@ -1,8 +0,0 @@
-import type { EchoPdfConfig } from "./pdf-types.js";
-import type { Env, FileStore } from "./types.js";
-export interface RuntimeFileStoreBundle {
-    readonly store: FileStore;
-    stats: () => Promise<unknown>;
-    cleanup: () => Promise<unknown>;
-}
-export declare const getRuntimeFileStore: (env: Env, config: EchoPdfConfig) => RuntimeFileStoreBundle;

package/dist/pdf-storage.js

@@ -1,86 +0,0 @@
-import { DurableObjectFileStore } from "./file-store-do.js";
-import { R2FileStore } from "./r2-file-store.js";
-class InMemoryFileStore {
-    store = new Map();
-    async put(input) {
-        const id = crypto.randomUUID();
-        const record = {
-            id,
-            filename: input.filename,
-            mimeType: input.mimeType,
-            sizeBytes: input.bytes.byteLength,
-            createdAt: new Date().toISOString(),
-            bytes: input.bytes,
-        };
-        this.store.set(id, record);
-        return this.toMeta(record);
-    }
-    async get(fileId) {
-        return this.store.get(fileId) ?? null;
-    }
-    async list() {
-        return [...this.store.values()].map((record) => this.toMeta(record));
-    }
-    async delete(fileId) {
-        return this.store.delete(fileId);
-    }
-    toMeta(record) {
-        return {
-            id: record.id,
-            filename: record.filename,
-            mimeType: record.mimeType,
-            sizeBytes: record.sizeBytes,
-            createdAt: record.createdAt,
-        };
-    }
-}
-const fallbackStore = new InMemoryFileStore();
-const DO_SAFE_MAX_FILE_BYTES = 1_200_000;
-export const getRuntimeFileStore = (env, config) => {
-    if (env.FILE_STORE_BUCKET) {
-        const store = new R2FileStore(env.FILE_STORE_BUCKET, config.service.storage);
-        return {
-            store,
-            stats: async () => store.stats(),
-            cleanup: async () => store.cleanup(),
-        };
-    }
-    if (env.FILE_STORE_DO) {
-        if (config.service.storage.maxFileBytes > DO_SAFE_MAX_FILE_BYTES) {
-            throw new Error(`service.storage.maxFileBytes=${config.service.storage.maxFileBytes} exceeds DO backend limit ${DO_SAFE_MAX_FILE_BYTES}; bind FILE_STORE_BUCKET (R2) or reduce maxFileBytes`);
-        }
-        const store = new DurableObjectFileStore(env.FILE_STORE_DO, config.service.storage);
-        return {
-            store,
-            stats: async () => store.stats(),
-            cleanup: async () => store.cleanup(),
-        };
-    }
-    return {
-        store: fallbackStore,
-        stats: async () => {
-            const files = await fallbackStore.list();
-            const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
-            return {
-                backend: "memory",
-                policy: config.service.storage,
-                stats: {
-                    fileCount: files.length,
-                    totalBytes,
-                },
-            };
-        },
-        cleanup: async () => ({
-            backend: "memory",
-            deletedExpired: 0,
-            deletedEvicted: 0,
-            stats: await (async () => {
-                const files = await fallbackStore.list();
-                return {
-                    fileCount: files.length,
-                    totalBytes: files.reduce((sum, file) => sum + file.sizeBytes, 0),
-                };
-            })(),
-        }),
-    };
-};

package/dist/pdfium-engine.d.ts

@@ -1,9 +0,0 @@
-import type { EchoPdfConfig } from "./pdf-types.js";
-export declare const getPdfPageCount: (config: EchoPdfConfig, bytes: Uint8Array) => Promise<number>;
-export declare const renderPdfPageToPng: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number, scale?: number) => Promise<{
-    width: number;
-    height: number;
-    png: Uint8Array;
-}>;
-export declare const extractPdfPageText: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number) => Promise<string>;
-export declare const toBytes: (value: string) => Promise<Uint8Array>;

package/dist/pdfium-engine.js

@@ -1,180 +0,0 @@
-import { init } from "@embedpdf/pdfium";
-import { encode as encodePng } from "@cf-wasm/png";
-let moduleInstance = null;
-let libraryInitialized = false;
-const toUint8 = (value) => new Uint8Array(value);
-const textDecoder = new TextDecoder();
-const isWorkerdRuntime = () => typeof globalThis.WebSocketPair === "function";
-const ensureWasmFunctionShim = () => {
-    const wasmApi = WebAssembly;
-    if (typeof wasmApi.Function === "function")
-        return;
-    wasmApi.Function = (_sig, fn) => fn;
-};
-const ensurePdfium = async (config) => {
-    ensureWasmFunctionShim();
-    if (!moduleInstance) {
-        if (isWorkerdRuntime()) {
-            const wasmModuleImport = await import("@embedpdf/pdfium/pdfium.wasm");
-            const maybeModule = wasmModuleImport.default ?? wasmModuleImport;
-            if (maybeModule instanceof WebAssembly.Module) {
-                moduleInstance = await init({
-                    instantiateWasm: (imports, successCallback) => {
-                        const instance = new WebAssembly.Instance(maybeModule, imports);
-                        successCallback(instance, maybeModule);
-                        return instance.exports;
-                    },
-                });
-            }
-        }
-        if (!moduleInstance) {
-            const wasmBinary = await fetch(config.pdfium.wasmUrl).then((res) => res.arrayBuffer());
-            moduleInstance = await init({ wasmBinary });
-        }
-    }
-    if (!libraryInitialized) {
-        moduleInstance.FPDF_InitLibrary();
-        libraryInitialized = true;
-    }
-    return moduleInstance;
-};
-const makeDoc = (pdfium, bytes) => {
-    const memPtr = pdfium.pdfium.wasmExports.malloc(bytes.length);
-    pdfium.pdfium.HEAPU8.set(bytes, memPtr);
-    const doc = pdfium.FPDF_LoadMemDocument(memPtr, bytes.length, "");
-    if (!doc) {
-        pdfium.pdfium.wasmExports.free(memPtr);
-        throw new Error("Failed to load PDF document");
-    }
-    return { doc, memPtr };
-};
-const closeDoc = (pdfium, doc, memPtr) => {
-    pdfium.FPDF_CloseDocument(doc);
-    pdfium.pdfium.wasmExports.free(memPtr);
-};
-const bgraToRgba = (bgra) => {
-    const rgba = new Uint8Array(bgra.length);
-    for (let i = 0; i < bgra.length; i += 4) {
-        rgba[i] = bgra[i + 2] ?? 0;
-        rgba[i + 1] = bgra[i + 1] ?? 0;
-        rgba[i + 2] = bgra[i] ?? 0;
-        rgba[i + 3] = bgra[i + 3] ?? 255;
-    }
-    return rgba;
-};
-const decodeUtf16Le = (buf) => {
-    const view = new Uint16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2));
-    const chars = [];
-    for (const code of view) {
-        if (code === 0)
-            break;
-        chars.push(code);
-    }
-    return String.fromCharCode(...chars);
-};
-export const getPdfPageCount = async (config, bytes) => {
-    const pdfium = await ensurePdfium(config);
-    const { doc, memPtr } = makeDoc(pdfium, bytes);
-    try {
-        return pdfium.FPDF_GetPageCount(doc);
-    }
-    finally {
-        closeDoc(pdfium, doc, memPtr);
-    }
-};
-export const renderPdfPageToPng = async (config, bytes, pageIndex, scale = config.service.defaultRenderScale) => {
-    const pdfium = await ensurePdfium(config);
-    const { doc, memPtr } = makeDoc(pdfium, bytes);
-    let page = 0;
-    let bitmap = 0;
-    try {
-        page = pdfium.FPDF_LoadPage(doc, pageIndex);
-        if (!page) {
-            throw new Error(`Failed to load page ${pageIndex}`);
-        }
-        const width = Math.max(1, Math.round(pdfium.FPDF_GetPageWidthF(page) * scale));
-        const height = Math.max(1, Math.round(pdfium.FPDF_GetPageHeightF(page) * scale));
-        bitmap = pdfium.FPDFBitmap_Create(width, height, 1);
-        if (!bitmap) {
-            throw new Error("Failed to create bitmap");
-        }
-        pdfium.FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xffffffff);
-        pdfium.FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
-        const stride = pdfium.FPDFBitmap_GetStride(bitmap);
-        const bufferPtr = pdfium.FPDFBitmap_GetBuffer(bitmap);
-        const heap = pdfium.pdfium.HEAPU8;
-        const bgra = heap.slice(bufferPtr, bufferPtr + stride * height);
-        const rgba = bgraToRgba(bgra);
-        const png = encodePng(rgba, width, height);
-        return { width, height, png };
-    }
-    finally {
-        if (bitmap)
-            pdfium.FPDFBitmap_Destroy(bitmap);
-        if (page)
-            pdfium.FPDF_ClosePage(page);
-        closeDoc(pdfium, doc, memPtr);
-    }
-};
-export const extractPdfPageText = async (config, bytes, pageIndex) => {
-    const pdfium = await ensurePdfium(config);
-    const { doc, memPtr } = makeDoc(pdfium, bytes);
-    let page = 0;
-    let textPage = 0;
-    let outPtr = 0;
-    try {
-        page = pdfium.FPDF_LoadPage(doc, pageIndex);
-        if (!page) {
-            throw new Error(`Failed to load page ${pageIndex}`);
-        }
-        textPage = pdfium.FPDFText_LoadPage(page);
-        if (!textPage)
-            return "";
-        const chars = pdfium.FPDFText_CountChars(textPage);
-        if (chars <= 0)
-            return "";
-        const bytesLen = (chars + 1) * 2;
-        outPtr = pdfium.pdfium.wasmExports.malloc(bytesLen);
-        pdfium.FPDFText_GetText(textPage, 0, chars, outPtr);
-        const heap = pdfium.pdfium.HEAPU8;
-        const raw = heap.slice(outPtr, outPtr + bytesLen);
-        return decodeUtf16Le(raw).trim();
-    }
-    finally {
-        if (outPtr)
-            pdfium.pdfium.wasmExports.free(outPtr);
-        if (textPage)
-            pdfium.FPDFText_ClosePage(textPage);
-        if (page)
-            pdfium.FPDF_ClosePage(page);
-        closeDoc(pdfium, doc, memPtr);
-    }
-};
-export const toBytes = async (value) => {
-    const response = await fetch(value);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch source: HTTP ${response.status}`);
-    }
-    const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
-    const bytes = toUint8(await response.arrayBuffer());
-    const signature = textDecoder.decode(bytes.subarray(0, Math.min(8, bytes.length)));
-    if (contentType.includes("application/pdf") || signature.startsWith("%PDF-")) {
-        return bytes;
-    }
-    const html = textDecoder.decode(bytes);
-    const pdfMatch = html.match(/https?:\/\/[^"' )]+\.pdf[^"' )]*/i);
-    if (!pdfMatch || pdfMatch.length === 0) {
-        throw new Error("URL does not point to a PDF and no PDF link was found in the page");
-    }
-    const resolvedUrl = pdfMatch[0].replace(/&amp;/g, "&");
-    const pdfResponse = await fetch(resolvedUrl);
-    if (!pdfResponse.ok) {
-        throw new Error(`Failed to fetch resolved PDF url: HTTP ${pdfResponse.status}`);
-    }
-    const pdfBytes = toUint8(await pdfResponse.arrayBuffer());
-    const pdfSignature = textDecoder.decode(pdfBytes.subarray(0, Math.min(8, pdfBytes.length)));
-    if (!pdfSignature.startsWith("%PDF-")) {
-        throw new Error("Resolved file is not a valid PDF");
-    }
-    return pdfBytes;
-};

package/dist/r2-file-store.d.ts

@@ -1,20 +0,0 @@
-import type { StoragePolicy } from "./pdf-types.js";
-import type { FileStore, R2Bucket, StoredFileMeta, StoredFileRecord } from "./types.js";
-export declare class R2FileStore implements FileStore {
-    private readonly bucket;
-    private readonly policy;
-    constructor(bucket: R2Bucket, policy: StoragePolicy);
-    put(input: {
-        readonly filename: string;
-        readonly mimeType: string;
-        readonly bytes: Uint8Array;
-    }): Promise<StoredFileMeta>;
-    get(fileId: string): Promise<StoredFileRecord | null>;
-    list(): Promise<ReadonlyArray<StoredFileMeta>>;
-    delete(fileId: string): Promise<boolean>;
-    stats(): Promise<unknown>;
-    cleanup(): Promise<unknown>;
-    private cleanupInternal;
-    private pickEvictions;
-    private listAllFiles;
-}