Regex: what do $, \Z, \z and lookbehind do before a trailing newline in JavaScript, Python re and grep -E/sed on macOS?

A log-validation agent checks lines with a pattern like ^[a-z]+$ and gets different answers depending on the engine, specifically when the input ends in a newline (for example read from a file without stripping, or from a shell variable). It also uses lookbehind and non-greedy alternation in patterns it ports between a Node service, a Python script and shell one-liners. I do not know exactly where the engines on a stock macOS machine disagree and I do not trust my memory of the docs. Engines to cover: JavaScript in node (RegExp), Python 3 re, macOS grep -E (BSD), and macOS sed -E. Questions: (1) does 'abc\n' match ^abc$, and does 'abc\n' match with Python's \Z, with Python's $, with JS $ with and without the m flag? What is the JS and Python way to anchor strictly at the end of the whole string (JS has no \Z; Python has \Z, and does it have \z in this version)? (2) is a fixed-width and a variable-width lookbehind (?<=a|bc) accepted in each engine, and is lookahead (?=) accepted by grep -E and sed -E? (3) for 'xaby' with patterns (a|ab)(c|bcd)? style alternation, which alternative wins in each engine (leftmost-first versus POSIX leftmost-longest), shown with the exact matched text? Mention the engine versions.

How an answer is checked: A script or list of short commands (node -e, python3 -c, printf | grep -E, printf | sed -E) that prints a table with one row per engine and one column per question (1) to (3), with the exact output of each command and the versions printed (node -v, python3 -V, grep -V, sed --version or the macOS equivalent). It must state for each cell match or no match, or the matched text, and name any pattern an engine rejects with its error message.

Versions: node v26.12.1 (V8 RegExp), Python 3.15.2 re, macOS /usr/bin/grep 2.6.0-FreeBSD (BSD grep, GNU compatible), macOS /usr/bin/sed (BSD, no --version flag: 'illegal option -- -'), Darwin arm64. Note: an interactive shell here may alias grep to another tool; use /usr/bin/grep. Every cell below was produced by a command I ran. Q1 input 'abc\n' (string ends in one newline): - JS /^abc$/ no match; /^abc$/m match; strict end of whole string: plain $ without m already means end of input, so no \Z is needed. /^abc(?![\s\S])/ also no match. \Z and \z with the u flag: SyntaxError 'Invalid regular expression: /^abc\Z/u: Invalid escape'; without u they are literal Z and z (no match on 'abc\n'). - Python re.search: ^abc$ match (also with re.M); ^abc\Z no match; ^abc\z is accepted in 3.15 and gives no match on 'abc\n' but matches 'abc'. re.fullmatch('abc$','abc\n') is False, fullmatch('abc\n') True. Strict anchor: \Z (or \z in 3.14+). - grep -E and sed -E are line based: the newline is the separator, never part of the line, so printf 'abc\n' | grep -E '^abc$' matches and sed -E 's/^abc$/MATCHED/' prints MATCHED. With 'abc\r\n' grep -c gives 0 (the CR is part of the line). \Z is not an anchor: 'abc\n' | grep -E 'abc\Z' rc=1, 'abcZ' matches (literal Z); sed 's/abc\Z/X/' on 'abcZ' gives X. In sed the pattern space only has a newline after N: printf 'abc\n\n' | sed -E 'N;s/abc\n$/M2/' gives M2. Q2 lookbehind and lookahead (inputs ab, bcd): - JS: (?<=a)b match 'b'; (?<=a|bc)d match 'd' (variable width accepted); a(?=b) match 'a'. - Python: (?<=a)b match; (?<=a|bc)d re.error: look-behind requires fixed-width pattern; a(?=b) match. - grep -E: all three rejected: 'grep: repetition-operator operand invalid' (rc 2). - sed -E: all three rejected: 'RE error: repetition-operator operand invalid' (the ? after ( has nothing to repeat). Q3 alternation, leftmost match text: xaby, (a|ab)(c|bcd)?: JS 'a', Python 'a', grep -oE 'ab', sed 's/../[&]/' x[ab]y. xaby, (ab|a)(c|bcd)?: JS 'ab', Python 'ab', grep 'ab', sed x[ab]y. xabcd, (a|ab)(c|bcd)?: JS 'abcd', Python 'abcd', grep 'abcd', sed x[abcd]. (first alt a, then bcd) xabcd, (ab|a)(c|bcd)?: JS 'abc', Python 'abc', grep 'abcd', sed x[abcd]. Plain a|ab on xabcd: JS and Python 'a'; grep and sed 'ab'. ab|a: all 'ab'. Rule: JS and Python are leftmost-first (first alternative that lets the whole pattern succeed wins, order matters); BSD grep -E and sed -E are POSIX leftmost-longest, order of alternatives does not matter. Table (cell = result): engine | 'abc\n' ^abc$ | strict end | variable lookbehind | lookahead | xaby (a|ab)(c|bcd)? JS | no match (m: match) | $ without m | accepted | accepted | a Python | match | \Z or \z | re.error fixed-width | accepted | a grep -E | match (per line) | none needed | rejected | rejected | ab sed -E | match (per line) | none needed | rejected | rejected | ab

Method: Ran node -e, python3 -c and /usr/bin/grep -E, /usr/bin/sed -E one-liners from scratch in a scratch folder on Node v26.12.1, Python 3.15.2, BSD grep 2.6.0-FreeBSD and macOS sed on Darwin arm64; printed each cell, errors captured from stderr. Not run: GNU grep/sed, PCRE grep -P, other Python or Node versions.