check-dfxp-compliance

name	check-dfxp-compliance
description	Generates EXHAUSTIVE DFXP/TTML compliance report checking all 115 rules individually + implementation quality gaps + styling/timing/element coverage with deep validation analysis to identify ALL issues in pycaption code.

check-dfxp-compliance

What this skill does

Exhaustive DFXP/TTML compliance checker - 6 phases:

1. Deep validation (critical rules with function-level detection vs validation) 1.5. Implementation quality gaps (things the code should do but doesn't, beyond regex existence)
2. Systematic checking (all 115 rules individually verified with per-rule patterns)
3. Styling attribute / timing format / content element / parameter coverage (read/write distinction)
4. Test coverage analysis
5. Report generation

Input: ai_artifacts/specs/dfxp/dfxp_specs_summary.md Output: ai_artifacts/compliance_checks/dfxp/compliance_report_{date}.md

Usage: /check-dfxp-compliance

---

Implementation

Run this Python script (context-optimized):

import os, re, glob
from datetime import datetime

print("DFXP/TTML Exhaustive Compliance Check\n" + "=" * 60)

# ===== INIT: Load spec and implementation =====
spec_files = glob.glob('ai_artifacts/specs/dfxp/dfxp_specs_summary*.md')
if not spec_files:
    print("ERROR: No dfxp_specs_summary.md found in ai_artifacts/specs/dfxp/")
    raise SystemExit(1)
latest_spec = max(spec_files, key=os.path.getmtime)
with open(latest_spec) as _f: spec = _f.read()

impl_files = [
    'pycaption/dfxp/reader.py',
    'pycaption/dfxp/writer.py',
    'pycaption/dfxp/constants.py',
    'pycaption/dfxp/extras.py',
    'pycaption/dfxp/__init__.py',
    'pycaption/geometry.py',
]
impl_content = {}
for f in impl_files:
    if os.path.exists(f):
        with open(f) as _fh: impl_content[f] = _fh.read()
impl = "\n".join(impl_content.values())

# Separate reader/writer for function-level checks
reader_content = impl_content.get('pycaption/dfxp/reader.py', '')
writer_content = impl_content.get('pycaption/dfxp/writer.py', '')
base_content = reader_content + "\n" + writer_content
extras_content = impl_content.get('pycaption/dfxp/extras.py', '')
geometry_content = impl_content.get('pycaption/geometry.py', '')

print(f"[INIT] Spec: {latest_spec} ({len(spec)} chars)")
print(f"[INIT] Implementation: {len(impl_content)} files ({len(impl)} chars)")

# Extract all rules from spec
all_rules = {}
for match in re.finditer(r'\*\*\[(RULE-[A-Z]+-\d{3}|IMPL-(?:[A-Z]+-)?\d{3})\]\*\*\s*(.+?)(?:\n|$)', spec):
    rule_id = match.group(1)
    rule_name = match.group(2).strip()
    rule_start = match.start()
    next_rule = re.search(r'\*\*\[(?:RULE-[A-Z]+-\d{3}|IMPL-(?:[A-Z]+-)?\d{3})\]\*\*', spec[rule_start + 1:])
    rule_block = spec[rule_start:rule_start + 1 + next_rule.start()] if next_rule else spec[rule_start:]
    level_match = re.search(r'\*\*Level:\*\*\s*(MUST NOT|MUST|SHOULD|MAY)', rule_block)
    level = level_match.group(1) if level_match else 'UNKNOWN'
    all_rules[rule_id] = {'name': rule_name, 'level': level}

print(f"[INIT] Extracted {len(all_rules)} rules from spec")

# ===== SANITY CHECK: Verify expected code landmarks exist =====
landmarks = {
    'class DFXPReader': ('pycaption/dfxp/reader.py', r'class\s+DFXPReader\b'),
    'class DFXPWriter': ('pycaption/dfxp/writer.py', r'class\s+DFXPWriter\b'),
    'def detect (DFXPReader)': ('pycaption/dfxp/reader.py', r'def\s+detect\b'),
    'def read (DFXPReader)': ('pycaption/dfxp/reader.py', r'def\s+read\b'),
    '_convert_style function': ('pycaption/dfxp/reader.py', r'def\s+_convert_style\b'),
    '_recreate_style function': ('pycaption/dfxp/writer.py', r'def\s+_recreate_style\b'),
    'class SinglePositioningDFXPWriter': ('pycaption/dfxp/extras.py', r'class\s+SinglePositioningDFXPWriter\b'),
    'class Layout': ('pycaption/geometry.py', r'class\s+Layout\b'),
}
stale_warnings = []
for name, (expected_file, pattern) in landmarks.items():
    try:
        with open(expected_file) as _fh:
            if not re.search(pattern, _fh.read()):
                stale_warnings.append(f"{name} not found in {expected_file}")
    except FileNotFoundError:
        stale_warnings.append(f"{expected_file} does not exist")

if stale_warnings:
    print(f"[SANITY] WARNING: {len(stale_warnings)} landmark(s) not found — patterns may be stale:")
    for w in stale_warnings:
        print(f"  - {w}")
else:
    print("[SANITY] All code landmarks found")

issues = {
    'validation_gaps': [],
    'partial_validation': [],
    'missing': [],
    'test_gaps': [],
}

# ===== PHASE 1: DEEP VALIDATION ANALYSIS =====
print("\n" + "=" * 60)
print("PHASE 1: DEEP VALIDATION ANALYSIS")
print("=" * 60)

deep_results = {}

# RULE-DOC-001: Root tt element detection
# OCTO-11531: detect() now uses regex requiring both <tt> and </tt> to eliminate false positives
has_detect = bool(re.search(r'def detect', base_content))
has_regex_detect = bool(re.search(r're\.search.*<tt|re\.compile.*<tt.*</tt>', base_content))
has_root_validate = bool(re.search(r'root.*tag.*!=.*tt|getroot.*!=.*tt|raise.*root.*element|<tt.*</tt>', base_content))
deep_results['RULE-DOC-001'] = {
    'name': 'Root tt element detection',
    'detected': has_detect,
    'validated': has_regex_detect or has_root_validate,
    'note': 'detect() uses regex requiring both <tt> and </tt> (OCTO-11531)' if has_regex_detect else 'detect() uses substring check',
}
if has_detect and not has_regex_detect and not has_root_validate:
    issues['partial_validation'].append({
        'rule_id': 'RULE-DOC-001', 'name': 'Root tt element detection',
        'status': 'DETECTED_NOT_VALIDATED', 'severity': 'SHOULD',
        'note': 'detect() uses simple substring check, not proper root element validation',
    })
print(f"  RULE-DOC-001: {'PASS (regex)' if has_regex_detect else 'PASS' if has_root_validate else 'DETECTION ONLY'}")

# RULE-DOC-003: xml:lang attribute
# Reads: dfxp_document.tt.attrs.get("xml:lang", DEFAULT_LANGUAGE_CODE)
# Silent fallback to "en", no validation of the value (e.g., BCP-47 check)
has_lang_read = bool(re.search(r'xml:lang.*DEFAULT_LANGUAGE_CODE|attrs\.get.*xml:lang', base_content))
has_lang_validate = bool(re.search(r'raise.*lang|warn.*lang|BCP.*47|valid.*lang', base_content, re.I))
deep_results['RULE-DOC-003'] = {
    'name': 'xml:lang attribute',
    'detected': has_lang_read,
    'validated': has_lang_validate,
    'note': 'Reads xml:lang with silent fallback to "en". No BCP-47 validation.',
}
if has_lang_read and not has_lang_validate:
    issues['partial_validation'].append({
        'rule_id': 'RULE-DOC-003', 'name': 'xml:lang attribute',
        'status': 'READ_NOT_VALIDATED', 'severity': 'SHOULD',
        'note': 'Reads with silent fallback to DEFAULT_LANGUAGE_CODE ("en"), no BCP-47 validation',
    })
print(f"  RULE-DOC-003: {'PASS' if has_lang_validate else 'READ ONLY (no validation)'}")

# RULE-TIME-001: Clock-time parsing
# CLOCK_TIME_PATTERN handles HH:MM:SS with optional .sub_frames or :frames
has_clock_pattern = bool(re.search(r'CLOCK_TIME_PATTERN', base_content))
has_clock_func = bool(re.search(r'def _convert_clock_time_to_microseconds', base_content))
has_clock_error = bool(re.search(r'CaptionReadTimingError.*Invalid timestamp', base_content))
deep_results['RULE-TIME-001'] = {
    'name': 'Clock-time parsing',
    'detected': has_clock_pattern and has_clock_func,
    'validated': has_clock_error,
    'note': 'Full parsing via CLOCK_TIME_PATTERN + _convert_clock_time_to_microseconds. Raises CaptionReadTimingError on invalid.',
}
print(f"  RULE-TIME-001: {'PASS' if has_clock_error else 'FAIL'}")

# RULE-TIME-002: Clock-time frames
# OCTO-11531: Now reads ttp:frameRate and ttp:frameRateMultiplier from <tt> element
has_frame_parse = bool(re.search(r'clock_time_match\.group.*"frames"', base_content))
has_frame_rate_param = bool(re.search(r'ttp:frameRate|frame_rate|_effective_frame_rate', base_content))
has_dynamic_framerate = bool(re.search(r'frameRateMultiplier|_effective_frame_rate|frame_rate\s*\*', base_content))
deep_results['RULE-TIME-002'] = {
    'name': 'Clock-time frames',
    'detected': has_frame_parse,
    'validated': has_frame_rate_param and has_dynamic_framerate,
    'note': 'Frames parsed using dynamic frame rate from ttp:frameRate * ttp:frameRateMultiplier.' if has_dynamic_framerate else 'Frames parsed but hardcoded /30.',
}
if has_frame_parse and not has_frame_rate_param:
    issues['validation_gaps'].append({
        'rule_id': 'RULE-TIME-002', 'name': 'Clock-time frames hardcoded to /30',
        'status': 'HARDCODED_FRAME_RATE', 'severity': 'MUST',
        'note': 'int(frames) / 30 * MICROSECONDS_PER_UNIT["seconds"] — ignores ttp:frameRate',
    })
print(f"  RULE-TIME-002: {'DYNAMIC FRAME RATE' if has_dynamic_framerate else 'HARDCODED /30'}")

# RULE-TIME-014: Frame timing requires ttp:frameRate
# OCTO-11531: Now reads ttp:frameRate and ttp:frameRateMultiplier from <tt> element
has_framerate_read = bool(re.search(r'ttp:frameRate|attrib.*frameRate|get.*frameRate|frame_rate', base_content))
has_multiplier_read = bool(re.search(r'frameRateMultiplier|frame_rate_multiplier', base_content))
deep_results['RULE-TIME-014'] = {
    'name': 'ttp:frameRate parameter',
    'detected': has_framerate_read,
    'validated': has_framerate_read and has_multiplier_read,
    'note': 'ttp:frameRate and ttp:frameRateMultiplier read from <tt> element, applied to frame-based timestamps.' if has_framerate_read else 'Not read.',
}
if not has_framerate_read:
    issues['validation_gaps'].append({
        'rule_id': 'RULE-TIME-014', 'name': 'ttp:frameRate not implemented',
        'status': 'NOT_IMPLEMENTED', 'severity': 'MUST',
        'note': 'Code never reads ttp:frameRate. Default 30fps used always.',
    })
print(f"  RULE-TIME-014: {'IMPLEMENTED' if has_framerate_read else 'NOT_IMPLEMENTED'}")

# RULE-TIME-009: Offset tick time
# OCTO-11531: Now implements tick metric with ttp:tickRate support
has_tick_impl = bool(re.search(r'metric.*==.*"t".*tick_rate|tick_rate.*microseconds|MICROSECONDS_PER_UNIT.*tick', base_content))
has_tick_error = bool(re.search(r'NotImplementedError.*tick', base_content))
has_tickrate_read = bool(re.search(r'ttp:tickRate|tickRate|tick_rate', base_content))
deep_results['RULE-TIME-009'] = {
    'name': 'Offset tick time',
    'detected': True,
    'validated': has_tick_impl or has_tickrate_read,
    'note': 'Tick metric implemented with ttp:tickRate support.' if (has_tick_impl or has_tickrate_read) else 'Raises NotImplementedError.',
}
if has_tick_error and not has_tick_impl and not has_tickrate_read:
    issues['validation_gaps'].append({
        'rule_id': 'RULE-TIME-009', 'name': 'Offset tick time raises NotImplementedError',
        'status': 'NOT_IMPLEMENTED', 'severity': 'SHOULD',
        'note': 'Code recognizes tick metric but raises NotImplementedError instead of computing',
    })
print(f"  RULE-TIME-009: {'IMPLEMENTED' if (has_tick_impl or has_tickrate_read) else 'NotImplementedError'}")

# IMPL-003: Style resolver cascade
# _get_style_reference_chain follows style references recursively
# _get_style_sources returns nested + referenced styles in order
has_chain = bool(re.search(r'def _get_style_reference_chain', base_content))
has_sources = bool(re.search(r'def _get_style_sources', base_content))
has_dup_error = bool(re.search(r'More than 1 style with.*xml:id', base_content))
deep_results['IMPL-003'] = {
    'name': 'Style resolver cascade',
    'detected': has_chain and has_sources,
    'validated': has_dup_error,
    'note': 'Follows style references via _get_style_reference_chain. Raises CaptionReadSyntaxError on duplicate xml:id.',
}
print(f"  IMPL-003: {'PASS' if has_chain else 'FAIL'}")

# IMPL-004: Region resolver
# _determine_region_id: element → ancestors → descendants
# RegionCreator: creates regions, assigns IDs, cleans up unused
has_region_determine = bool(re.search(r'def _determine_region_id', base_content))
has_region_creator = bool(re.search(r'class RegionCreator', base_content))
has_region_cleanup = bool(re.search(r'def cleanup_regions', base_content))
deep_results['IMPL-004'] = {
    'name': 'Region resolver',
    'detected': has_region_determine and has_region_creator,
    'validated': has_region_cleanup,
    'note': 'Full region resolution: element→ancestors→descendants. RegionCreator creates/assigns/cleans up regions.',
}
print(f"  IMPL-004: {'PASS' if has_region_determine else 'FAIL'}")

# IMPL-007: Color handling
# Reader: _convert_style reads tts:color as raw string (no parsing)
# Writer: _recreate_style writes color as raw string
# geometry.py: no color parsing
# Named colors only exist as defaults ("white" in DFXP_DEFAULT_STYLE)
has_color_read = bool(re.search(r'tts:color.*attrs\[.*color', base_content, re.DOTALL))
has_color_parse = bool(re.search(r'parse.*color|rgba?\s*\(|#[0-9a-fA-F]{6}|color.*convert', base_content + geometry_content, re.I))
deep_results['IMPL-007'] = {
    'name': 'Color handling',
    'detected': has_color_read,
    'validated': False,
    'note': 'Color read/written as raw string passthrough. No parsing of named colors, hex, or rgba() formats.',
}
if has_color_read and not has_color_parse:
    issues['partial_validation'].append({
        'rule_id': 'IMPL-007', 'name': 'Color handling',
        'status': 'PASSTHROUGH_ONLY', 'severity': 'SHOULD',
        'note': 'tts:color passed through as raw string. No validation of color format (hex, named, rgba).',
    })
print(f"  IMPL-007: {'PARSE' if has_color_parse else 'PASSTHROUGH ONLY'}")

# IMPL-008: XML escaping
# Writer uses xml.sax.saxutils.escape(s) via _encode method
has_escape_import = bool(re.search(r'from xml\.sax\.saxutils import escape', base_content))
has_encode_func = bool(re.search(r'def _encode.*\n.*return escape', base_content))
deep_results['IMPL-008'] = {
    'name': 'XML character escaping',
    'detected': has_escape_import,
    'validated': has_encode_func,
    'note': 'Writer uses xml.sax.saxutils.escape() via _encode method. Handles &, <, >.',
}
print(f"  IMPL-008: {'PASS' if has_encode_func else 'FAIL'}")

# RULE-STY-006: fontWeight/bold — read-only gap
# Reader: attrs["bold"] = True when tts:fontWeight == "bold" (line ~320)
# Writer: _recreate_style never outputs tts:fontWeight — bold silently dropped on write
has_bold_read = bool(re.search(r'tts:fontweight.*bold.*attrs\[.bold.\]|fontweight.*==.*bold', base_content, re.I))
recreate_style_section = re.search(r'def _recreate_style\(content.*?\n(?=\ndef |\nclass |\Z)', base_content, re.DOTALL)
recreate_style_code = recreate_style_section.group(0) if recreate_style_section else ''
has_bold_in_recreate = bool(re.search(r'fontWeight|bold', recreate_style_code))
deep_results['RULE-STY-006'] = {
    'name': 'fontWeight/bold read-only gap',
    'detected': has_bold_read,
    'validated': has_bold_in_recreate,
    'note': 'Reader parses tts:fontWeight→attrs["bold"], but _recreate_style never writes it back. Bold silently dropped on round-trip.' if has_bold_read and not has_bold_in_recreate else '',
}
if has_bold_read and not has_bold_in_recreate:
    issues['partial_validation'].append({
        'rule_id': 'RULE-STY-006', 'name': 'fontWeight/bold read-only',
        'status': 'READ_NOT_WRITTEN', 'severity': 'MUST',
        'note': 'Reader: attrs["bold"]=True from tts:fontWeight. Writer: _recreate_style omits tts:fontWeight. Bold lost on write.',
    })
print(f"  RULE-STY-006: {'PASS' if has_bold_in_recreate else 'READ-ONLY — bold dropped on write'}")

# RULE-STY-008: textDecoration/underline — read-only gap
# Reader: attrs["underline"] = True when tts:textDecoration contains "underline"
# Writer: _recreate_style never outputs tts:textDecoration — underline silently dropped
has_underline_read = bool(re.search(r'tts:textdecoration.*underline', base_content, re.I | re.DOTALL))
has_underline_in_recreate = bool(re.search(r'textDecoration|underline', recreate_style_code))
deep_results['RULE-STY-008'] = {
    'name': 'textDecoration/underline read-only gap',
    'detected': has_underline_read,
    'validated': has_underline_in_recreate,
    'note': 'Reader parses tts:textDecoration→attrs["underline"], but _recreate_style never writes it back. Underline silently dropped on round-trip.' if has_underline_read and not has_underline_in_recreate else '',
}
if has_underline_read and not has_underline_in_recreate:
    issues['partial_validation'].append({
        'rule_id': 'RULE-STY-008', 'name': 'textDecoration/underline read-only',
        'status': 'READ_NOT_WRITTEN', 'severity': 'MUST',
        'note': 'Reader: attrs["underline"]=True from tts:textDecoration. Writer: _recreate_style omits tts:textDecoration. Underline lost on write.',
    })
print(f"  RULE-STY-008: {'PASS' if has_underline_in_recreate else 'READ-ONLY — underline dropped on write'}")

# IMPL-004: Region resolver — LookupError silently drops region
# _determine_region_id catches LookupError from _get_region_from_descendants
# and returns None (bare `return`), silently dropping the region assignment
# when descendants have conflicting region IDs
has_region_lookup_catch = bool(re.search(r'except LookupError:\s*\n\s*return\b', base_content))
has_region_lookup_warn = bool(re.search(r'except LookupError:[^\n]*(?:warn|log|raise)|\nexcept LookupError:\s*\n\s+(?:warn|log|raise)', base_content))
if has_region_lookup_catch and not has_region_lookup_warn:
    deep_results['IMPL-004']['note'] = (
        deep_results['IMPL-004'].get('note', '') +
        ' WARNING: _determine_region_id catches LookupError and returns None — '
        'conflicting descendant regions silently dropped instead of warned/raised.'
    ).strip()
    deep_results['IMPL-004']['validated'] = False
    issues['partial_validation'].append({
        'rule_id': 'IMPL-004', 'name': 'Region resolver silently drops conflicting regions',
        'status': 'SILENT_ERROR_SUPPRESSION', 'severity': 'SHOULD',
        'note': 'except LookupError: return — conflicting descendant regions cause silent None region. No warning or error raised.',
    })
print(f"  IMPL-004 (LookupError): {'PASS' if not has_region_lookup_catch else 'SILENT DROP — conflicting regions suppressed'}")

print(f"\n  Read-only attribute summary:")
print(f"    fontWeight: read={'YES' if has_bold_read else 'NO'}, write={'YES' if has_bold_in_recreate else 'NO'}")
print(f"    textDecoration: read={'YES' if has_underline_read else 'NO'}, write={'YES' if has_underline_in_recreate else 'NO'}")

# Extract _convert_style section early (needed for subsequent deep checks)
convert_style_section = ''
m = re.search(r'def _convert_style\b.*?(?=\ndef |\nclass )', base_content, re.DOTALL)
if m:
    convert_style_section = m.group(0)

# RULE-STY-002: tts:backgroundColor
# OCTO-11514: Writer now emits tts:backgroundColor on spans/styles from WebVTT/SAMI sources
has_bg_read = bool(re.search(r'tts:backgroundColor|background.?[Cc]olor', convert_style_section if convert_style_section else base_content))
has_bg_write = bool(re.search(r'tts:backgroundColor|background.?[Cc]olor', recreate_style_code + "\n" + writer_content))
deep_results['RULE-STY-002'] = {
    'name': 'tts:backgroundColor',
    'detected': has_bg_read or has_bg_write,
    'validated': has_bg_write,
    'note': 'Writer emits tts:backgroundColor (OCTO-11514).' if has_bg_write else 'Not implemented.',
}
if not has_bg_read and not has_bg_write:
    issues['validation_gaps'].append({
        'rule_id': 'RULE-STY-002', 'name': 'tts:backgroundColor not implemented',
        'status': 'NOT_IMPLEMENTED', 'severity': 'SHOULD',
        'note': '_convert_style has no case for tts:backgroundColor. _recreate_style does not write it.',
    })
print(f"  RULE-STY-002: {'PASS' if has_bg_write else 'NOT IMPLEMENTED'}")

# IMPL-SPAN-001: Writer uses stack-based nesting for spans (not flat boolean)
has_span_stack = bool(re.search(r'_span_stack\s*=\s*\[\]', writer_content))
has_old_open_span = bool(re.search(r'self\.open_span\s*=\s*(True|False)', writer_content))
deep_results['IMPL-SPAN-001'] = {
    'name': 'Writer nested span support (stack-based)',
    'detected': has_span_stack or has_old_open_span,
    'validated': has_span_stack and not has_old_open_span,
    'note': 'Writer uses open_span boolean — nested spans collapse to flat.' if has_old_open_span and not has_span_stack else '',
}
if has_old_open_span and not has_span_stack:
    issues['partial_validation'].append({
        'rule_id': 'IMPL-SPAN-001', 'name': 'Nested spans not supported in writer',
        'status': 'FLAT_SPAN_ONLY', 'severity': 'SHOULD',
        'note': 'Writer uses self.open_span boolean: each new span closes the previous. Nested <b><i>text</i></b> collapses to single span.',
    })
print(f"  IMPL-SPAN-001: {'STACK-BASED (nested OK)' if has_span_stack and not has_old_open_span else 'FLAT BOOLEAN — nesting broken'}")

# RULE-STY-005: fontStyle only handles "italic", ignores "oblique"/"normal"
has_fontstyle_italic = bool(re.search(r'tts:fontstyle.*==.*italic|fontstyle.*italic', base_content, re.I))
has_fontstyle_oblique = bool(re.search(r'oblique', base_content))
deep_results['RULE-STY-005'] = {
    'name': 'fontStyle partial — only italic handled',
    'detected': has_fontstyle_italic,
    'validated': has_fontstyle_oblique,
    'note': '_convert_style only handles tts:fontStyle=="italic". Values "oblique" and "normal" are silently ignored.' if has_fontstyle_italic and not has_fontstyle_oblique else '',
}
if has_fontstyle_italic and not has_fontstyle_oblique:
    issues['partial_validation'].append({
        'rule_id': 'RULE-STY-005', 'name': 'fontStyle only handles italic',
        'status': 'PARTIAL_VALUES', 'severity': 'SHOULD',
        'note': 'Reader checks tts:fontStyle=="italic" only. "oblique" and "normal" values silently ignored.',
    })
print(f"  RULE-STY-005: {'PASS' if has_fontstyle_oblique else 'PARTIAL — only italic, oblique/normal ignored'}")

# IMPL-008 extra: &apos; workaround — silent XML entity rewrite before parsing
has_apos_workaround = bool(re.search(r'replace\(.*&apos;|replace\(.*apos', base_content))
if has_apos_workaround:
    issues['partial_validation'].append({
        'rule_id': 'IMPL-008', 'name': 'Silent &apos; workaround',
        'status': 'SILENT_WORKAROUND', 'severity': 'SHOULD',
        'note': 'markup.replace("&apos;", "\'") silently rewrites valid XML entity before parsing. Could mask malformed input.',
    })
print(f"  IMPL-008 (&apos;): {'SILENT WORKAROUND' if has_apos_workaround else 'CLEAN'}")

# LegacyDFXPWriter in extras.py — same bold/underline write gap
has_legacy_recreate = bool(re.search(r'def _recreate_style', extras_content))
has_legacy_bold_write = bool(re.search(r'fontWeight|bold', extras_content.split('def _recreate_style')[1] if 'def _recreate_style' in extras_content else ''))
if has_legacy_recreate and not has_legacy_bold_write:
    issues['partial_validation'].append({
        'rule_id': 'RULE-STY-006', 'name': 'LegacyDFXPWriter also drops bold',
        'status': 'READ_NOT_WRITTEN', 'severity': 'MUST',
        'note': 'extras.py LegacyDFXPWriter._recreate_style also omits tts:fontWeight. Same gap as base.py.',
    })
print(f"  extras.py bold: {'PASS' if has_legacy_bold_write else 'ALSO DROPS BOLD'}")

# ===== PHASE 1.5: IMPLEMENTATION QUALITY GAPS =====
# Beyond "does the code exist" — checks for things a reference TTML parser handles.
print("\n" + "=" * 60)
print("PHASE 1.5: IMPLEMENTATION QUALITY GAPS")
print("=" * 60)

quality_gaps = []

# Q1: No structured error diagnostics (only exceptions or silence)
has_structured_diag = bool(re.search(r'warnings\.warn|CaptionReadWarning', reader_content))
has_error_collection = bool(re.search(r'errors\s*=\s*\[\]|self\.errors|self\.warnings|diagnostic', reader_content, re.I))
if not has_structured_diag and not has_error_collection:
    quality_gaps.append({
        'id': 'QUAL-001', 'name': 'No structured error diagnostics',
        'severity': 'SHOULD',
        'note': 'Reader either raises an exception (halting) or silently accepts. '
                'No middle ground for collecting issues like a validator would. '
                'Reference TTML parsers collect all errors with line/element info.',
    })
    print("  QUAL-001: NO STRUCTURED DIAGNOSTICS")
else:
    print("  QUAL-001: PASS")

# Q2: timeContainer="seq" not implemented (silently treated as "par")
has_time_container = bool(re.search(r'timeContainer|time_container|sequential', reader_content, re.I))
if not has_time_container:
    quality_gaps.append({
        'id': 'QUAL-002', 'name': 'timeContainer="seq" not implemented',
        'severity': 'SHOULD',
        'note': 'TTML defines parallel (default) and sequential time containers. '
                'Sequential timing (children play one after another) is never checked. '
                'All timing is treated as parallel without warning.',
    })
    print("  QUAL-002: timeContainer=seq NOT IMPLEMENTED")
else:
    print("  QUAL-002: PASS")

# Q3: Time containment not enforced (children can exceed parent timing)
has_containment = bool(re.search(r'containment|constrain|clip.*time|child.*exceed|parent.*time', reader_content, re.I))
if not has_containment:
    quality_gaps.append({
        'id': 'QUAL-003', 'name': 'Time containment not enforced',
        'severity': 'MAY',
        'note': 'TTML specifies that children are constrained by parent begin/end. '
                'A <p> inside a <div begin="5s" end="10s"> with begin="0s" should be clipped. '
                'No containment logic exists — children use raw timestamps.',
    })
    print("  QUAL-003: NO TIME CONTAINMENT")
else:
    print("  QUAL-003: PASS")

# Q4: Unknown tts: attributes silently ignored
# _convert_style only handles 8 known attributes (fontStyle, fontWeight, textDecoration,
# textAlign, fontFamily, fontSize, color, backgroundColor). All others silently dropped.
has_unknown_attr_warn = bool(re.search(r'unknown.*attr|unrecognized.*tts|warn.*attribute', reader_content, re.I))
if not has_unknown_attr_warn:
    quality_gaps.append({
        'id': 'QUAL-004', 'name': 'Unknown tts: attributes silently ignored',
        'severity': 'MAY',
        'note': '_convert_style only handles 8 known tts: attributes. '
                'Any other tts: attribute (lineHeight, opacity, textOutline, etc.) '
                'is silently dropped. No warning for unrecognized styling.',
    })
    print("  QUAL-004: UNKNOWN TTS ATTRS SILENTLY DROPPED")
else:
    print("  QUAL-004: PASS")

# Q5: <set> animation element completely ignored
has_set_element = bool(re.search(r'set.*element|<set|name.*==.*"set"', reader_content, re.I))
if not has_set_element:
    quality_gaps.append({
        'id': 'QUAL-005', 'name': '<set> animation element completely ignored',
        'severity': 'MAY',
        'note': 'TTML defines <set> for style animation (e.g. visibility changes at time offsets). '
                'Reader does not handle <set> elements at all — they are silently skipped by '
                'the tag-to-node conversion which only handles span/br/text.',
    })
    print("  QUAL-005: <set> ELEMENT NOT HANDLED")
else:
    print("  QUAL-005: PASS")

# Q6: No xml:space whitespace normalization
has_xml_space = bool(re.search(r'xml:space|whitespace.*normal|preserve.*space', reader_content, re.I))
if not has_xml_space:
    quality_gaps.append({
        'id': 'QUAL-006', 'name': 'No xml:space whitespace normalization',
        'severity': 'SHOULD',
        'note': 'TTML inherits xml:space from XML spec. With xml:space="default", '
                'consecutive whitespace should be collapsed and leading/trailing stripped. '
                'With "preserve", all whitespace is kept. Reader does neither — '
                'whitespace handling depends on BeautifulSoup defaults.',
    })
    print("  QUAL-006: NO xml:space HANDLING")
else:
    print("  QUAL-006: PASS")

# Q7: No duplicate xml:id detection beyond <style> elements
# _get_style_reference_chain raises on duplicate style IDs, but region/div/p IDs unchecked
has_dup_style_check = bool(re.search(r'More than 1 style with.*xml:id', reader_content))
has_dup_region_check = bool(re.search(r'duplicate.*region.*id|More than 1 region', reader_content, re.I))
if has_dup_style_check and not has_dup_region_check:
    quality_gaps.append({
        'id': 'QUAL-007', 'name': 'Duplicate xml:id only checked for <style> elements',
        'severity': 'MAY',
        'note': '_get_style_reference_chain raises CaptionReadSyntaxError for duplicate style IDs. '
                'But duplicate region xml:ids, or duplicate IDs on div/p elements, go unchecked. '
                'XML spec requires all xml:id values be unique within a document.',
    })
    print("  QUAL-007: DUPLICATE IDs ONLY CHECKED FOR STYLES")
else:
    print("  QUAL-007: PASS")

# Q8: fontStyle only handles "italic", other values silently ignored
# (This is already caught in Phase 1 deep analysis as RULE-STY-005, but the quality
# gap framing is about _convert_style silently ignoring values rather than warning)
has_fontstyle_else = bool(re.search(r'fontstyle.*!=.*italic.*warn|fontstyle.*else|unknown.*fontstyle', reader_content, re.I))
if not has_fontstyle_else and has_fontstyle_italic:
    quality_gaps.append({
        'id': 'QUAL-008', 'name': 'Non-italic fontStyle values silently ignored',
        'severity': 'MAY',
        'note': '_convert_style checks tts:fontStyle=="italic" only. Values "oblique" and '
                '"normal" are silently skipped without warning. A document with '
                'tts:fontStyle="oblique" will render as normal text without any diagnostic.',
    })
    print("  QUAL-008: NON-ITALIC FONTSTYLE SILENTLY IGNORED")
else:
    print("  QUAL-008: PASS")

# Q9: No BCP-47 language tag validation
has_lang_validate = bool(re.search(r'BCP.*47|valid.*lang|language.*code.*check|validate.*lang', reader_content, re.I))
if not has_lang_validate:
    quality_gaps.append({
        'id': 'QUAL-009', 'name': 'No BCP-47 language tag validation',
        'severity': 'MAY',
        'note': 'xml:lang read with silent fallback to "en". No validation that the value '
                'is a valid BCP-47 language tag. Invalid values like "zz-INVALID" are '
                'accepted without warning.',
    })
    print("  QUAL-009: NO BCP-47 VALIDATION")
else:
    print("  QUAL-009: PASS")

# Q10: Writer drops style properties not in its known set
# _recreate_style only handles: class, text-align, italics, bold, underline,
# font-family, font-size, color, background-color, display-align (10 keys).
# Any other internal style key is silently dropped.
has_unknown_style_warn = bool(re.search(r'unknown.*style|unrecognized.*key|warn.*style.*key', writer_content, re.I))
if not has_unknown_style_warn:
    quality_gaps.append({
        'id': 'QUAL-010', 'name': 'Writer silently drops unknown style properties',
        'severity': 'MAY',
        'note': '_recreate_style only maps 10 known internal keys to tts: attributes. '
                'Any style property from other formats (e.g., lang, writing-mode passed as '
                'internal key) is silently lost on DFXP output without warning.',
    })
    print("  QUAL-010: WRITER DROPS UNKNOWN STYLE KEYS")
else:
    print("  QUAL-010: PASS")

print(f"  Quality gaps found: {len(quality_gaps)}")

# Add quality gaps to issues
for qg in quality_gaps:
    issues['partial_validation'].append({
        'rule_id': qg['id'], 'name': qg['name'],
        'status': 'QUALITY_GAP', 'severity': qg['severity'],
        'note': qg['note'],
    })

# ===== PHASE 2: SYSTEMATIC RULE CHECK =====
print("\n" + "=" * 60)
print("PHASE 2: ALL RULES CHECK ({} rules)".format(len(all_rules)))
print("=" * 60)

# Per-rule patterns matching ACTUAL code constructs, not keywords
specific_patterns = {
    # Document structure
    'RULE-DOC-001': [r'def detect|</tt>.*content|DFXP_BASE_MARKUP.*<tt'],
    'RULE-DOC-002': [r'http://www.w3.org/ns/ttml|xmlns.*ttml'],
    'RULE-DOC-003': [r'xml:lang.*DEFAULT_LANGUAGE_CODE|attrs\.get.*xml:lang'],
    'RULE-DOC-004': [r'<head|find.*head|findChild.*head'],
    'RULE-DOC-005': [r'find.*body|find_all.*body|<body'],
    'RULE-DOC-006': [r'application/ttml\+xml|content_type.*ttml|mime.*ttml'],
    'RULE-DOC-007': [r'xml.*declaration|encoding.*UTF-8|encoding.*utf'],
    # Time expressions
    'RULE-TIME-001': [r'CLOCK_TIME_PATTERN|_convert_clock_time_to_microseconds'],
    'RULE-TIME-002': [r'clock_time_match\.group.*frames|/\s*30\s*\*'],
    'RULE-TIME-003': [r'OFFSET_TIME_PATTERN|_convert_time_count_to_microseconds'],
    'RULE-TIME-004': [r'metric.*==.*"h"|MICROSECONDS_PER_UNIT.*hours'],
    'RULE-TIME-005': [r'metric.*==.*"m"|MICROSECONDS_PER_UNIT.*minutes'],
    'RULE-TIME-006': [r'metric.*==.*"s"|MICROSECONDS_PER_UNIT.*seconds'],
    'RULE-TIME-007': [r'metric.*==.*"ms"|MICROSECONDS_PER_UNIT.*milliseconds'],
    'RULE-TIME-008': [r'metric.*==.*"f"|frame.*offset'],
    'RULE-TIME-009': [r'metric.*==.*"t"|NotImplementedError.*tick'],
    'RULE-TIME-010': [r'\.get\("begin"\)|\.get\(.*begin|attrib.*begin'],
    'RULE-TIME-011': [r'\.get\("end"\)|\.get\(.*end|attrib.*end'],
    'RULE-TIME-012': [r'timeContainer|par\b.*parallel|seq\b.*sequential'],
    'RULE-TIME-013': [r'containment|constrain|clip.*time'],
    'RULE-TIME-014': [r'ttp:frameRate|attrib.*frameRate|get.*frameRate'],
    # Content elements
    'RULE-CONT-001': [r'find.*body|find_all.*body'],
    'RULE-CONT-002': [r'find_all.*"div"|new_tag.*"div"'],
    'RULE-CONT-003': [r'find_all.*"p"|new_tag.*"p"'],
    'RULE-CONT-004': [r'_convert_span_to_nodes|_recreate_span|name.*==.*"span"'],
    'RULE-CONT-005': [r'name.*==.*"br"|<br/?>'],
    'RULE-CONT-006': [r'<set\b|set.*element'],
    'RULE-CONT-007': [r'NavigableString|isinstance.*NavigableString|\.text'],
    'RULE-CONT-008': [r'nested.*div|div.*div.*nesting'],
    # Styling — use word-boundary patterns to avoid substring matches
    'RULE-STY-001': [r'tts:color|\.lower\(\).*==.*"tts:color"'],
    'RULE-STY-002': [r'tts:backgroundColor|background.*[Cc]olor'],
    'RULE-STY-003': [r'tts:fontSize|tts:fontsize|font-size'],
    'RULE-STY-004': [r'tts:fontFamily|tts:fontfamily|font-family'],
    'RULE-STY-005': [r'tts:fontStyle|tts:fontstyle|fontStyle.*italic'],
    'RULE-STY-006': [r'tts:fontWeight|tts:fontweight|fontWeight.*bold'],
    'RULE-STY-007': [r'tts:textAlign|tts:textalign|text-align'],
    'RULE-STY-008': [r'tts:textDecoration|tts:textdecoration|underline'],
    'RULE-STY-009': [r'(?<!\w)tts:direction(?!\w)'],
    'RULE-STY-010': [r'(?<!\w)(?:tts:writingMode|writingMode)(?!\w)'],
    # CRITICAL: tts:display must NOT match tts:displayAlign
    'RULE-STY-011': [r'(?<!\w)tts:display(?!Align)(?!\w)'],
    'RULE-STY-012': [r'tts:displayAlign|display.*[Aa]lign|displayAlign'],
    'RULE-STY-013': [r'(?<!\w)(?:tts:lineHeight|lineHeight)(?!\w)'],
    'RULE-STY-014': [r'(?<!\w)tts:opacity(?!\w)'],
    'RULE-STY-015': [r'(?<!\w)(?:tts:textOutline|textOutline)(?!\w)'],
    'RULE-STY-016': [r'tts:padding|Padding\.from_xml_attribute'],
    'RULE-STY-017': [r'tts:extent|Stretch\.from_xml_attribute'],
    'RULE-STY-018': [r'tts:origin|Point\.from_xml_attribute'],
    'RULE-STY-019': [r'(?<!\w)tts:overflow(?!\w)'],
    'RULE-STY-020': [r'(?<!\w)(?:tts:showBackground|showBackground)(?!\w)'],
    'RULE-STY-021': [r'(?<!\w)tts:visibility(?!\w)'],
    'RULE-STY-022': [r'(?<!\w)(?:tts:wrapOption|wrapOption)(?!\w)'],
    'RULE-STY-023': [r'(?<!\w)(?:tts:unicodeBidi|unicodeBidi)(?!\w)'],
    'RULE-STY-024': [r'(?<!\w)(?:tts:zIndex|zIndex)(?!\w)'],
    'RULE-STY-025': [r'named_colors|color_map|color.*lookup|COLOR_NAMES'],
    'RULE-STY-026': [r'parse_color|rgba_to_|hex_to_|int\(.*16\).*color'],
    'RULE-STY-027': [r'UnitEnum\.PIXEL|UnitEnum\.EM|UnitEnum\.PERCENT|UnitEnum\.CELL|Size\.from_string'],
    # Style model
    'RULE-SMOD-001': [r'find.*"styling"|find.*"style"'],
    'RULE-SMOD-002': [r'xml:id.*style|style.*xml:id'],
    'RULE-SMOD-003': [r'_get_style_reference_chain|style.*=.*attrib'],
    'RULE-SMOD-004': [r'_get_style_sources|nested_styles'],
    'RULE-SMOD-005': [r'inline.*style|dfxp_attrs.*tts:'],
    # Layout
    'RULE-LAY-001': [r'find.*"layout"|<layout'],
    'RULE-LAY-002': [r'find.*"region"|RegionCreator|_determine_region_id'],
    'RULE-LAY-003': [r'xml:id.*region|region.*xml:id'],
    'RULE-LAY-004': [r'default.*region|DFXP_DEFAULT_REGION'],
    # Metadata — match actual element/attribute access, not keywords
    'RULE-META-001': [r'find.*"metadata"|find_all.*"metadata"|ttm:title|ttm:desc|ttm:copyright'],
    'RULE-META-002': [r'find.*"ttm:title"|attrib.*ttm:title'],
    'RULE-META-003': [r'find.*"ttm:desc"|attrib.*ttm:desc'],
    'RULE-META-004': [r'find.*"ttm:copyright"|attrib.*ttm:copyright'],
    'RULE-META-005': [r'find.*"ttm:agent"|attrib.*ttm:agent'],
    'RULE-META-006': [r'find.*"ttm:role"|attrib.*ttm:role'],
    # Parameters — check for actual reading from document, not just keywords
    'RULE-PAR-001': [r'ttp:timeBase|attrib.*timeBase|get.*timeBase'],
    'RULE-PAR-002': [r'ttp:frameRate|attrib.*frameRate|get.*frameRate'],
    'RULE-PAR-003': [r'ttp:subFrameRate|attrib.*subFrameRate'],
    'RULE-PAR-004': [r'ttp:frameRateMultiplier|attrib.*frameRateMultiplier'],
    'RULE-PAR-005': [r'ttp:tickRate|attrib.*tickRate|get.*tickRate'],
    'RULE-PAR-006': [r'ttp:dropMode|attrib.*dropMode'],
    'RULE-PAR-007': [r'ttp:clockMode|attrib.*clockMode'],
    'RULE-PAR-008': [r'ttp:markerMode|attrib.*markerMode'],
    'RULE-PAR-009': [r'ttp:cellResolution|attrib.*cellResolution|cell.*resolution'],
    'RULE-PAR-010': [r'ttp:pixelAspectRatio|pixel.*aspect'],
    'RULE-PAR-011': [r'ttp:profile|attrib.*profile'],
    # Profile
    'RULE-PROF-001': [r'profile.*designat|profile.*uri'],
    'RULE-PROF-002': [r'transformation.*profile'],
    'RULE-PROF-003': [r'presentation.*profile'],
    'RULE-PROF-004': [r'profile.*element.*attribute|profile.*precedence'],
    'RULE-PROF-005': [r'feature.*designat|feature.*uri'],
    # Validation
    'RULE-VAL-001': [r'arg\.lower\(\).*==.*"tts:|attr_name\.lower\(\)|\.lower\(\).*==.*"tts:'],
    'RULE-VAL-002': [r'CaptionReadTimingError|Invalid timestamp|raise.*timing'],
    'RULE-VAL-003': [r'CaptionReadSyntaxError|raise.*syntax|raise.*parsing'],
    'RULE-VAL-004': [r'CaptionReadNoCaptions|empty caption|is_empty'],
    'RULE-VAL-005': [r'InvalidInputError|not.*unicode|isinstance.*str'],
}

missing_rules = []
found_rules = []

for rule_id, meta in sorted(all_rules.items()):
    # Skip rules covered in Phase 1
    if rule_id in deep_results:
        if deep_results[rule_id]['detected']:
            found_rules.append(rule_id)
        else:
            if not any(i['rule_id'] == rule_id for i in issues['validation_gaps']):
                missing_rules.append({
                    'rule_id': rule_id, 'name': meta['name'],
                    'level': meta['level'], 'status': 'MISSING',
                })
        continue

    patterns = specific_patterns.get(rule_id, [])
    if not patterns:
        missing_rules.append({
            'rule_id': rule_id, 'name': meta['name'],
            'level': meta['level'], 'status': 'NO_PATTERN',
        })
        continue

    found = any(re.search(p, impl, re.I) for p in patterns)
    if found:
        found_rules.append(rule_id)
    else:
        missing_rules.append({
            'rule_id': rule_id, 'name': meta['name'],
            'level': meta['level'], 'status': 'MISSING',
        })

issues['missing'] = missing_rules
must_missing = [r for r in missing_rules if r['level'] == 'MUST']
print(f"  Found: {len(found_rules)}/{len(all_rules)}, Missing: {len(missing_rules)} (MUST: {len(must_missing)})")

# ===== PHASE 3: COVERAGE ANALYSIS =====
print("\n" + "=" * 60)
print("PHASE 3: COVERAGE ANALYSIS")
print("=" * 60)

# Styling attributes: track read vs write separately
# Reader: _convert_style in DFXPReader
# Writer: _recreate_style (module-level function)
# Layout: LayoutInfoScraper._find_attribute
reader_section = ''
m = re.search(r'(class DFXPReader.*?)(?=class DFXPWriter)', base_content, re.DOTALL)
if m:
    reader_section = m.group(1)

# The module-level _recreate_style function (writer side)
recreate_fn = ''
m2 = re.search(r'^def _recreate_style\(content.*?(?=\n(?:def |class ))', base_content, re.DOTALL | re.MULTILINE)
if m2:
    recreate_fn = m2.group(0)

styling_coverage = {
    'tts:color':          {
        'read': bool(re.search(r'tts:color', reader_section, re.I)),
        'write': bool(re.search(r'tts:color', recreate_fn, re.I)),
        'note': 'Full round-trip (raw string passthrough)',
    },
    'tts:backgroundColor': {
        'read': bool(re.search(r'tts:backgroundcolor', reader_section, re.I)),
        'write': bool(re.search(r'tts:backgroundColor', recreate_fn + base_content)),
        'note': 'Round-trip via _convert_style + _recreate_style',
    },
    'tts:fontSize':       {
        'read': bool(re.search(r'tts:fontsize', reader_section, re.I)),
        'write': bool(re.search(r'tts:fontSize', recreate_fn)),
        'note': 'Full round-trip',
    },
    'tts:fontFamily':     {
        'read': bool(re.search(r'tts:fontfamily', reader_section, re.I)),
        'write': bool(re.search(r'tts:fontFamily', recreate_fn)),
        'note': 'Full round-trip',
    },
    'tts:fontStyle':      {
        'read': bool(re.search(r'tts:fontstyle', reader_section, re.I)),
        'write': bool(re.search(r'tts:fontStyle', recreate_fn)),
        'note': 'Full round-trip (italic only)',
    },
    'tts:fontWeight':     {
        'read': bool(re.search(r'tts:fontweight', reader_section, re.I)),
        'write': bool(re.search(r'fontWeight|bold', recreate_fn)),
        'note': 'READ-ONLY: Reader detects bold, writer silently drops it',
    },
    'tts:textAlign':      {
        'read': bool(re.search(r'tts:textalign', reader_section, re.I)),
        'write': bool(re.search(r'tts:textAlign', recreate_fn)),
        'note': 'Full round-trip (also via LayoutInfoScraper)',
    },
    'tts:textDecoration': {
        'read': bool(re.search(r'tts:textdecoration', reader_section, re.I)),
        'write': bool(re.search(r'textDecoration|underline', recreate_fn)),
        'note': 'READ-ONLY: Reader detects underline, writer silently drops it',
    },
    'tts:direction':      {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:writingMode':    {
        'read': bool(re.search(r'tts:writingMode|writingMode|_DFXP_WRITING_MODE_MAP', base_content, re.I)),
        'write': bool(re.search(r'tts:writingMode|writing_direction', base_content)),
        'note': 'Read via _DFXP_WRITING_MODE_MAP, write via _WRITING_DIRECTION_TO_DFXP',
    },
    'tts:display':        {'read': False, 'write': False, 'note': 'Not implemented (distinct from tts:displayAlign)'},
    'tts:displayAlign':   {
        'read': bool(re.search(r'tts:displayAlign', base_content)),
        'write': bool(re.search(r'tts:displayAlign', recreate_fn + base_content.split('class RegionCreator')[0] if 'class RegionCreator' in base_content else '')),
        'note': 'Full round-trip via LayoutInfoScraper + _create_external_alignment',
    },
    'tts:lineHeight':     {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:opacity':        {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:textOutline':    {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:padding':        {
        'read': bool(re.search(r'tts:padding', base_content)),
        'write': bool(re.search(r'tts:padding', base_content)),
        'note': 'Full round-trip via LayoutInfoScraper + _convert_layout_to_attributes',
    },
    'tts:extent':         {
        'read': bool(re.search(r'tts:extent', base_content)),
        'write': bool(re.search(r'tts:extent', base_content)),
        'note': 'Full round-trip via LayoutInfoScraper. Root tt extent must be in pixels.',
    },
    'tts:origin':         {
        'read': bool(re.search(r'tts:origin', base_content)),
        'write': bool(re.search(r'tts:origin', base_content)),
        'note': 'Full round-trip via LayoutInfoScraper',
    },
    'tts:overflow':       {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:showBackground': {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:visibility':     {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:wrapOption':     {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:unicodeBidi':    {'read': False, 'write': False, 'note': 'Not implemented'},
    'tts:zIndex':         {'read': False, 'write': False, 'note': 'Not implemented'},
}

sty_read = sum(1 for s in styling_coverage.values() if s['read'])
sty_write = sum(1 for s in styling_coverage.values() if s['write'])
sty_roundtrip = sum(1 for s in styling_coverage.values() if s['read'] and s['write'])
sty_readonly = sum(1 for s in styling_coverage.values() if s['read'] and not s['write'])
print(f"  Styling: {sty_read}/24 read, {sty_write}/24 write, {sty_roundtrip}/24 round-trip, {sty_readonly} read-only")

# Time expression formats
time_coverage = {
    'Clock-time fractional (HH:MM:SS.sss)': {
        'supported': bool(re.search(r'sub_frames', base_content)),
        'note': 'Via CLOCK_TIME_PATTERN sub_frames group, .ljust(3, "0")',
    },
    'Clock-time frames (HH:MM:SS:FF)': {
        'supported': bool(re.search(r'clock_time_match.*frames', base_content)),
        'note': 'Parsed with dynamic frame rate from ttp:frameRate' if bool(re.search(r'_effective_frame_rate|frame_rate\s*\*', base_content)) else 'Parsed but hardcoded /30',
    },
    'Offset hours (Nh)': {
        'supported': bool(re.search(r'metric.*==.*"h"', base_content)),
        'note': 'Supported',
    },
    'Offset minutes (Nm)': {
        'supported': bool(re.search(r'metric.*==.*"m"', base_content)),
        'note': 'Supported',
    },
    'Offset seconds (Ns)': {
        'supported': bool(re.search(r'metric.*==.*"s"', base_content)),
        'note': 'Supported',
    },
    'Offset milliseconds (Nms)': {
        'supported': bool(re.search(r'metric.*==.*"ms"', base_content)),
        'note': 'Supported',
    },
    'Offset frames (Nf)': {
        'supported': bool(re.search(r'metric.*==.*"f"', base_content)),
        'note': 'Parsed with dynamic frame rate from ttp:frameRate' if bool(re.search(r'_effective_frame_rate|frame_rate\s*\*', base_content)) else 'Parsed but hardcoded /30',
    },
    'Offset ticks (Nt)': {
        'supported': bool(re.search(r'tick_rate|ttp:tickRate', base_content)),
        'note': 'Supported via ttp:tickRate (OCTO-11531)' if bool(re.search(r'tick_rate|ttp:tickRate', base_content)) else 'Raises NotImplementedError',
    },
}

time_supported = sum(1 for t in time_coverage.values() if t['supported'])
print(f"  Time formats: {time_supported}/8 ({8 - time_supported} missing/broken)")

# Content elements
content_elements = {
    'body':     {'read': bool(re.search(r'find.*"body"', base_content)), 'write': bool(re.search(r'<body|new_tag.*"body"', base_content))},
    'div':      {'read': bool(re.search(r'find_all.*"div"', base_content)), 'write': bool(re.search(r'new_tag.*"div"', base_content))},
    'p':        {'read': bool(re.search(r'find_all.*"p"', base_content)), 'write': bool(re.search(r'new_tag.*"p"', base_content))},
    'span':     {'read': bool(re.search(r'_convert_span_to_nodes', base_content)), 'write': bool(re.search(r'_recreate_span', base_content))},
    'br':       {'read': bool(re.search(r'name.*==.*"br"', base_content)), 'write': bool(re.search(r'<br/?>', base_content))},
    'set':      {'read': False, 'write': False},
    'styling':  {'read': bool(re.search(r'find.*"styling"', base_content)), 'write': bool(re.search(r'find.*"styling".*append', base_content))},
    'style':    {'read': bool(re.search(r'find_all.*"style"', base_content)), 'write': bool(re.search(r'_recreate_styling_tag', base_content))},
    'layout':   {'read': bool(re.search(r'LayoutInfoScraper|layout_info', base_content)), 'write': bool(re.search(r'find.*"layout".*append|layout_section', base_content))},
    'region':   {'read': bool(re.search(r'_determine_region_id', base_content)), 'write': bool(re.search(r'_create_unique_regions', base_content))},
    'metadata': {'read': False, 'write': False},
}

elem_read = sum(1 for e in content_elements.values() if e['read'])
elem_write = sum(1 for e in content_elements.values() if e['write'])
print(f"  Content elements: {elem_read}/11 read, {elem_write}/11 write")

# Parameter attributes — check if actually read FROM document
param_coverage = {
    'ttp:timeBase':             {'read': False, 'note': 'Not read (media assumed)'},
    'ttp:frameRate':            {'read': bool(re.search(r'ttp:frameRate|frame_rate', base_content)), 'note': 'Read from <tt> element (OCTO-11531)' if bool(re.search(r'ttp:frameRate', base_content)) else 'Not read'},
    'ttp:subFrameRate':         {'read': False, 'note': 'Not implemented'},
    'ttp:frameRateMultiplier':  {'read': bool(re.search(r'frameRateMultiplier', base_content)), 'note': 'Read from <tt> element (OCTO-11531)' if bool(re.search(r'frameRateMultiplier', base_content)) else 'Not implemented'},
    'ttp:tickRate':             {'read': bool(re.search(r'ttp:tickRate|tick_rate', base_content)), 'note': 'Read from <tt> element (OCTO-11531)' if bool(re.search(r'tickRate', base_content)) else 'Not read'},
    'ttp:dropMode':             {'read': False, 'note': 'Not implemented'},
    'ttp:clockMode':            {'read': False, 'note': 'Not implemented'},
    'ttp:markerMode':           {'read': False, 'note': 'Not implemented'},
    'ttp:cellResolution':       {'read': False, 'note': 'Not read (hardcoded 32x15 defaults in geometry.py)'},
    'ttp:pixelAspectRatio':     {'read': False, 'note': 'Not implemented'},
    'ttp:profile':              {'read': False, 'note': 'Not implemented'},
}

param_read = sum(1 for p in param_coverage.values() if p['read'])
print(f"  Parameter attributes: {param_read}/11 read from document")

# Length unit support (from geometry.py)
unit_coverage = {
    'px (pixel)': bool(re.search(r'UnitEnum\.PIXEL|"px"', geometry_content)),
    'em':         bool(re.search(r'UnitEnum\.EM|"em"', geometry_content)),
    '% (percent)': bool(re.search(r'UnitEnum\.PERCENT|"%"', geometry_content)),
    'c (cell)':   bool(re.search(r'UnitEnum\.CELL|"c"', geometry_content)),
    'pt (point)': bool(re.search(r'UnitEnum\.PT|"pt"', geometry_content)),
}

units_supported = sum(1 for u in unit_coverage.values() if u)
print(f"  Length units: {units_supported}/5")

# ===== PHASE 4: TEST COVERAGE =====
print("\n" + "=" * 60)
print("PHASE 4: TEST COVERAGE")
print("=" * 60)

test_files = glob.glob('tests/**/test*dfxp*.py', recursive=True)
def _read(p):
    with open(p) as _fh: return _fh.read()
tests = "\n".join(_read(f) for f in test_files if os.path.exists(f))
print(f"  Test files: {len(test_files)} ({len(tests)} chars)")

test_checks = {
    'RULE-DOC-001': [r'def test.*detect|def test.*root|def test.*tt\b|def test.*namespace'],
    'RULE-DOC-003': [r'def test.*lang'],
    'RULE-TIME-001': [r'def test.*time|def test.*clock|def test.*timestamp'],
    'RULE-TIME-002': [r'def test.*frame'],
    'RULE-STY-001': [r'def test.*color'],
    'RULE-STY-003': [r'def test.*font.*size'],
    'RULE-STY-006': [r'def test.*bold|def test.*font.*weight'],
    'RULE-STY-007': [r'def test.*align'],
    'RULE-STY-008': [r'def test.*underline|def test.*text.*decoration'],
    'RULE-LAY-002': [r'def test.*region'],
    'RULE-SMOD-003': [r'def test.*style.*ref|def test.*style.*inherit|def test.*cascade'],
    'IMPL-003': [r'def test.*style.*resolv|def test.*cascade|def test.*inherit'],
    'IMPL-004': [r'def test.*region'],
    'IMPL-008': [r'def test.*escap|def test.*encod|def test.*write'],
}

for rid, patterns in test_checks.items():
    if not any(re.search(p, tests, re.I) for p in patterns):
        name = all_rules.get(rid, {}).get('name', rid)
        issues['test_gaps'].append({'rule_id': rid, 'name': name, 'status': 'NO_TEST'})
        print(f"  {rid}: NO TEST")
    else:
        print(f"  {rid}: HAS TEST")

# ===== PHASE 5: GENERATE REPORT =====
print("\n" + "=" * 60)
print("PHASE 5: GENERATE REPORT")
print("=" * 60)

os.makedirs("ai_artifacts/compliance_checks/dfxp", exist_ok=True)
date = datetime.now().strftime("%Y-%m-%d")
path = f"ai_artifacts/compliance_checks/dfxp/compliance_report_{date}.md"

total_issues = sum(len(v) for v in issues.values())
must_issues = (len([i for i in issues['validation_gaps'] if i.get('severity') == 'MUST']) +
               len([i for i in issues['partial_validation'] if i.get('severity') == 'MUST']) +
               len(must_missing))

sanity_section = ""
if stale_warnings:
    sanity_section = "\n**STALE PATTERN WARNING**: The following expected code landmarks were not found. Some findings below may report features as 'missing' when they have actually been renamed or moved:\n"
    for w in stale_warnings:
        sanity_section += f"- {w}\n"
    sanity_section += "\n"

report = f"""# DFXP/TTML EXHAUSTIVE Compliance Report

**Generated**: {date}
**Spec**: {latest_spec}
**Analysis**: Deep Validation + Quality Gaps + Systematic Rules + Coverage + Tests
**Implementation files**: {', '.join(f for f in impl_files if os.path.exists(f))}
{sanity_section}
---

## Executive Summary

**Rules checked**: {len(all_rules)}/{len(all_rules)} (100%)
**Total issues**: {total_issues}
**MUST violations**: {must_issues}

| Category | Count |
|----------|-------|
| Validation gaps | {len(issues['validation_gaps'])} |
| Implementation quality gaps | {len(quality_gaps)} |
| Implementation caveats | {len(issues['partial_validation']) - len(quality_gaps)} |
| Missing rules | {len(issues['missing'])} (MUST: {len(must_missing)}) |
| Test gaps | {len(issues['test_gaps'])} |

---

## 1. Validation Gaps ({len(issues['validation_gaps'])})

Rules that are not properly implemented or validated.

"""

for g in issues['validation_gaps']:
    report += f"### {g['rule_id']}: {g['name']}\n"
    report += f"- **Status**: {g['status']}\n"
    report += f"- **Severity**: {g['severity']}\n"
    report += f"- **Note**: {g['note']}\n\n"

report += f"""---

## 2. Implementation Quality Gaps ({len(quality_gaps)})

Features that exist but are incomplete compared to a reference TTML parser.
These represent silent data loss or missing validation that affects interoperability.

"""

for qg in quality_gaps:
    report += f"### {qg['id']}: {qg['name']}\n"
    report += f"- **Severity**: {qg['severity']}\n"
    report += f"- **Note**: {qg['note']}\n\n"

# Filter out quality gaps from partial_validation for section 3
non_quality_caveats = [p for p in issues['partial_validation'] if not p['rule_id'].startswith('QUAL-')]

report += f"""---

## 3. Implementation Caveats ({len(non_quality_caveats)})

Rules implemented but with significant limitations.

"""

for p in non_quality_caveats:
    report += f"### {p['rule_id']}: {p['name']}\n"
    report += f"- **Status**: {p['status']}\n"
    report += f"- **Note**: {p['note']}\n\n"

report += f"""---

## 4. Missing Rules ({len(issues['missing'])})

### MUST Rules ({len(must_missing)})

"""

for r in must_missing:
    report += f"- **{r['rule_id']}**: {r['name']} ({r['status']})\n"

should_missing = [r for r in issues['missing'] if r['level'] == 'SHOULD']
may_missing = [r for r in issues['missing'] if r['level'] in ('MAY', 'MUST NOT')]

report += f"\n### SHOULD Rules ({len(should_missing)})\n\n"
for r in should_missing:
    report += f"- **{r['rule_id']}**: {r['name']} ({r['status']})\n"

report += f"\n### MAY/MUST NOT Rules ({len(may_missing)})\n\n"
for r in may_missing:
    report += f"- **{r['rule_id']}**: {r['name']} ({r['status']})\n"

report += f"""
---

## 5. Coverage Analysis

### Styling Attributes ({sty_read}/24 read, {sty_write}/24 write, {sty_roundtrip}/24 round-trip)

| Attribute | Read | Write | Round-trip | Note |
|-----------|------|-------|------------|------|
"""

for attr, info in styling_coverage.items():
    r = "Yes" if info['read'] else "No"
    w = "Yes" if info['write'] else "No"
    rt = "Yes" if info['read'] and info['write'] else "No"
    report += f"| `{attr}` | {r} | {w} | {rt} | {info['note']} |\n"

report += f"""
### Time Expression Formats ({time_supported}/8)

| Format | Supported | Note |
|--------|-----------|------|
"""

for fmt, info in time_coverage.items():
    s = "Yes" if info['supported'] else "No"
    report += f"| {fmt} | {s} | {info['note']} |\n"

report += f"""
### Content Elements ({elem_read}/11 read, {elem_write}/11 write)

| Element | Read | Write |
|---------|------|-------|
"""

for elem, info in content_elements.items():
    r = "Yes" if info['read'] else "No"
    w = "Yes" if info['write'] else "No"
    report += f"| `<{elem}>` | {r} | {w} |\n"

report += f"""
### Parameter Attributes ({param_read}/11 read from document)

| Attribute | Read | Note |
|-----------|------|------|
"""

for attr, info in param_coverage.items():
    r = "Yes" if info['read'] else "No"
    report += f"| `{attr}` | {r} | {info['note']} |\n"

report += f"""
### Length Units ({units_supported}/5)

| Unit | Supported |
|------|-----------|
"""

for unit, supported in unit_coverage.items():
    s = "Yes" if supported else "No"
    report += f"| {unit} | {s} |\n"

report += f"""
---

## 6. Test Gaps ({len(issues['test_gaps'])})

"""

for t in issues['test_gaps']:
    report += f"- **{t['rule_id']}**: {t['name']}\n"

report += f"""
---

## 7. Key Findings

"""

# Generate dynamic key findings
key_findings = []

# Frame rate
if has_dynamic_framerate:
    key_findings.append("1. **Frame rate is dynamic (OCTO-11531)**: Reads `ttp:frameRate` and `ttp:frameRateMultiplier` from <tt> element. Clock-time frames and offset frames use the document's declared rate.")
else:
    key_findings.append("1. **Frame rate hardcoded to /30**: Both clock-time frames (HH:MM:SS:FF) and offset frames (Nf) divide by 30. The code never reads `ttp:frameRate`.")

# Tick time
if bool(re.search(r'tick_rate|ttp:tickRate', base_content)):
    key_findings.append("2. **Tick time implemented (OCTO-11531)**: `_convert_time_count_to_microseconds` computes tick metric using `ttp:tickRate` from document.")
else:
    key_findings.append("2. **Tick time raises NotImplementedError**: Recognizes `t` metric but raises instead of computing.")

# Parameter attributes
key_findings.append(f"3. **ttp: parameters read from document**: {param_read}/11 TTML parameter attributes read. Remaining use hardcoded defaults.")

# Bold/underline
key_findings.append(f"4. **fontWeight (bold)**: read={'YES' if has_bold_read else 'NO'}, write={'YES' if has_bold_in_recreate else 'NO'}. **textDecoration (underline)**: read={'YES' if has_underline_read else 'NO'}, write={'YES' if has_underline_in_recreate else 'NO'}.")
key_findings.append("5. **tts:display is NOT implemented** (distinct from tts:displayAlign which IS implemented).")
key_findings.append("6. **xml:lang reads with silent fallback**: Falls back to DEFAULT_LANGUAGE_CODE silently. No BCP-47 validation.")
key_findings.append("7. **Color passed through as raw string**: `tts:color` is read and written but never parsed or validated.")
key_findings.append("8. **Style chaining IS implemented**: `_get_style_reference_chain` follows style references recursively.")
key_findings.append("9. **Region resolution IS implemented**: Full ancestor→descendant lookup via `_determine_region_id`.")

if has_regex_detect:
    key_findings.append("10. **detect() uses regex (OCTO-11531)**: Requires both `<tt>` and `</tt>` to eliminate false positives on non-TTML content.")
else:
    key_findings.append("10. **detect() uses substring check**: Matches anywhere in content, not proper root validation.")

key_findings.append(f"11. **{units_supported} length units supported**: px, em, %, c (cell), pt — all via `Size.from_string()` in geometry.py.")

if has_bg_write:
    key_findings.append("12. **tts:backgroundColor IS supported**: Writer emits on spans/styles from WebVTT/SAMI sources (OCTO-11514).")
else:
    key_findings.append("12. **tts:backgroundColor NOT supported**: Common TTML attribute entirely missing.")

# tts:writingMode
has_writing_mode_write = bool(re.search(r'tts:writingMode|writingMode', writer_content))
if has_writing_mode_write:
    key_findings.append("13. **tts:writingMode IS supported on write (OCTO-11514)**: Writer emits on regions for vertical text.")
else:
    key_findings.append("13. **tts:writingMode not implemented**.")

key_findings.append(f"14. **{len(quality_gaps)} quality gaps vs reference parser**: No structured diagnostics, timeContainer=seq not supported, unknown tts: attrs silently dropped, no xml:space handling.")

for f in key_findings:
    report += f + "\n"

report += f"""
---

**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M')}
**Rules**: {len(all_rules)} | **Found**: {len(found_rules)} | **Missing**: {len(issues['missing'])}
**Quality gaps**: {len(quality_gaps)} | **Styling**: {sty_roundtrip}/24 round-trip ({sty_readonly} read-only) | **Timing**: {time_supported}/8 | **Elements**: {elem_read}/11 read | **Params**: {param_read}/11
"""

with open(path, 'w') as _f: _f.write(report)
print(f"\n Report: {path}")
print(f"   Total issues: {total_issues} ({must_issues} MUST)")

Execute the above Python script directly (no external files needed beyond spec and implementation).

---

Key improvements over previous version

1. Phase 1.5 quality gaps: 10 checks for implementation-quality issues beyond regex existence (no diagnostics, timeContainer=seq, xml:space, etc.)
2. No tts:display false positive: Uses negative lookahead (?!Align) so tts:display pattern does NOT match tts:displayAlign
3. Read-only attributes correctly identified: fontWeight and textDecoration tracked as read-only (reader detects, writer drops)
4. xml:lang correctly assessed: Silent fallback to "en", no BCP-47 validation
5. Expanded file scope: Includes geometry.py for unit parsing, Layout, Size, Padding classes
6. Per-rule specific_patterns: Matches actual function names (_convert_clock_time_to_microseconds, _get_style_reference_chain) not broad keywords
7. Read/write distinction for all coverage: Styling, elements, parameters tracked for read vs write separately
8. NotImplementedError for ticks correctly reported: Not counted as "implemented"
9. Frame rate analysis: Clearly reports hardcoded /30 for both clock-time and offset frames
10. Zero ttp: parameters: Explicitly reports that no TTML parameter attributes are read from documents
11. Key findings section: 14 accurate assessments with specific code references

---

Success Criteria

• All spec rules individually checked with per-rule patterns
• Deep validation for 10 critical rules at function level
• Styling attributes tracked as read/write/round-trip (not just keyword match)
• Time formats with accurate implementation status (hardcoded /30 flagged)
• Content elements tracked as read/write
• Parameter attributes checked for actual document reading (not just keyword)
• Length unit support verified against geometry.py
• No false positives (tts:display ≠ tts:displayAlign)
• No false assessments (fontWeight/textDecoration = read-only, not round-trip)
• Key findings narrative for actionable summary