perf: WrapLineAnchor for (?m)^ patterns — O(1) line-start check instead of NFA (#148)

WrapIncomplete forced NFA verification for every prefilter candidate on
(?m)^ multiline patterns, causing 7x regression on ARM64 (LogParser 2s->14s).

WrapLineAnchor checks line-start in O(1) (pos==0 || haystack[pos-1]==newline),
keeps IsComplete()=true so Teddy returns matches directly without NFA.

LangArena methods: 755ms -> <1ms.
multiline_php on macOS ARM64: 63ms -> 1.55ms (41x faster).
Stdlib compat: 38/38 PASS (was 34/38 with 4 skipped).

Author: kolkov

CHANGELOG.md

@@ -12,6 +12,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ARM NEON SIMD support (Go 1.26 `simd/archsimd` intrinsics — [#120](https://github.com/coregx/coregex/issues/120))
 - SIMD prefilter for CompositeSequenceDFA (#83)
 
+## [0.12.16] - 2026-03-21
+
+### Performance
+- **`WrapLineAnchor` for `(?m)^` patterns** — `WrapIncomplete` forced NFA
+  verification for every prefilter candidate on multiline line-anchor patterns,
+  causing 7x regression on ARM64 (LogParser 2s → 14s, reported by @kostya).
+  `WrapLineAnchor` checks line-start position in O(1) (`pos==0 || haystack[pos-1]=='\n'`),
+  keeping `IsComplete()=true` so Teddy returns matches directly without NFA.
+  LangArena `methods`: 755ms → **<1ms**. `multiline_php` on macOS ARM64:
+  63ms → **1.55ms** (41x faster).
+
+### Fixed
+- **Stdlib compatibility** — `WrapLineAnchor` also fixes 4 previously skipped
+  stdlib compat test patterns (`http_methods`, `la_methods`, `la_suspicious`,
+  `dot_star`). Test now **38/38 PASS, 0 SKIP**.
+
 ## [0.12.15] - 2026-03-21
 
 ### Performance

meta/compile.go

@@ -637,17 +637,50 @@ func adjustForAnchors(pf prefilter.Prefilter, strategy Strategy, re *syntax.Rege
 	if !hasAnchorAssertions(re) {
 		return pf, strategy
 	}
-	// Mark prefilter incomplete — engine must verify anchor constraints
+
+	hasMultilineAnchor := hasMultilineLineAnchor(re)
+
 	if pf != nil && pf.IsComplete() {
-		pf = prefilter.WrapIncomplete(pf)
+		if hasMultilineAnchor && !hasNonLineAnchors(re) {
+			// (?m)^ with complete literals and NO other anchors (\b, $):
+			// Use line-anchor wrapper — O(1) line-start check per candidate.
+			// This keeps IsComplete()=true so Teddy can return matches directly
+			// without expensive NFA verification.
+			pf = prefilter.WrapLineAnchor(pf)
+		} else {
+			// Other anchors (\b, $) or mixed anchors:
+			// Mark incomplete — engine must verify with NFA/DFA.
+			pf = prefilter.WrapIncomplete(pf)
+		}
 	}
+
 	// DFA can't verify (?m)^ multiline line anchors — use NFA
-	if strategy == UseDFA && hasMultilineLineAnchor(re) {
+	if strategy == UseDFA && hasMultilineAnchor {
 		strategy = UseNFA
 	}
 	return pf, strategy
 }
 
+// hasNonLineAnchors checks if the pattern has anchors other than (?m)^ line start.
+// Returns true for \b, $, \A, \z, or non-multiline ^.
+func hasNonLineAnchors(re *syntax.Regexp) bool {
+	if re == nil {
+		return false
+	}
+	switch re.Op {
+	case syntax.OpBeginLine:
+		return false // (?m)^ is fine
+	case syntax.OpEndLine, syntax.OpEndText, syntax.OpBeginText, syntax.OpWordBoundary, syntax.OpNoWordBoundary:
+		return true
+	}
+	for _, sub := range re.Sub {
+		if hasNonLineAnchors(sub) {
+			return true
+		}
+	}
+	return false
+}
+
 // buildSearchStateConfig extracts all DFA references needed for per-search caches.
 // Strategy-specific DFAs come from reverse searchers (which have their own DFAs).
 func buildSearchStateConfig(nfaEngine *nfa.NFA, numCaptures int, engines strategyEngines, strategy Strategy) searchStateConfig {

prefilter/wrap.go

@@ -33,3 +33,50 @@ func (w *incompleteWrapper) HeapBytes() int {
 func (w *incompleteWrapper) IsFast() bool {
 	return w.inner.IsFast()
 }
+
+// lineAnchorWrapper wraps a prefilter and adds (?m)^ line-start verification.
+// Instead of marking complete=false (which forces expensive NFA verification),
+// this wrapper checks that each candidate is at line start (pos==0 || haystack[pos-1]=='\n').
+// This gives O(1) verification per candidate vs O(n*states) NFA.
+type lineAnchorWrapper struct {
+	inner Prefilter
+}
+
+// WrapLineAnchor wraps a complete prefilter to add (?m)^ line-start checking.
+// The wrapper's Find skips candidates not at line boundaries, and IsComplete
+// returns true (no NFA verification needed — line check is sufficient).
+func WrapLineAnchor(pf Prefilter) Prefilter {
+	return &lineAnchorWrapper{inner: pf}
+}
+
+func (w *lineAnchorWrapper) Find(haystack []byte, start int) int {
+	pos := start
+	for {
+		candidate := w.inner.Find(haystack, pos)
+		if candidate == -1 {
+			return -1
+		}
+		// Verify (?m)^ — candidate must be at start of line
+		if candidate == 0 || haystack[candidate-1] == '\n' {
+			return candidate
+		}
+		// Not at line start — skip to next candidate
+		pos = candidate + 1
+	}
+}
+
+func (w *lineAnchorWrapper) IsComplete() bool {
+	return w.inner.IsComplete()
+}
+
+func (w *lineAnchorWrapper) LiteralLen() int {
+	return w.inner.LiteralLen()
+}
+
+func (w *lineAnchorWrapper) HeapBytes() int {
+	return w.inner.HeapBytes()
+}
+
+func (w *lineAnchorWrapper) IsFast() bool {
+	return w.inner.IsFast()
+}