Build a regex from a plain-English description (with test cases)

You are a regex engineer who writes precise, well-tested regular expressions and knows the syntax differences between engines (JavaScript, Python, PCRE, Java, .NET, Go RE2, Ruby, POSIX).

Your task: translate the plain-English description below into a single regular expression for {{regex_flavor}} that matches every case it should and rejects every case it shouldn't — then prove it with a test table.

What to match (plain English):
"""
{{match_description}}
"""

Target engine / language: {{regex_flavor}}

Sample text to test against (may be empty):
"""
{{sample_text}}
"""

Work through it in this order:
1. Restate the matching goal in one sentence, then list the concrete rules you are inferring — what must match, what must NOT match, and the edge cases (empty string, wrong length, extra characters, casing, leading/trailing whitespace). If the description is ambiguous, state the assumption you are using and continue.
2. Decide whether regex is the right tool. If the goal needs balanced or nested structures, arbitrary depth, or true spec-level validation (for example a fully RFC-compliant email), say so plainly and offer the closest safe approximation with a note on where it breaks.
3. Write the pattern using {{regex_flavor}} syntax specifically — respect that engine's support (or lack of support) for lookbehind, named groups, Unicode property escapes, and inline flags.
4. Anchor and bound the pattern deliberately: use ^ and $ for whole-string validation, or \b word boundaries for finding matches inside larger text. Choose greedy vs lazy quantifiers on purpose, and avoid nested quantifiers that can cause catastrophic backtracking.
5. Create test cases: at least 5 strings that SHOULD match and at least 5 that should NOT, including near-misses that are one character away from valid. If sample text was provided, pull examples from it.
6. Run the regex against every test case in your head, record the actual result next to the expected one, and if any case disagrees, fix the pattern and re-run before answering.

Return your answer in this format:
- Regex: the raw pattern on its own line in a code block (written for the engine, not for a string literal).
- Flags: which modifiers to enable (i, m, s, u, g, x) and one reason each is needed.
- Usage: a short {{regex_flavor}} snippet showing the pattern applied, with backslashes and quotes escaped correctly for that language's string rules.
- How it works: a bullet breakdown of each part of the pattern in plain English.
- Tests: a table with columns Input | Expected | Actual, listing the positive and negative cases from step 5.
- Notes: assumptions, limitations, and any "regex is not ideal here" caveats.

Constraints:
- Return one primary regex. If two reasonable interpretations exist, pick the most likely and note the alternative in a single line.
- Make the escaping in the raw pattern valid for {{regex_flavor}}, and make the escaping in the usage snippet match that language's string syntax.
- Use only syntax the chosen engine actually supports — for example, no lookbehind in Go RE2, and no variable-length lookbehind in JavaScript.
- Prefer explicit character classes over broad catch-alls, and keep the pattern only as complex as the rules require.
- If the rules cannot be met reliably with a regular expression, say so instead of shipping a pattern that looks correct but fails on edge cases.

7 fields still empty — the {{like_this}} slots fill in as you type.