Are There Limitations to the Number of Files That Can Be Converted in p2r3/convert?

The p2r3/convert repository does not impose a hard-coded limit on the number of files that can be processed in a single conversion request.

When working with the open-source p2r3/convert tool, understanding potential constraints on batch processing is crucial for planning large-scale conversion workflows. While many conversion utilities enforce artificial caps on file quantities, this repository takes a different approach. The architecture allows unlimited file processing in theory, though real-world limitations to the number of files that can be converted effectively depend entirely on your environment's resources.

Core Architecture: No Hard-Coded Restrictions

The conversion pipeline is designed around a generic handler interface that accepts an array of FileData objects without validating array length. In src/FormatHandler.ts, the doConvert method signature receives inputFiles as an array and iterates over every entry unconditionally.

Each concrete implementation in src/handlers/ follows this same contract. Whether processing PNG images, MP4 videos, or SVG graphics, no handler defines a MAX_FILES constant or implements guard clauses that reject large collections. The code simply processes what it receives.

Web UI Implementation

The browser interface uses standard HTML5 APIs that support unlimited multi-file selection. In index.html, the file input element includes the multiple attribute:

<input type="file" multiple>

The event wiring in src/main.ts converts the FileList to an array and passes it directly to the conversion engine:

const fileInput = document.getElementById('file-input') as HTMLInputElement;
fileInput.addEventListener('change', async () => {
  const files = Array.from(fileInput.files ?? []);
  await convertFiles(files);
});

Because the browser handles the file selection and the conversion engine accepts any array size, there is no artificial bottleneck in the UI layer.

Practical Limitations to Consider

While the codebase imposes no restrictions, several environmental factors create de facto limitations to the number of files that can be converted in practice:

• Browser Memory: Processing large numbers of high-resolution images, videos, or audio files can exhaust client-side RAM, causing the page to become unresponsive or crash.

• File Size Constraints: Individual handlers rely on browser APIs like FileReader, Blob, and WebAssembly modules. Extremely large individual files may hit browser-specific per-file size caps before quantity becomes an issue.

• Network and Server Resources: If the application is deployed with a backend server for processing, server-side upload limits, timeout configurations, and processing queues would impose constraints. However, the current pure-client implementation has no server-side restrictions.

Programmatic Batch Conversion Example

When using the library programmatically, you can process unlimited files by mapping them to the FileData interface:

import PNGHandler from './handlers/png.ts';
import { readFile } from './utils.ts';

async function batchConvert(fileList: File[]) {
  const handler = new PNGHandler();
  await handler.init();

  const inputFiles = await Promise.all(
    fileList.map(async f => ({
      name: f.name,
      buffer: await readFile(f),
      mime: f.type,
    }))
  );

  // No length validation occurs here
  const outputs = await handler.doConvert(
    inputFiles,
    handler.supportedFormats![0],
    handler.supportedFormats![0]
  );
  return outputs;
}

This pattern applies across all handlers in src/handlers/, from image converters to video processors.

Summary

• The p2r3/convert repository contains no hard-coded limits on file quantities in src/FormatHandler.ts or any concrete handler implementation.
• The web interface uses standard HTML5 multiple file selection without artificial caps.
• Practical limitations to the number of files that can be converted stem from browser memory, individual file sizes, and potential server-side constraints in deployed environments.
• The architecture supports unlimited batch processing as long as the host environment has sufficient resources.

Frequently Asked Questions

Is there a maximum file count I can select in the web interface?

No. The file input element in index.html uses the standard multiple attribute without a max property, and src/main.ts processes all selected files regardless of quantity. The only limits are your browser's memory and performance capabilities.

Will the conversion crash if I upload thousands of files at once?

Potentially. While the code in src/FormatHandler.ts will attempt to process every file in the inputFiles array, thousands of large media files can exhaust available RAM. The application does not implement queue-based processing or memory management guards to prevent browser crashes from excessive batch sizes.

Do individual handlers like the PNG or MP4 converters have different file limits?

No. All handlers in src/handlers/ inherit the same interface from src/FormatHandler.ts and accept the inputFiles array without length validation. Whether converting PNG images, MP4 videos, or SVG graphics, none define a MAX_FILES constant or implement quantity restrictions.

Can I implement my own file count limits when using the library programmatically?

Yes. Since the core library imposes no restrictions, you can add validation logic before calling handler.doConvert(). Simply check the length of your file array and implement pagination, queuing, or rejection logic based on your specific resource constraints or business requirements.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}