The VeriWorkly ATS Engine throws typed errors you can catch with instanceof, and applies fixed limits so a hostile or oversized input costs a bounded amount of work. Most limits cut the input and carry on. A few refuse it.

Error classes

All extend Error. Plain text of any length never throws AtsInputError: text is cut at the limit.

AtsInputError

Fields: issues, an array of { path, message }. At most 20 issues are listed. path is dotted, such as basics.name; it is empty for a whole-document problem such as size. Thrown by prepareResume, and so by check and AtsScoringService.check.

AtsPolicyError

Fields: issues, an array of { path, message } (AtsPolicyIssue), where path is the dotted path of the offending field, such as rules.3.weight. Thrown by parseAtsPolicy and withLocales for an invalid policy or pack. Also thrown by a check that names a region or targetAts the policy does not have. The package does not decide what that means for a server; map it to the response you want.

AtsFileError

No extra fields. Thrown by readResumeFile and readJobFile for a missing file, a folder, a pipe or device, a network share (\\host\share), a file over 20 MB, an unsupported extension, a file that is not a regular file, invalid JSON, a .json that is neither a JSON Resume nor an ats-resume document, and a file with too little text to read (for a PDF, a scan or flattened image; for other formats, fewer than 50 characters). The command line and the MCP server print its message as is.

AtsAiError

Fields: code, status (the provider's HTTP status, when there was one), usage, attempts (what was spent before it failed), and cause.

LlmProviderError

Fields: status (HTTP status, when there was one) and retryable, the adapter's verdict. Thrown by openAiCompatible and anthropic without an API key, and for a network error, a timeout, a non-2xx answer, or a body that is not JSON. Inside a task, it is wrapped as an AtsAiError with code provider. The adapter's own timeoutMs ends a slow call this way, as a retryable LlmProviderError, not as aborted. Rate limits (429), server faults, timeouts and unreadable bodies are retryable; a rejection of the request itself (another 4xx) is not.

Catching them

import { AtsInputError, AtsPolicyError, check } from "@veriworkly/ats-engine";
import { AtsAiError, LlmProviderError } from "@veriworkly/ats-engine/ai";
import { AtsFileError, readResumeFile } from "@veriworkly/ats-engine/node";

try {
  const { input, layout, file } = await readResumeFile("resume.pdf");
  console.log(check(input, undefined, { layout, file }).readinessScore);
} catch (error) {
  if (error instanceof AtsFileError) console.error(error.message);
  else if (error instanceof AtsInputError) console.error(error.issues);
  else if (error instanceof AtsPolicyError) console.error(error.issues);
  else throw error;
}

function describe(error: unknown): string {
  if (error instanceof AtsAiError) return `${error.code} after ${error.attempts} attempt(s)`;
  if (error instanceof LlmProviderError) return `provider: ${error.status ?? "no status"}`;
  return String(error);
}

Limits

Limits marked "cut" shorten the input and continue. Limits marked "refuse" stop with an error.

Text and postings

Files

Structured documents

DOCUMENT_LIMITS from @veriworkly/ats-engine/document holds the limits of an AtsResumeDocument. An array past its limit, or a document with too many nodes, throws AtsInputError. A string past its limit is cut, not refused. The values are set at or above what the VeriWorkly editor allows.

import { DOCUMENT_LIMITS } from "@veriworkly/ats-engine/document";

console.log(DOCUMENT_LIMITS);

A JSON Resume is cut to the same limits when it is converted instead of refused.

AI and tools

See Check options for the options that interact with these limits, and the MCP server for its refused paths.