Executive Summary

In the realm of official record-keeping, legal proceedings, and archival management, the integrity and traceability of documents are paramount. When multiple multi-page PDF documents need to be consolidated for these critical purposes, the process of merging them presents a significant challenge, particularly concerning the preservation of Bates numbering or other sequential identifiers. Bates numbering, a system of sequentially numbering each page of a document or a collection of documents, is crucial for indexing, referencing, and ensuring that no pages are missing or altered. This guide provides an authoritative, in-depth analysis of how a robust PDF merging tool, specifically focusing on the capabilities and best practices of merge-pdf, can ensure the accurate sequencing and preservation of Bates numbering during the merging process. We will delve into the technical intricacies, explore practical scenarios, discuss industry standards, and offer a glimpse into future advancements, empowering professionals to maintain document integrity with confidence.

Deep Technical Analysis: Preserving Bates Numbering with merge-pdf

Understanding the Challenge

The core challenge in merging PDFs with existing Bates numbers lies in the fact that Bates numbering is often applied as an overlay or annotation on each page. When PDFs are merged, the underlying structure and page order are altered. A naive merging process might simply concatenate the page data, leading to several critical issues:

• Sequencing Errors: Bates numbers from different source documents might not continue sequentially in the merged document. For example, if Document A ends with Bates number 000150 and Document B starts with 000001, a simple merge might result in a sequence like ..., 000150, 000001, 000002, ... instead of ..., 000150, 000151, 000152, ....
• Duplicate Numbers: If multiple source documents use the same starting Bates number, a simple merge could result in duplicate Bates numbers within the final document, rendering it unusable for legal or official purposes.
• Loss of Overlay Information: In some cases, the Bates number overlay might be treated as a separate layer. A poorly implemented merge could strip or corrupt this overlay information.
• Metadata Discrepancies: Bates numbering is often tied to metadata or indexing systems. Merging without considering this can break such links.

The Role of merge-pdf in Preserving Bates Numbering

A sophisticated merge-pdf tool, designed for professional use, must go beyond simple file concatenation. To effectively preserve Bates numbering, it needs to understand and manipulate the PDF structure at a deeper level. The key functionalities and considerations for merge-pdf are:

1. Intelligent Page Ordering and Sequencing

The tool must allow for explicit control over the order in which source PDFs are merged. Crucially, it needs to have the intelligence to:

• Read Bates Numbering Information: The tool should be able to detect and interpret existing Bates numbers on the pages of the input PDFs. This might involve parsing page content, looking for specific text patterns, or examining annotation layers.
• Determine the Correct Continuation Number: Before merging, the tool should identify the last Bates number in the preceding document (or the last number in the sequence if it's the first document being merged). It then needs to calculate the appropriate starting Bates number for the incoming document to ensure a continuous sequence.
• Re-numbering or Adjusting: If the source documents have overlapping or non-sequential Bates numbers, the tool should offer options to either re-number the pages entirely within the merged document based on the final sequence, or to intelligently adjust the existing Bates numbers to maintain the overall continuity. The latter is often preferred to preserve the original numbering scheme as much as possible.

2. Handling of Bates Numbering as an Overlay/Annotation

Bates numbering is typically applied as a watermark or an annotation on each page. A robust merge-pdf tool will treat these overlays with care:

• Layer Preservation: The tool should aim to preserve the layer on which the Bates number is applied, ensuring it remains visible and does not interfere with the underlying document content.
• Annotation Integrity: When merging, the tool should ensure that annotations, including Bates numbers, are correctly transferred and rendered in the final document. This might involve re-rendering them in the correct position relative to the new page layout if scaling or transformations occur.

3. Configuration and Customization

The flexibility of the merge-pdf tool is critical for handling diverse scenarios:

• Customizable Numbering Schemes: The tool should allow users to define custom prefixes, suffixes, padding (e.g., leading zeros), and the starting number for the Bates sequence. This is essential for adhering to specific organizational or legal requirements.
• Control over Merging Order: A user interface or API that allows for drag-and-drop reordering of input files or explicit specification of the merge sequence is vital.
• Option to Re-number vs. Adjust: The ability to choose between a complete re-numbering of all pages in the merged document or an intelligent adjustment of existing numbers is a key differentiator.
• Batch Processing Capabilities: For large volumes of documents, batch processing with pre-defined rules for Bates numbering is indispensable.

4. Underlying PDF Library Capabilities

The effectiveness of merge-pdf is intrinsically linked to the underlying PDF manipulation library it employs. Libraries like Apache PDFBox (Java), PyMuPDF (Python), or iText (Java/C#) provide the foundational APIs for:

• Page Extraction and Insertion: The ability to extract individual pages from source PDFs and insert them into a new document.
• Annotation Management: Reading, writing, and manipulating PDF annotations.
• Content Rendering: Re-rendering page content, including text and graphics, to ensure overlays are correctly positioned.
• Metadata Handling: Preserving or updating document metadata.

merge-pdf, when implemented with these libraries, can leverage their power to precisely control the merging process and the Bates numbering application.

Example of the Logic (Conceptual)

Let's consider a simplified conceptual flow for a merge-pdf tool aiming to preserve Bates numbering:

            function merge_pdfs_with_bates(source_pdfs, merge_order, bates_config) {
                let merged_document = initialize_new_pdf();
                let current_bates_number = bates_config.start_number;

                for (let i = 0; i < merge_order.length; i++) {
                    let pdf_path = merge_order[i];
                    let source_pdf = open_pdf(pdf_path);
                    let num_pages_in_source = source_pdf.get_page_count();

                    // Determine the last Bates number from the *previous* document merged
                    // This is a critical step: if it's the first document, use the configured start number.
                    // Otherwise, look at the last page of the *already merged* document.
                    let last_bates_in_merged = merged_document.get_last_page_bates_number(); // hypothetical method

                    if (i > 0 && last_bates_in_merged !== null) {
                        current_bates_number = last_bates_in_merged + 1;
                    } else if (i === 0) {
                        current_bates_number = bates_config.start_number;
                    } else {
                        // Handle cases where previous Bates number couldn't be determined
                        // Fallback to current_bates_number or throw error
                    }

                    for (let page_index = 0; page_index < num_pages_in_source; page_index++) {
                        let page = source_pdf.get_page(page_index);

                        // Check if the page already has a Bates number
                        let existing_bates = page.get_bates_number(); // hypothetical method

                        if (existing_bates !== null) {
                            // Option 1: Preserve existing Bates number if it fits the sequence
                            if (existing_bates === current_bates_number) {
                                // Good, continue
                            } else {
                                // Option 2: Adjust the existing Bates number to fit the sequence
                                // Or Option 3: Re-number this page entirely
                                let new_bates_string = format_bates_number(current_bates_number, bates_config);
                                page.apply_bates_overlay(new_bates_string, bates_config.position, bates_config.font);
                            }
                        } else {
                            // Apply a new Bates number if none exists
                            let new_bates_string = format_bates_number(current_bates_number, bates_config);
                            page.apply_bates_overlay(new_bates_string, bates_config.position, bates_config.font);
                        }

                        merged_document.add_page(page);
                        current_bates_number++;
                    }
                    close_pdf(source_pdf);
                }
                return merged_document;
            }

            function format_bates_number(number, config) {
                let padded_number = String(number).padStart(config.padding, '0');
                return `${config.prefix}${padded_number}${config.suffix}`;
            }
            

This conceptual example highlights the core logic: iterating through documents, determining the correct starting number for each, and then applying or adjusting Bates numbers page by page. The `merge-pdf` tool needs robust implementations of `get_page_count`, `get_page`, `apply_bates_overlay`, `get_last_page_bates_number`, and `add_page`.

Practical Scenarios & Implementation Strategies

The successful preservation of Bates numbering during PDF merging hinges on understanding and adapting to various real-world scenarios. A comprehensive merge-pdf tool must provide the flexibility to handle these situations gracefully.

Scenario 1: Simple Concatenation with Sequential Bates Numbers

Description: Two or more PDF documents, each with internally sequential Bates numbers, are to be merged in a specific order, and the Bates numbers should continue sequentially across the merged documents.

Example: Document A (pages 001-050), Document B (pages 051-100).

merge-pdf Strategy:

• The tool identifies the last Bates number of Document A (050).
• It uses this number to set the starting point for Document B, ensuring its pages are numbered 051, 052, and so on.
• The merging order is crucial and must be user-defined.

Configuration:

Scenario 2: Overlapping or Non-Sequential Bates Numbers in Source Documents

Description: Source documents have Bates numbers that overlap (e.g., both start from 000001) or are not in the expected sequence.

Example: Document A (pages 001-050), Document B (pages 001-075). The desired output should have a single, continuous sequence.

merge-pdf Strategy:

• The tool must be configured to **re-number** all pages of the second (and subsequent) documents to ensure a unique, sequential numbering scheme.
• The user must explicitly define the starting Bates number for the entire merged document.

Configuration:

In this case, Document B's pages would be re-numbered from 0001000001 onwards, effectively ignoring their original Bates numbers.

Scenario 3: Merging Documents with Different Bates Numbering Formats

Description: Input PDFs might have different prefixes, suffixes, or padding (e.g., "DOC-001", "FILE-00002"). The output requires a unified format.

Example: Document A ("DOC-001" to "DOC-050"), Document B ("FILE-001" to "FILE-075"). The output should be consistent, e.g., "LEGAL-000001" onwards.

merge-pdf Strategy:

• The tool will read existing Bates numbers but will apply the *new* unified format and sequence to all pages of the merged document.
• It's often best to treat this as a full re-numbering scenario, applying the desired output format to every page.

Configuration:

Scenario 4: Handling Documents with No Existing Bates Numbers

Description: Some source documents might not have any Bates numbering applied.

Example: Document A (pages 001-050, with Bates numbers), Document B (pages 001-075, no Bates numbers).

merge-pdf Strategy:

• The tool will identify Document A's last Bates number.
• It will then apply the sequential Bates numbers to Document B, starting from the next logical number.
• If the user specifies a global start number, it will be applied to the first document, and subsequent documents will continue from there.

Configuration:

Scenario 5: Complex Document Structures (Bookmarks, Layers)

Description: Source PDFs might have complex internal structures like bookmarks, layers, or interactive forms. The merging process needs to preserve these where possible and ensure Bates numbers do not interfere.

merge-pdf Strategy:

• A sophisticated tool will attempt to preserve document structure, including bookmarks, by re-parenting them within the merged document's hierarchy.
• Bates number overlays must be applied in a way that does not disrupt existing layers or interactive elements. This usually means applying them as a high-level annotation or watermark that sits above most content but below interactive forms.
• The tool should ideally provide options to control the stacking order of elements if conflicts arise.

Configuration:

Scenario 6: Merging with OCR'd Documents

Description: Some documents might be scanned images that have undergone Optical Character Recognition (OCR) to make their text searchable. Bates numbering must be applied accurately to these pages.

merge-pdf Strategy:

• The merge-pdf tool should be able to handle PDFs with embedded text layers (from OCR) as well as image-only PDFs.
• The Bates number overlay should be applied to the visual representation of the page, ensuring it appears correctly regardless of whether the underlying content is image or text.
• If the OCR process itself applied a form of numbering or indexing, the tool's re-numbering strategy needs to be carefully considered.

Configuration:

Implementation Notes for merge-pdf Developers

• Robust Bates Detection: Implement pattern matching (regex) for common Bates number formats (e.g., `\d{6,}`, `[A-Z]{2,}-\d{4,}`).
• Annotation Parsing: Utilize PDF library APIs to iterate through page annotations and identify text annotations that are likely Bates numbers.
• Content Stream Analysis: For cases where Bates numbers are not annotations but part of the content stream, more advanced parsing might be needed.
• State Management: Maintain a clear state of the `current_bates_number` as pages are processed.
• Error Handling: Gracefully handle malformed PDFs, missing Bates numbers, or unexpected numbering sequences. Provide clear error messages to the user.
• User Feedback: Offer a preview or detailed logging of the Bates numbering process before the final merge.

Global Industry Standards and Best Practices

While there isn't a single universal "Bates Numbering Standard" enforced by law in every jurisdiction, several de facto standards and best practices have emerged, particularly within the legal and archival communities. A capable merge-pdf tool should align with these to ensure maximum compatibility and acceptance.

Key Characteristics of Proper Bates Numbering:

• Uniqueness: Each page within a given set of documents for a specific matter must have a unique Bates number.
• Sequencing: Numbers must be sequential and continuous within the context of the entire document set.
• Consistency: The format (prefix, suffix, padding, font) should be consistent across all numbered pages.
• Readability: Bates numbers must be clearly visible on each page without obscuring essential document content.
• Immutability: Once applied, Bates numbers should not be easily altered or removed without leaving a trace.
• Location: Typically placed at the bottom or top margin, often in the footer or header, to ensure consistent visibility.

Legal and Litigation Context:

In the United States, Bates numbering is a standard practice in litigation for managing discovery documents. Federal Rule of Civil Procedure 30(f)(1) (and similar state rules) often mandates that deposition transcripts be numbered. While not explicitly requiring Bates numbering, the practice has become essential for:

• Document Identification: Providing a single, unambiguous identifier for each page.
• Discovery Management: Facilitating the organization, retrieval, and production of large volumes of documents.
• Evidence Presentation: Ensuring that exhibits and testimony can be precisely referenced.
• Chain of Custody: Helping to maintain a clear record of document handling and integrity.

Law firms and legal departments often have internal standards or client-specific requirements for Bates numbering format.

Archival and Records Management Standards:

Organizations managing official records, whether governmental or private, often adhere to archival principles. These principles emphasize:

• Integrity: Ensuring documents are complete and unaltered.
• Authenticity: Verifying the origin and accuracy of records.
• Accessibility: Making records retrievable for future use.

Bates numbering contributes to these by providing a consistent indexing mechanism that supports long-term preservation and access. Standards from organizations like the International Council on Archives (ICA) or national archives (e.g., NARA in the US) guide the management of digital records, where consistent identification is key.

ISO Standards:

While no ISO standard directly mandates Bates numbering, several ISO standards related to document management and PDF itself are relevant:

• ISO 32000 (PDF Specification): This standard defines the PDF file format. A robust merge-pdf tool will adhere to ISO 32000 to ensure compatibility. The ability to manage annotations and content streams is crucial, as described in this standard.
• ISO 15489 (Records Management): This standard provides guidelines for managing records. While it doesn't specify Bates numbering, it emphasizes the need for unique identifiers and controlled processes for managing records, which Bates numbering supports.

Best Practices for Using merge-pdf with Bates Numbers:

• Define Your Scheme Early: Before merging, clearly define the required Bates numbering format (prefix, suffix, padding, starting number) based on project or organizational requirements.
• Maintain a Single Source of Truth: If possible, apply Bates numbering to source documents *before* merging, or ensure your merge tool can handle it consistently.
• Test Thoroughly: Always perform a test merge with a small subset of documents to verify the Bates numbering sequence and format before processing large batches.
• Document Your Process: Keep detailed records of the merging process, including the input files, the order of merging, and the Bates numbering configuration used.
• Consider Audit Trails: For highly sensitive records, ensure your merge-pdf tool or surrounding workflow provides an audit trail of when and how documents were merged and numbered.
• Backup Original Documents: Always maintain backups of the original, unmerged documents.

Multi-language Code Vault

To illustrate the implementation of Bates numbering logic within a PDF merging context, we provide code snippets in popular programming languages. These examples focus on the core logic of calculating and applying sequential numbers, assuming the existence of a PDF manipulation library.

Python (using PyMuPDF)

PyMuPDF is a powerful Python binding for MuPDF, excellent for PDF manipulation.

            import fitz  # PyMuPDF
            import os

            def apply_bates_number_to_page(page, bates_number, config):
                """Applies a Bates number overlay to a PDF page."""
                text = f"{config['prefix']}{bates_number:0{config['padding']}}{config['suffix']}"
                rect = page.rect  # Get page dimensions

                # Define position (e.g., bottom center)
                # This is a simplified example, real positioning needs careful calculation
                page_width = rect.width
                text_width = page.insert_text((0,0), text, fontsize=11)[2] # Get text width
                x = (page_width - text_width) / 2
                y = rect.height - 20 # 20 points from bottom

                page.insert_text((x, y), text, fontsize=11, color=(0, 0, 0), rotate=0)
                # For more advanced overlays (e.g., as annotations or watermarks),
                # you would use page.add_redact_annot or similar methods and then apply.
                # The insert_text is a direct text overlay for simplicity here.

            def merge_pdfs_with_bates_python(input_paths, output_path, config):
                """
                Merges PDF files and applies Bates numbering.
                Assumes input_paths are ordered correctly for merging.
                """
                doc_out = fitz.open()
                current_bates_num = config.get('start_number', 1)

                for path in input_paths:
                    if not os.path.exists(path):
                        print(f"Warning: File not found {path}, skipping.")
                        continue

                    doc_in = fitz.open(path)
                    for page_num in range(len(doc_in)):
                        page = doc_in.load_page(page_num)

                        # Check for existing Bates numbers (simplified: assumes specific format)
                        # A real implementation would need more robust detection.
                        # For this example, we'll always apply a new number based on sequence.
                        apply_bates_number_to_page(page, current_bates_num, config)

                        doc_out.insert_pdf(doc_in, from_page=page_num, to_page=page_num)
                        # Note: PyMuPDF's insert_pdf copies pages. We need to ensure the overlay is applied *before* copying
                        # or find a way to add a modified page.
                        # A more direct approach:
                        # new_page = doc_out.new_page(width=page.rect.width, height=page.rect.height)
                        # new_page.show_pdf_page(new_page.rect, doc_in, page_num) # Copy content
                        # apply_bates_number_to_page(new_page, current_bates_num, config)

                        current_bates_num += 1
                    doc_in.close()

                doc_out.save(output_path, garbage=4, deflate=True)
                doc_out.close()

            # --- Example Usage ---
            bates_config = {
                'prefix': 'CASE-',
                'suffix': '',
                'padding': 6,
                'start_number': 1000001
            }

            input_files = ['doc1.pdf', 'doc2.pdf', 'doc3.pdf'] # Ensure these files exist
            output_file = 'merged_with_bates.pdf'

            # Create dummy PDFs for testing if they don't exist
            for i, f in enumerate(input_files):
                if not os.path.exists(f):
                    doc = fitz.open()
                    page = doc.new_page()
                    page.insert_text((50, 100), f"This is page {i+1} of {f}")
                    doc.save(f)
                    doc.close()

            merge_pdfs_with_bates_python(input_files, output_file, bates_config)
            print(f"PDFs merged into {output_file} with Bates numbering.")
            

Java (using Apache PDFBox)

Apache PDFBox is a widely used Java library for PDF document manipulation.

            import org.apache.pdfbox.multipdf.PDFMergerUtility;
            import org.apache.pdfbox.pdmodel.PDDocument;
            import org.apache.pdfbox.pdmodel.PDPage;
            import org.apache.pdfbox.pdmodel.PDPageContentStream;
            import org.apache.pdfbox.pdmodel.font.PDType1Font;
            import org.apache.pdfbox.pdmodel.common.PDRectangle;

            import java.io.File;
            import java.io.IOException;
            import java.util.ArrayList;
            import java.util.List;
            import java.util.Locale;

            public class PdfMergerWithBates {

                public static void mergeAndNumber(List inputFiles, File outputFile, BatesConfig config) throws IOException {
                    PDFMergerUtility merger = new PDFMergerUtility();
                    merger.setDestinationFile(outputFile);

                    long currentBatesNumber = config.getStartNumber();
                    int fileIndex = 0;

                    for (File inputFile : inputFiles) {
                        if (!inputFile.exists()) {
                            System.err.println("Warning: File not found " + inputFile.getAbsolutePath() + ", skipping.");
                            continue;
                        }

                        try (PDDocument docIn = PDDocument.load(inputFile)) {
                            PDDocument tempDocForPageModification = new PDDocument(); // To hold modified pages

                            for (int pageNum = 0; pageNum < docIn.getNumberOfPages(); pageNum++) {
                                PDPage page = docIn.getPage(pageNum);
                                PDRectangle mediaBox = page.getMediaBox();
                                float pageWidth = mediaBox.getWidth();
                                float pageHeight = mediaBox.getHeight();

                                // Format Bates number
                                String batesText = String.format(Locale.US, "%s%0" + config.getPadding() + "d%s",
                                        config.getPrefix(), currentBatesNumber, config.getSuffix());

                                // Create a new page to add the Bates number, then copy content
                                PDPage modifiedPage = new PDPage(page.getMediaBox());
                                try (PDPageContentStream contentStream = new PDPageContentStream(modifiedPage, PDPageContentStream.AppendMode.APPEND, true, true)) {
                                    contentStream.setFont(PDType1Font.HELVETICA_BOLD, 12); // Example font and size

                                    // Calculate text position (e.g., bottom center)
                                    // This requires measuring text width, which PDFBox doesn't do directly easily here.
                                    // For simplicity, we'll place it at a fixed offset.
                                    float xPosition = pageWidth / 2 - 100; // Approximate centering
                                    float yPosition = 30; // 30 points from bottom

                                    contentStream.beginText();
                                    contentStream.newLineAtOffset(xPosition, yPosition);
                                    contentStream.showText(batesText);
                                    contentStream.endText();

                                    // Copy the original page content onto the modified page
                                    // This is a simplified approach. A more robust solution might involve PDFStreamEngine.
                                    // For a true overlay, you might need to get the original page's content stream
                                    // and append to it, or use an intermediate document.
                                    // A common approach is to draw the original page onto the new page.
                                    // This part is complex and often involves a PDFStreamEngine or similar.
                                    // For a basic overlay on a NEW page:
                                    PDPageContentStream originalPageCopier = new PDPageContentStream(modifiedPage, PDPageContentStream.AppendMode.APPEND, true, true);
                                    originalPageCopier.drawPage(page); // Draw original page content onto the new page
                                    originalPageCopier.close();

                                }
                                tempDocForPageModification.addPage(modifiedPage);
                                currentBatesNumber++;
                            }
                            // Now merge the pages from the temporary document
                            merger.appendRawPDFDocument(tempDocForPageModification, "dummy"); // This needs careful handling for appending pages
                            // A more direct approach for merging pages with modifications:
                            // Instead of `appendRawPDFDocument`, you'd typically iterate and add pages to the final output doc.
                            // Let's refine the merging logic for clarity with PDFBox:

                            // Corrected logic: Load input, modify pages, add to output doc
                            try (PDDocument finalOutputDoc = PDDocument.load(outputFile)) { // If outputFile already exists and we're appending
                                // If outputFile is new, load an empty doc
                                if (finalOutputDoc.getNumberOfPages() == 0 && !outputFile.exists()) {
                                    // Create a new document if it doesn't exist
                                    // This logic needs to be outside the loop for the first file
                                }
                                // This is getting complicated. The PDFMergerUtility is for merging whole files.
                                // For page-by-page modification and merging, it's often better to:
                                // 1. Create a new PDDocument for the output.
                                // 2. Iterate through input files and their pages.
                                // 3. Load each page, apply Bates number.
                                // 4. Add the modified page to the output document.

                            } // Close finalOutputDoc if it was loaded

                        } // Close docIn
                        fileIndex++;
                    }

                    // Re-implementing merge logic more accurately for page-by-page modification
                    try (PDDocument finalOutputDoc = new PDDocument()) { // Start with a fresh output document
                        long finalBatesNumber = config.getStartNumber();
                        for (File inputFile : inputFiles) {
                            if (!inputFile.exists()) continue;
                            try (PDDocument docIn = PDDocument.load(inputFile)) {
                                for (int pageNum = 0; pageNum < docIn.getNumberOfPages(); pageNum++) {
                                    PDPage originalPage = docIn.getPage(pageNum);
                                    PDPage newPage = new PDPage(originalPage.getMediaBox()); // Create a new page with same dimensions

                                    // Add original page content to the new page
                                    try (PDPageContentStream contentStream = new PDPageContentStream(newPage, PDPageContentStream.AppendMode.APPEND, true, true)) {
                                        contentStream.drawPage(originalPage); // Draw original content first
                                    }

                                    // Now add the Bates number overlay on top
                                    try (PDPageContentStream overlayStream = new PDPageContentStream(newPage, PDPageContentStream.AppendMode.APPEND, true, true)) {
                                        overlayStream.setFont(PDType1Font.HELVETICA_BOLD, 12);
                                        float pageWidth = newPage.getMediaBox().getWidth();
                                        float pageHeight = newPage.getMediaBox().getHeight();

                                        // Simple text measurement and positioning for Bates
                                        // This is a placeholder, real measurement is complex in PDFBox
                                        String batesText = String.format(Locale.US, "%s%0" + config.getPadding() + "d%s",
                                                config.getPrefix(), finalBatesNumber, config.getSuffix());

                                        // Estimate text width (crude) - PDFBox doesn't have a direct `getTextWidth` for PDType1Font easily
                                        // A more robust way would involve a FontMetrics object or rendering to measure.
                                        float textWidthEstimate = batesText.length() * 7; // Very rough estimate

                                        float xPosition = (pageWidth - textWidthEstimate) / 2;
                                        float yPosition = 30; // 30 points from bottom

                                        overlayStream.beginText();
                                        overlayStream.newLineAtOffset(xPosition, yPosition);
                                        overlayStream.showText(batesText);
                                        overlayStream.endText();
                                    }
                                    finalOutputDoc.addPage(newPage);
                                    finalBatesNumber++;
                                }
                            }
                        }
                        finalOutputDoc.save(outputFile);
                    }
                }


                // Helper class for configuration
                public static class BatesConfig {
                    private String prefix = "";
                    private String suffix = "";
                    private int padding = 6;
                    private long startNumber = 1;

                    public BatesConfig(String prefix, String suffix, int padding, long startNumber) {
                        this.prefix = prefix;
                        this.suffix = suffix;
                        this.padding = padding;
                        this.startNumber = startNumber;
                    }

                    public String getPrefix() { return prefix; }
                    public String getSuffix() { return suffix; }
                    public int getPadding() { return padding; }
                    public long getStartNumber() { return startNumber; }
                }

                public static void main(String[] args) {
                    // Example Usage
                    List inputFiles = new ArrayList<>();
                    inputFiles.add(new File("doc1.pdf"));
                    inputFiles.add(new File("doc2.pdf"));
                    inputFiles.add(new File("doc3.pdf"));

                    File outputFile = new File("merged_with_bates_java.pdf");

                    // Create dummy PDFs for testing if they don't exist
                    for (File file : inputFiles) {
                        if (!file.exists()) {
                            try (PDDocument doc = new PDDocument()) {
                                PDPage page = new PDPage(PDRectangle.A4);
                                try (PDPageContentStream contentStream = new PDPageContentStream(doc, page)) {
                                    contentStream.beginText();
                                    contentStream.setFont(PDType1Font.HELVETICA, 12);
                                    contentStream.newLineAtOffset(100, 700);
                                    contentStream.showText("This is a dummy page for " + file.getName());
                                    contentStream.endText();
                                }
                                doc.addPage(page);
                                doc.save(file);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                    BatesConfig config = new BatesConfig("LEGAL-", ".PDF", 7, 1000001);

                    try {
                        mergeAndNumber(inputFiles, outputFile, config);
                        System.out.println("PDFs merged into " + outputFile.getAbsolutePath() + " with Bates numbering.");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            

Note on Code Examples: The provided code snippets are illustrative. Real-world PDF manipulation, especially precise text positioning and handling of diverse PDF structures, can be significantly more complex and may require deeper integration with the underlying PDF library's advanced features (e.g., custom `PDFStreamEngine` in PDFBox, or annotation objects in PyMuPDF).

Future Outlook and Advancements

The field of PDF manipulation, while mature, continues to evolve. For merge-pdf tools focusing on critical applications like record-keeping and legal submissions, future advancements will likely center on enhanced intelligence, user experience, and robustness.

1. AI-Assisted Bates Numbering Detection and Validation

Advancement: Machine learning models could be trained to more accurately identify existing Bates numbers, even in non-standard formats or on complex page layouts. AI could also flag potential inconsistencies or errors in Bates numbering across large document sets.

Impact: Reduced manual effort in verifying numbering, increased accuracy, and faster processing of legacy or poorly formatted documents.

2. Blockchain Integration for Auditability

Advancement: Merged documents, along with their Bates numbering metadata and the merging process itself, could be recorded on a blockchain. This creates an immutable and verifiable audit trail.

Impact: Enhanced trust and integrity for legal submissions and critical records, providing indisputable proof of origin and manipulation history.

3. Intelligent Merging Based on Document Content

Advancement: Beyond user-defined order, a merge-pdf tool could analyze document content to suggest an optimal merging order for maintaining logical flow, especially when dealing with fragmented records.

Impact: Improved organization and understanding of merged document sets, particularly for historical or complex case files.

4. Enhanced Metadata Management

Advancement: Deeper integration with document management systems (DMS) and e-discovery platforms. Bates numbers could be automatically synchronized with metadata fields in these systems, enabling richer search and retrieval.

Impact: Streamlined workflows, better data governance, and more powerful search capabilities for large document repositories.

5. Cloud-Native and API-First Architectures

Advancement: merge-pdf functionalities becoming more accessible via robust APIs, allowing for seamless integration into cloud-based workflows, automated processes, and microservices architectures.

Impact: Greater flexibility, scalability, and ability to embed PDF merging capabilities into a wider range of applications and services.

6. Advanced Graphics and Annotation Handling

Advancement: Improved preservation and rendering of complex graphical elements, layers, and interactive annotations during the merge process. This is critical for ensuring that Bates numbers do not degrade the visual fidelity or functionality of the original documents.

Impact: Higher quality output documents that accurately reflect the original source material, crucial for legal admissibility and archival accuracy.

As the volume and complexity of digital information continue to grow, the demand for sophisticated and reliable PDF merging tools that can meticulously manage critical identifiers like Bates numbers will only increase. The evolution of merge-pdf will be driven by the need for greater automation, verifiable integrity, and seamless integration into modern digital workflows.