VALIDATION_ERROR_TYPE_INFO

export const VALIDATION_ERROR_TYPE_INFO = {
    all_caps: { description: string },
    arabic_leak: { description: string },
    collapsed_speakers: { description: string },
    duplicate_id: { description: string },
    empty_parentheses: { description: string },
    invalid_marker_format: { description: string },
    invented_id: { description: string },
    length_mismatch: { description: string },
    missing_id_gap: { description: string },
    multiword_translit_without_gloss: { description: string },
    newline_after_id: { description: string },
    no_valid_markers: { description: string },
    truncated_segment: { description: string },
} as const satisfies Record<ValidationErrorType, { description: string }>

// Input: "P1 - THIS IS VERY VERY LOUD"
VALIDATION_ERROR_TYPE_INFO.all_caps.description
// "ALL CAPS \"shouting\" detected (run of N uppercase words)."

// Input: "P1 - He quoted «واللاتي تخافون نشوزهن»."
VALIDATION_ERROR_TYPE_INFO.arabic_leak.description
// "Arabic script was detected in output (except ﷺ)."

{
  type: 'arabic_leak',
  message: 'Arabic script detected: "واللاتي تخافون نشوزهن"',
  matchText: 'واللاتي تخافون نشوزهن',
  range: { start: 17, end: 41 },
  id: 'P1'
}

// Input: "P1 - Questioner: Yes.\nThe Shaykh: Yes. Questioner: Yes."
//                                                 ^^^ collapsed here
VALIDATION_ERROR_TYPE_INFO.collapsed_speakers.description
// "Speaker labels appear mid-line instead of starting on a new line."

{
  type: 'collapsed_speakers',
  message: 'Collapsed speaker label detected in "P1": "Questioner:" should start on a new line. Detected line-start labels: Questioner, The Shaykh',
  matchText: 'Questioner:',
  range: { start: 48, end: 59 },
  id: 'P1'
}

// Input: "P1 - First.\nP1 - Second."
VALIDATION_ERROR_TYPE_INFO.duplicate_id.description
// "The same segment ID appears more than once in the response."

{
  type: 'duplicate_id',
  message: 'Duplicate ID "P1" detected - each segment should appear only once',
  matchText: 'P1 - ',
  range: { start: 12, end: 17 },
  id: 'P1'
}

// Input: "P1 - One () two () three () four () five ()."
VALIDATION_ERROR_TYPE_INFO.empty_parentheses.description
// "Excessive \"()\" patterns detected, often indicating failed/empty term-pairs."

{
  type: 'empty_parentheses',
  message: 'Found 5 empty parentheses "()" - this usually indicates failed transliterations. Please check if the LLM omitted Arabic/transliterated terms.',
  matchText: '()',
  range: { start: 9, end: 11 },
}

// Input: "B12a34 - Invalid"
VALIDATION_ERROR_TYPE_INFO.invalid_marker_format.description
// "A segment marker line is malformed (e.g., wrong ID shape or missing content after the dash)."

// Wrong ID format
{
  type: 'invalid_marker_format',
  message: 'Invalid reference format "B12a34 -" - expected format is letter + numbers + optional suffix (a-j) + dash',
  matchText: 'B12a34 - ',
  range: { start: 0, end: 9 }
}

// Dollar sign
{
  type: 'invalid_marker_format',
  message: 'Invalid reference format "B1234$5" - contains $ character',
  matchText: 'B1234$5',
  range: { start: 0, end: 7 }
}

// Empty after dash
{
  type: 'invalid_marker_format',
  message: 'Reference "P1 -" has dash but no content after it',
  matchText: 'P1 -   ',
  range: { start: 0, end: 7 }
}

// Source: [{ id: 'P1', text: 'نص' }]
// Input: "P1 - Valid.\nP2 - Invented."
VALIDATION_ERROR_TYPE_INFO.invented_id.description
// "The response contains a segment ID that does not exist in the provided source corpus."

{
  type: 'invented_id',
  message: 'Invented ID detected: "P2" - this ID does not exist in the source',
  matchText: 'P2 - ',
  range: { start: 15, end: 20 },
  id: 'P2'
}

// Source: { id: 'P1', text: '(100+ chars of Arabic)' }
// Input: "P1 - Short."
VALIDATION_ERROR_TYPE_INFO.length_mismatch.description
// "Translation appears too short relative to Arabic source (heuristic truncation check)."

{
  type: 'length_mismatch',
  message: 'Translation for "P1" appears truncated: 6 chars for 115 char Arabic text (expected at least ~34 chars)',
  matchText: 'Short.',
  range: { start: 5, end: 11 },
  id: 'P1'
}

// Source: [P1, P2, P3]
// Input: "P1 - Text.\nP3 - Text."  // P2 is missing
VALIDATION_ERROR_TYPE_INFO.missing_id_gap.description
// "A gap was detected: the response includes two IDs whose corpus order implies one or more intermediate IDs are missing."

{
  type: 'missing_id_gap',
  message: 'Missing segment ID detected between translated IDs: "P2"',
  matchText: 'P3 - ',
  range: { start: 12, end: 17 },
  id: 'P2'
}

// Input: "P1 - He advised al-hajr fi al-madajīʿ."
VALIDATION_ERROR_TYPE_INFO.multiword_translit_without_gloss.description
// "A multi-word transliteration phrase was detected without an immediate parenthetical gloss."

{
  type: 'multiword_translit_without_gloss',
  message: 'Multi-word transliteration without immediate gloss in "P1": "al-hajr fi al-madajīʿ"',
  matchText: 'al-hajr fi al-madajīʿ',
  range: { start: 16, end: 37 },
  id: 'P1'
}

// With gloss (no error):
// "P1 - He advised al-hajr fi al-madajīʿ (marital bed abandonment)."

// Input: "P1 -\nText"
VALIDATION_ERROR_TYPE_INFO.newline_after_id.description
// "The response used \"ID -\\nText\" instead of \"ID - Text\" (newline immediately after the marker)."

{
  type: 'newline_after_id',
  message: 'Invalid format: newline after ID "P1 -" - use "ID - Text" format',
  matchText: 'P1 -\n',
  range: { start: 0, end: 5 }
}

// Input: "Just some text without markers"
VALIDATION_ERROR_TYPE_INFO.no_valid_markers.description
// "No valid \"ID - ...\" markers were found anywhere in the response."

{
  type: 'no_valid_markers',
  message: 'No valid translation markers found',
  matchText: 'Just some text without markers',
  range: { start: 0, end: 30 },
  ruleId: 'no_valid_markers'
}

// Input: "P1 - …\nP2 - ...\nP3 - [INCOMPLETE]"
VALIDATION_ERROR_TYPE_INFO.truncated_segment.description
// "A segment appears truncated (e.g., only \"…\", \"...\", or \"[INCOMPLETE]\")."

{
  type: 'truncated_segment',
  message: 'Truncated segment detected: "P1" - segments must be fully translated',
  matchText: '…',
  range: { start: 5, end: 6 },
  id: 'P1'
}

import { validateTranslationResponse, VALIDATION_ERROR_TYPE_INFO } from 'wobble-bibble';

const segments = [{ id: 'P1', text: 'نص عربي' }];
const response = 'P1 - He said الله.';

const result = validateTranslationResponse(segments, response);

for (const error of result.errors) {
  console.log(`Error: ${error.type}`);
  console.log(`Description: ${VALIDATION_ERROR_TYPE_INFO[error.type].description}`);
  console.log(`Message: ${error.message}`);
  console.log(`Match: "${error.matchText}"`);
  console.log(`Range: ${error.range.start}-${error.range.end}`);
}

// Output:
// Error: arabic_leak
// Description: Arabic script was detected in output (except ﷺ).
// Message: Arabic script detected: "الله"
// Match: "الله"
// Range: 13-17

type ValidationErrorType =
  | 'invalid_marker_format'
  | 'no_valid_markers'
  | 'newline_after_id'
  | 'duplicate_id'
  | 'invented_id'
  | 'missing_id_gap'
  | 'collapsed_speakers'
  | 'truncated_segment'
  | 'arabic_leak'
  | 'empty_parentheses'
  | 'length_mismatch'
  | 'all_caps'
  | 'multiword_translit_without_gloss'